shaka-player 3.3.4 → 4.0.0

package/lib/offline/storage.js

@@ -7,7 +7,6 @@
 goog.provide('shaka.offline.Storage');
 
 goog.require('goog.asserts');
-goog.require('shaka.Deprecate');
 goog.require('shaka.Player');
 goog.require('shaka.log');
 goog.require('shaka.media.DrmEngine');
@@ -25,11 +24,9 @@ goog.require('shaka.util.ArrayUtils');
 goog.require('shaka.util.ConfigUtils');
 goog.require('shaka.util.Destroyer');
 goog.require('shaka.util.Error');
-goog.require('shaka.util.Functional');
 goog.require('shaka.util.IDestroyable');
 goog.require('shaka.util.Iterables');
 goog.require('shaka.util.MimeUtils');
-goog.require('shaka.util.Mutex');
 goog.require('shaka.util.Platform');
 goog.require('shaka.util.PlayerConfiguration');
 goog.require('shaka.util.StreamUtils');
@@ -195,22 +192,10 @@ shaka.offline.Storage = class {
     if (arguments.length == 2 && typeof(config) == 'string') {
       config = shaka.util.ConfigUtils.convertToConfigObject(config, value);
     }
-
     goog.asserts.assert(typeof(config) == 'object', 'Should be an object!');
 
-    // Deprecate 'manifest.dash.defaultPresentationDelay' configuration.
-    if (config['manifest'] && config['manifest']['dash'] &&
-          'defaultPresentationDelay' in config['manifest']['dash']) {
-      shaka.Deprecate.deprecateFeature(4,
-          'manifest.dash.defaultPresentationDelay configuration',
-          'Please Use manifest.defaultPresentationDelay instead.');
-      config['manifest']['defaultPresentationDelay'] =
-          config['manifest']['dash']['defaultPresentationDelay'];
-      delete config['manifest']['dash']['defaultPresentationDelay'];
-    }
-
     goog.asserts.assert(
-        this.config_, 'Cannot reconfigure stroage after calling destroy.');
+        this.config_, 'Cannot reconfigure storage after calling destroy.');
     return shaka.util.PlayerConfiguration.mergeConfigObjects(
         /* destination= */ this.config_, /* updates= */ config );
   }
@@ -292,7 +277,7 @@ shaka.offline.Storage = class {
           config.manifest.retryParameters,
           mimeType || null);
 
-      return shaka.util.Functional.callFactory(factory);
+      return factory();
     };
 
     /** @type {!shaka.offline.DownloadManager} */
@@ -309,33 +294,9 @@ shaka.offline.Storage = class {
       shaka.util.ArrayUtils.remove(this.openDownloadManagers_, downloader);
     });
 
-    // Provide a temporary shim for "then" for backward compatibility.
-    /** @type {!Object} */ (abortableStoreOp)['then'] = (onSuccess) => {
-      shaka.Deprecate.deprecateFeature(4,
-          'shaka.offline.Storage.store.then',
-          'Storage operations now return a shaka.util.AbortableOperation, ' +
-          'rather than a promise.  Please update to conform to this new API; ' +
-          'you can use the |chain| method instead.');
-      return abortableStoreOp.promise.then(onSuccess);
-    };
-
     return this.startAbortableOperation_(abortableStoreOp);
   }
 
-  /**
-   * Returns true if an asset is currently downloading.
-   *
-   * @return {boolean}
-   * @deprecated
-   * @export
-   */
-  getStoreInProgress() {
-    shaka.Deprecate.deprecateFeature(4,
-        'shaka.offline.Storage.getStoreInProgress',
-        'Multiple concurrent downloads are now supported.');
-    return false;
-  }
-
   /**
    * See |shaka.offline.Storage.store| for details.
    *
@@ -479,36 +440,34 @@ shaka.offline.Storage = class {
   async downloadSegments_(
       toDownload, manifestId, manifestDB, downloader, config, storage,
       manifest, drmEngine) {
+    let pendingManifestUpdates = {};
+    let pendingDataSize = 0;
+
     /**
      * @param {!Array.<!shaka.offline.DownloadInfo>} toDownload
      * @param {boolean} updateDRM
      */
     const download = async (toDownload, updateDRM) => {
-      const throwIfAbortedFn = () => {
-        this.ensureNotDestroyed_();
-      };
       for (const download of toDownload) {
-        /** @param {?BufferSource} data */
-        let data;
         const request = download.makeSegmentRequest(config);
         const estimateId = download.estimateId;
         const isInitSegment = download.isInitSegment;
-        const onDownloaded = (d) => {
-          data = d;
-          return Promise.resolve();
-        };
-        downloader.queue(download.groupId,
-            request, estimateId, isInitSegment, onDownloaded);
-        downloader.queueWork(download.groupId, async () => {
-          goog.asserts.assert(data, 'We should have loaded data by now');
-          goog.asserts.assert(data instanceof ArrayBuffer,
-              'The data should be an ArrayBuffer');
 
+        const onDownloaded = async (data) => {
+          // Store the data.
+          const dataKeys = await storage.addSegments([{data}]);
+          this.ensureNotDestroyed_();
+
+          // Store the necessary update to the manifest, to be processed later.
           const ref = /** @type {!shaka.media.SegmentReference} */ (
             download.ref);
-          manifestDB = (await shaka.offline.Storage.assignStreamToManifest(
-              manifestId, ref, {data}, throwIfAbortedFn)) || manifestDB;
-        });
+          const id = shaka.offline.DownloadInfo.idForSegmentRef(ref);
+          pendingManifestUpdates[id] = dataKeys[0];
+          pendingDataSize += data.byteLength;
+        };
+
+        downloader.queue(download.groupId,
+            request, estimateId, isInitSegment, onDownloaded);
       }
       await downloader.waitToFinish();
 
@@ -516,8 +475,8 @@ shaka.offline.Storage = class {
         // Re-store the manifest, to attach session IDs.
         // These were (maybe) discovered inside the downloader; we can only add
         // them now, at the end, since the manifestDB is in flux during the
-        // process of downloading and storing, and assignStreamToManifest does
-        // not know about the DRM engine.
+        // process of downloading and storing, and assignSegmentsToManifest
+        // does not know about the DRM engine.
         this.ensureNotDestroyed_();
         this.setManifestDrmFields_(manifest, manifestDB, drmEngine, config);
         await storage.updateManifest(manifestId, manifestDB);
@@ -526,24 +485,54 @@ shaka.offline.Storage = class {
 
     const usingBgFetch = false; // TODO: Get.
 
-    if (this.getManifestIsEncrypted_(manifest) && usingBgFetch &&
-        !this.getManifestIncludesInitData_(manifest)) {
-      // Background fetch can't make DRM sessions, so if we have to get the
-      // init data from the init segments, download those first before anything
-      // else.
-      await download(toDownload.filter((info) => info.isInitSegment), true);
-      this.ensureNotDestroyed_();
-      toDownload = toDownload.filter((info) => !info.isInitSegment);
-    }
+    try {
+      if (this.getManifestIsEncrypted_(manifest) && usingBgFetch &&
+          !this.getManifestIncludesInitData_(manifest)) {
+        // Background fetch can't make DRM sessions, so if we have to get the
+        // init data from the init segments, download those first before
+        // anything else.
+        await download(toDownload.filter((info) => info.isInitSegment), true);
+        this.ensureNotDestroyed_();
+        toDownload = toDownload.filter((info) => !info.isInitSegment);
 
-    if (!usingBgFetch) {
-      await download(toDownload, false);
-      this.ensureNotDestroyed_();
+        // Copy these and reset them now, before calling await.
+        const manifestUpdates = pendingManifestUpdates;
+        const dataSize = pendingDataSize;
+        pendingManifestUpdates = {};
+        pendingDataSize = 0;
 
-      goog.asserts.assert(
-          !manifestDB.isIncomplete, 'The manifest should be complete by now');
-    } else {
-      // TODO: Send the request to the service worker. Don't await the result.
+        await shaka.offline.Storage.assignSegmentsToManifest(
+            storage, manifestId, manifestDB, manifestUpdates, dataSize,
+            () => this.ensureNotDestroyed_());
+        this.ensureNotDestroyed_();
+      }
+
+      if (!usingBgFetch) {
+        await download(toDownload, false);
+        this.ensureNotDestroyed_();
+
+        // Copy these and reset them now, before calling await.
+        const manifestUpdates = pendingManifestUpdates;
+        const dataSize = pendingDataSize;
+        pendingManifestUpdates = {};
+        pendingDataSize = 0;
+
+        await shaka.offline.Storage.assignSegmentsToManifest(
+            storage, manifestId, manifestDB, manifestUpdates, dataSize,
+            () => this.ensureNotDestroyed_());
+        this.ensureNotDestroyed_();
+
+        goog.asserts.assert(
+            !manifestDB.isIncomplete, 'The manifest should be complete by now');
+      } else {
+        // TODO: Send the request to the service worker. Don't await the result.
+      }
+    } catch (error) {
+      const dataKeys = Object.values(pendingManifestUpdates);
+      // Remove these pending segments that are not yet linked to the manifest.
+      await storage.removeSegments(dataKeys, (key) => {});
+
+      throw error;
     }
   }
 
@@ -567,70 +556,50 @@ shaka.offline.Storage = class {
   }
 
   /**
-   * Load the given manifest, modifies it by assigning the given data to the
-   * segments corresponding to "ref", then re-stores the manifest.
-   * The parts of this function that modify the manifest are protected by a
-   * mutex, to prevent race conditions; specifically, it prevents two parallel
-   * instances of this method from both loading the manifest into memory at the
-   * same time, which would result in the slower/later call overwriting the
-   * changes of the other.
+   * Updates the given manifest, assigns database keys to segments, then stores
+   * the updated manifest.
    *
+   * It is up to the caller to ensure that this method is not called
+   * concurrently on the same manifest.
+   *
+   * @param {shaka.extern.StorageCell} storage
    * @param {number} manifestId
-   * @param {!shaka.media.SegmentReference} ref
-   * @param {shaka.extern.SegmentDataDB} data
+   * @param {!shaka.extern.ManifestDB} manifestDB
+   * @param {!Object.<string, number>} manifestUpdates
+   * @param {number} dataSizeUpdate
    * @param {function()} throwIfAbortedFn  A function that should throw if the
    *   download has been aborted.
-   * @return {!Promise.<?shaka.extern.ManifestDB>}
+   * @return {!Promise}
    */
-  static async assignStreamToManifest(manifestId, ref, data, throwIfAbortedFn) {
-    /** @type {shaka.offline.StorageMuxer} */
-    const muxer = new shaka.offline.StorageMuxer();
-
-    const idForRef = shaka.offline.DownloadInfo.idForSegmentRef(ref);
+  static async assignSegmentsToManifest(
+      storage, manifestId, manifestDB, manifestUpdates, dataSizeUpdate,
+      throwIfAbortedFn) {
     let manifestUpdated = false;
-    let dataKey;
-    let activeHandle;
-    /** @type {!shaka.extern.ManifestDB} */
-    let manifestDB;
-
-    let mutexId = 0;
 
     try {
-      await muxer.init();
-      activeHandle = await muxer.getActive();
-
-      // Store the data.
-      const dataKeys = await activeHandle.cell.addSegments([data]);
-      dataKey = dataKeys[0];
-      throwIfAbortedFn();
-
-      // Acquire the mutex before accessing the manifest, since there could be
-      // multiple instances of this method running at once.
-      mutexId = await shaka.offline.Storage.mutex_.acquire();
-      throwIfAbortedFn();
-
-      // Load the manifest.
-      const manifests = await activeHandle.cell.getManifests([manifestId]);
-      throwIfAbortedFn();
-      manifestDB = manifests[0];
-
       // Assign the stored data to the manifest.
       let complete = true;
       for (const stream of manifestDB.streams) {
         for (const segment of stream.segments) {
-          if (segment.pendingSegmentRefId == idForRef) {
+          let dataKey = segment.pendingSegmentRefId ?
+              manifestUpdates[segment.pendingSegmentRefId] : null;
+          if (dataKey != null) {
             segment.dataKey = dataKey;
             // Now that the segment has been associated with the appropriate
             // dataKey, the pendingSegmentRefId is no longer necessary.
             segment.pendingSegmentRefId = undefined;
           }
-          if (segment.pendingInitSegmentRefId == idForRef) {
+
+          dataKey = segment.pendingInitSegmentRefId ?
+              manifestUpdates[segment.pendingInitSegmentRefId] : null;
+          if (dataKey != null) {
             segment.initSegmentKey = dataKey;
             // Now that the init segment has been associated with the
             // appropriate initSegmentKey, the pendingInitSegmentRefId is no
             // longer necessary.
             segment.pendingInitSegmentRefId = undefined;
           }
+
           if (segment.pendingSegmentRefId) {
             complete = false;
           }
@@ -641,33 +610,30 @@ shaka.offline.Storage = class {
       }
 
       // Update the size of the manifest.
-      manifestDB.size += data.data.byteLength;
+      manifestDB.size += dataSizeUpdate;
 
       // Mark the manifest as complete, if all segments are downloaded.
       if (complete) {
         manifestDB.isIncomplete = false;
       }
 
-      // Re-store the manifest.
-      await activeHandle.cell.updateManifest(manifestId, manifestDB);
+      // Update the manifest.
+      await storage.updateManifest(manifestId, manifestDB);
       manifestUpdated = true;
       throwIfAbortedFn();
     } catch (e) {
       await shaka.offline.Storage.cleanStoredManifest(manifestId);
 
-      if (activeHandle && !manifestUpdated && dataKey) {
+      if (!manifestUpdated) {
+        const dataKeys = Object.values(manifestUpdates);
         // The cleanStoredManifest method will not "see" any segments that have
         // been downloaded but not assigned to the manifest yet. So un-store
         // them separately.
-        await activeHandle.cell.removeSegments([dataKey], (key) => {});
+        await storage.removeSegments(dataKeys, (key) => {});
       }
 
       throw e;
-    } finally {
-      await muxer.destroy();
-      shaka.offline.Storage.mutex_.release(mutexId);
     }
-    return manifestDB;
   }
 
   /**
@@ -866,6 +832,7 @@ shaka.offline.Storage = class {
       drmInfo,
       appMetadata: metadata,
       isIncomplete: true,
+      sequenceMode: manifest.sequenceMode,
     };
 
     return {manifestDB, toDownload};
@@ -1361,6 +1328,9 @@ shaka.offline.Storage = class {
     const startTime =
         manifest.presentationTimeline.getSegmentAvailabilityStart();
 
+    const numberOfParallelDownloads = config.offline.numberOfParallelDownloads;
+    let groupId = 0;
+
     shaka.offline.Storage.forEachSegment_(stream, startTime, (segment) => {
       const pendingSegmentRefId =
           shaka.offline.DownloadInfo.idForSegmentRef(segment);
@@ -1374,7 +1344,7 @@ shaka.offline.Storage = class {
         const segmentDownload = new shaka.offline.DownloadInfo(
             segment,
             estimateId,
-            stream.id,
+            groupId,
             /* isInitSegment= */ false);
         toDownload.set(pendingSegmentRefId, segmentDownload);
       }
@@ -1389,7 +1359,7 @@ shaka.offline.Storage = class {
           const initDownload = new shaka.offline.DownloadInfo(
               segment.initSegmentReference,
               estimateId,
-              stream.id,
+              groupId,
               /* isInitSegment= */ true);
           toDownload.set(pendingInitSegmentRefId, initDownload);
         }
@@ -1409,6 +1379,7 @@ shaka.offline.Storage = class {
         dataKey: 0,
       };
       streamDb.segments.push(segmentDB);
+      groupId = (groupId + 1) % numberOfParallelDownloads;
     });
 
     return streamDb;
@@ -1662,9 +1633,6 @@ shaka.offline.Storage = class {
   }
 };
 
-/** @private {!shaka.util.Mutex} */
-shaka.offline.Storage.mutex_ = new shaka.util.Mutex();
-
 shaka.offline.Storage.defaultSystemIds_ = new Map()
     .set('org.w3.clearkey', '1077efecc0b24d02ace33c1e52e2fb4b')
     .set('com.widevine.alpha', 'edef8ba979d64acea3c827dcd51d21ed')