shaka-player 4.12.9 → 4.13.0

package/lib/offline/storage.js

@@ -8,11 +8,12 @@ goog.provide('shaka.offline.Storage');
 
 goog.require('goog.asserts');
 goog.require('shaka.Player');
+goog.require('shaka.drm.DrmEngine');
 goog.require('shaka.log');
-goog.require('shaka.media.DrmEngine');
 goog.require('shaka.media.ManifestParser');
 goog.require('shaka.media.SegmentIndex');
 goog.require('shaka.media.SegmentReference');
+goog.require('shaka.media.SegmentUtils');
 goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.net.NetworkingUtils');
 goog.require('shaka.offline.DownloadInfo');
@@ -102,21 +103,21 @@ shaka.offline.Storage = class {
      * A list of open operations that are being performed by this instance of
      * |shaka.offline.Storage|.
      *
-     * @private {!Array.<!Promise>}
+     * @private {!Array<!Promise>}
      */
     this.openOperations_ = [];
 
     /**
      * A list of open download managers that are being used to download things.
      *
-     * @private {!Array.<!shaka.offline.DownloadManager>}
+     * @private {!Array<!shaka.offline.DownloadManager>}
      */
     this.openDownloadManagers_ = [];
 
     /**
      * Storage should only destroy the networking engine if it was initialized
      * without a player instance. Store this as a flag here to avoid including
-     * the player object in the destoyer's closure.
+     * the player object in the destroyer's closure.
      *
      * @type {boolean}
      */
@@ -263,9 +264,9 @@ shaka.offline.Storage = class {
    *   refer to {@link https://bit.ly/StructClone}
    * @param {?string=} mimeType
    *   The mime type for the content |manifestUri| points to.
-   * @param {?Array.<string>=} externalThumbnails
+   * @param {?Array<string>=} externalThumbnails
    *   The external thumbnails to store along the main content.
-   * @param {?Array.<shaka.extern.ExtraText>=} externalText
+   * @param {?Array<shaka.extern.ExtraText>=} externalText
    *   The external text to store along the main content.
    * @return {!shaka.extern.IAbortableOperation.<shaka.extern.StoredContent>}
    *   An AbortableOperation that resolves with a structure representing what
@@ -323,12 +324,12 @@ shaka.offline.Storage = class {
    *
    * @param {string} uri
    * @param {!Object} appMetadata
-   * @param {!Array.<string>} externalThumbnails
-   * @param {!Array.<shaka.extern.ExtraText>} externalText
-   * @param {function():!Promise.<shaka.extern.ManifestParser>} getParser
+   * @param {!Array<string>} externalThumbnails
+   * @param {!Array<shaka.extern.ExtraText>} externalText
+   * @param {function(): !Promise<shaka.extern.ManifestParser>} getParser
    * @param {shaka.extern.PlayerConfiguration} config
    * @param {!shaka.offline.DownloadManager} downloader
-   * @return {!Promise.<shaka.extern.StoredContent>}
+   * @return {!Promise<shaka.extern.StoredContent>}
    * @private
    */
   async store_(uri, appMetadata, externalThumbnails, externalText,
@@ -342,7 +343,7 @@ shaka.offline.Storage = class {
 
     /** @type {?shaka.extern.ManifestParser} */
     let parser = null;
-    /** @type {?shaka.media.DrmEngine} */
+    /** @type {?shaka.drm.DrmEngine} */
     let drmEngine = null;
     /** @type {shaka.offline.StorageMuxer} */
     const muxer = new shaka.offline.StorageMuxer();
@@ -394,11 +395,38 @@ shaka.offline.Storage = class {
         this.ensureNotDestroyed_();
       }
 
+      shaka.drm.DrmEngine.configureClearKey(
+          config.drm.clearKeys, manifest.variants);
+
+      const clearKeyDataLicenseServerUri = manifest.variants.some((v) => {
+        if (v.audio) {
+          for (const drmInfo of v.audio.drmInfos) {
+            if (drmInfo.licenseServerUri.startsWith('data:')) {
+              return true;
+            }
+          }
+        }
+        if (v.video) {
+          for (const drmInfo of v.video.drmInfos) {
+            if (drmInfo.licenseServerUri.startsWith('data:')) {
+              return true;
+            }
+          }
+        }
+        return false;
+      });
+
+      let usePersistentLicense = config.offline.usePersistentLicense;
+      if (clearKeyDataLicenseServerUri) {
+        usePersistentLicense = false;
+      }
+
       // Create the DRM engine, and load the keys in the manifest.
       drmEngine = await this.createDrmEngine(
           manifest,
           (e) => { drmError = drmError || e; },
-          config);
+          config,
+          usePersistentLicense);
 
       // We could have been asked to destroy ourselves while we were "away"
       // creating the drm engine.
@@ -407,7 +435,8 @@ shaka.offline.Storage = class {
         throw drmError;
       }
 
-      await this.filterManifest_(manifest, drmEngine, config);
+      await this.filterManifest_(
+          manifest, drmEngine, config, usePersistentLicense);
 
       await muxer.init();
       this.ensureNotDestroyed_();
@@ -420,7 +449,8 @@ shaka.offline.Storage = class {
 
       goog.asserts.assert(drmEngine, 'drmEngine should be non-null here.');
       const {manifestDB, toDownload} = this.makeManifestDB_(
-          drmEngine, manifest, uri, appMetadata, config, downloader);
+          drmEngine, manifest, uri, appMetadata, config, downloader,
+          usePersistentLicense);
 
       // Store the empty manifest, before downloading the segments.
       const ids = await activeHandle.cell.addManifests([manifestDB]);
@@ -434,10 +464,12 @@ shaka.offline.Storage = class {
       }
 
       await this.downloadSegments_(toDownload, manifestId, manifestDB,
-          downloader, config, activeHandle.cell, manifest, drmEngine);
+          downloader, config, activeHandle.cell, manifest, drmEngine,
+          usePersistentLicense);
       this.ensureNotDestroyed_();
 
-      this.setManifestDrmFields_(manifest, manifestDB, drmEngine, config);
+      this.setManifestDrmFields_(
+          manifest, manifestDB, drmEngine, usePersistentLicense);
       await activeHandle.cell.updateManifest(manifestId, manifestDB);
       this.ensureNotDestroyed_();
 
@@ -471,42 +503,57 @@ shaka.offline.Storage = class {
    * Download and then store the contents of each segment.
    * The promise this returns will wait for local downloads.
    *
-   * @param {!Array.<!shaka.offline.DownloadInfo>} toDownload
+   * @param {!Array<!shaka.offline.DownloadInfo>} toDownload
    * @param {number} manifestId
    * @param {shaka.extern.ManifestDB} manifestDB
    * @param {!shaka.offline.DownloadManager} downloader
    * @param {shaka.extern.PlayerConfiguration} config
    * @param {shaka.extern.StorageCell} storage
    * @param {shaka.extern.Manifest} manifest
-   * @param {!shaka.media.DrmEngine} drmEngine
+   * @param {!shaka.drm.DrmEngine} drmEngine
+   * @param {boolean} usePersistentLicense
    * @return {!Promise}
    * @private
    */
   async downloadSegments_(
       toDownload, manifestId, manifestDB, downloader, config, storage,
-      manifest, drmEngine) {
+      manifest, drmEngine, usePersistentLicense) {
     let pendingManifestUpdates = {};
     let pendingDataSize = 0;
 
+    const ensureNotAbortedOrDestroyed = () => {
+      if (this.destroyer_.destroyed() || downloader.isAborted()) {
+        throw new shaka.util.Error(
+            shaka.util.Error.Severity.CRITICAL,
+            shaka.util.Error.Category.STORAGE,
+            shaka.util.Error.Code.OPERATION_ABORTED);
+      }
+    };
+
     /**
-     * @param {!Array.<!shaka.offline.DownloadInfo>} toDownload
+     * @param {!Array<!shaka.offline.DownloadInfo>} toDownload
      * @param {boolean} updateDRM
      */
     const download = async (toDownload, updateDRM) => {
       for (const download of toDownload) {
+        ensureNotAbortedOrDestroyed();
         const request = download.makeSegmentRequest(config);
         const estimateId = download.estimateId;
         const isInitSegment = download.isInitSegment;
 
         const onDownloaded = async (data) => {
+          const ref = /** @type {!shaka.media.SegmentReference} */ (
+            download.ref);
+          const id = shaka.offline.DownloadInfo.idForSegmentRef(ref);
+          if (ref.aesKey) {
+            data = await shaka.media.SegmentUtils.aesDecrypt(
+                data, ref.aesKey, download.refPosition);
+          }
           // Store the data.
           const dataKeys = await storage.addSegments([{data}]);
-          this.ensureNotDestroyed_();
+          ensureNotAbortedOrDestroyed();
 
           // Store the necessary update to the manifest, to be processed later.
-          const ref = /** @type {!shaka.media.SegmentReference} */ (
-            download.ref);
-          const id = shaka.offline.DownloadInfo.idForSegmentRef(ref);
           pendingManifestUpdates[id] = dataKeys[0];
           pendingDataSize += data.byteLength;
         };
@@ -523,15 +570,16 @@ shaka.offline.Storage = class {
         }
       }
       await downloader.waitToFinish();
+      ensureNotAbortedOrDestroyed();
 
-      if (updateDRM) {
+      if (updateDRM && !downloader.isAborted()) {
         // 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 assignSegmentsToManifest
         // does not know about the DRM engine.
-        this.ensureNotDestroyed_();
-        this.setManifestDrmFields_(manifest, manifestDB, drmEngine, config);
+        this.setManifestDrmFields_(
+            manifest, manifestDB, drmEngine, usePersistentLicense);
         await storage.updateManifest(manifestId, manifestDB);
       }
     };
@@ -545,7 +593,7 @@ shaka.offline.Storage = class {
         // init data from the init segments, download those first before
         // anything else.
         await download(toDownload.filter((info) => info.isInitSegment), true);
-        this.ensureNotDestroyed_();
+        ensureNotAbortedOrDestroyed();
         toDownload = toDownload.filter((info) => !info.isInitSegment);
 
         // Copy these and reset them now, before calling await.
@@ -557,12 +605,12 @@ shaka.offline.Storage = class {
         await shaka.offline.Storage.assignSegmentsToManifest(
             storage, manifestId, manifestDB, manifestUpdates, dataSize,
             () => this.ensureNotDestroyed_());
-        this.ensureNotDestroyed_();
+        ensureNotAbortedOrDestroyed();
       }
 
       if (!usingBgFetch) {
         await download(toDownload, false);
-        this.ensureNotDestroyed_();
+        ensureNotAbortedOrDestroyed();
 
         // Copy these and reset them now, before calling await.
         const manifestUpdates = pendingManifestUpdates;
@@ -572,8 +620,8 @@ shaka.offline.Storage = class {
 
         await shaka.offline.Storage.assignSegmentsToManifest(
             storage, manifestId, manifestDB, manifestUpdates, dataSize,
-            () => this.ensureNotDestroyed_());
-        this.ensureNotDestroyed_();
+            () => ensureNotAbortedOrDestroyed());
+        ensureNotAbortedOrDestroyed();
 
         goog.asserts.assert(
             !manifestDB.isIncomplete, 'The manifest should be complete by now');
@@ -618,7 +666,7 @@ shaka.offline.Storage = class {
    * @param {shaka.extern.StorageCell} storage
    * @param {number} manifestId
    * @param {!shaka.extern.ManifestDB} manifestDB
-   * @param {!Object.<string, number>} manifestUpdates
+   * @param {!Object<string, number>} manifestUpdates
    * @param {number} dataSizeUpdate
    * @param {function()} throwIfAbortedFn  A function that should throw if the
    *   download has been aborted.
@@ -694,12 +742,13 @@ shaka.offline.Storage = class {
    * streams that we want to store and can actually play.
    *
    * @param {shaka.extern.Manifest} manifest
-   * @param {!shaka.media.DrmEngine} drmEngine
+   * @param {!shaka.drm.DrmEngine} drmEngine
    * @param {shaka.extern.PlayerConfiguration} config
+   * @param {boolean} usePersistentLicense
    * @return {!Promise}
    * @private
    */
-  async filterManifest_(manifest, drmEngine, config) {
+  async filterManifest_(manifest, drmEngine, config, usePersistentLicense) {
     // Filter the manifest based on the restrictions given in the player
     // configuration.
     const maxHwRes = {width: Infinity, height: Infinity};
@@ -709,7 +758,7 @@ shaka.offline.Storage = class {
     // Filter the manifest based on what we know MediaCapabilities will be able
     // to play later (no point storing something we can't play).
     await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
-        drmEngine, manifest, config.offline.usePersistentLicense,
+        drmEngine, manifest, usePersistentLicense,
         config.drm.preferredKeySystems, config.drm.keySystemsMapping);
 
     // Gather all tracks.
@@ -772,11 +821,11 @@ shaka.offline.Storage = class {
           shaka.util.Error.Code.DOWNLOAD_SIZE_CALLBACK_ERROR);
     }
 
-    /** @type {!Set.<number>} */
+    /** @type {!Set<number>} */
     const variantIds = new Set();
-    /** @type {!Set.<number>} */
+    /** @type {!Set<number>} */
     const textIds = new Set();
-    /** @type {!Set.<number>} */
+    /** @type {!Set<number>} */
     const imageIds = new Set();
 
     // Collect the IDs of the chosen tracks.
@@ -809,19 +858,21 @@ shaka.offline.Storage = class {
    * Create a download manager and download the manifest.
    * This also sets up download infos for each segment to be downloaded.
    *
-   * @param {!shaka.media.DrmEngine} drmEngine
+   * @param {!shaka.drm.DrmEngine} drmEngine
    * @param {shaka.extern.Manifest} manifest
    * @param {string} uri
    * @param {!Object} metadata
    * @param {shaka.extern.PlayerConfiguration} config
    * @param {!shaka.offline.DownloadManager} downloader
+   * @param {boolean} usePersistentLicense
    * @return {{
    *   manifestDB: shaka.extern.ManifestDB,
-   *   toDownload: !Array.<!shaka.offline.DownloadInfo>
+   *   toDownload: !Array<!shaka.offline.DownloadInfo>
    * }}
    * @private
    */
-  makeManifestDB_(drmEngine, manifest, uri, metadata, config, downloader) {
+  makeManifestDB_(drmEngine, manifest, uri, metadata, config, downloader,
+      usePersistentLicense) {
     const pendingContent = shaka.offline.StoredContentUtils.fromManifest(
         uri, manifest, /* size= */ 0, metadata);
     // In https://github.com/shaka-project/shaka-player/issues/2652, we found
@@ -837,7 +888,7 @@ shaka.offline.Storage = class {
       progressCallback(pendingContent, progress);
     };
     const onInitData = (initData, systemId) => {
-      if (needsInitData && config.offline.usePersistentLicense &&
+      if (needsInitData && usePersistentLicense &&
           currentSystemId == systemId) {
         drmEngine.newInitData('cenc', initData);
       }
@@ -869,7 +920,6 @@ shaka.offline.Storage = class {
         downloader, estimator, drmEngine, manifest, config);
 
     const drmInfo = drmEngine.getDrmInfo();
-    const usePersistentLicense = config.offline.usePersistentLicense;
     if (drmInfo && usePersistentLicense) {
       // Don't store init data, since we have stored sessions.
       drmInfo.initData = [];
@@ -925,19 +975,18 @@ shaka.offline.Storage = class {
   /**
    * @param {shaka.extern.Manifest} manifest
    * @param {shaka.extern.ManifestDB} manifestDB
-   * @param {!shaka.media.DrmEngine} drmEngine
-   * @param {shaka.extern.PlayerConfiguration} config
+   * @param {!shaka.drm.DrmEngine} drmEngine
+   * @param {boolean} usePersistentLicense
    * @private
    */
-  setManifestDrmFields_(manifest, manifestDB, drmEngine, config) {
+  setManifestDrmFields_(manifest, manifestDB, drmEngine, usePersistentLicense) {
     manifestDB.expiration = drmEngine.getExpiration();
 
     const sessions = drmEngine.getSessionIds();
-    manifestDB.sessionIds = config.offline.usePersistentLicense ?
-        sessions : [];
+    manifestDB.sessionIds = usePersistentLicense ? sessions : [];
 
     if (this.getManifestIsEncrypted_(manifest) &&
-        config.offline.usePersistentLicense && !sessions.length) {
+        usePersistentLicense && !sessions.length) {
       throw new shaka.util.Error(
           shaka.util.Error.Severity.CRITICAL,
           shaka.util.Error.Category.STORAGE,
@@ -1001,7 +1050,7 @@ shaka.offline.Storage = class {
   /**
    * @param {shaka.extern.ManifestDB} manifestDb
    * @param {boolean} isVideo
-   * @return {!Array.<MediaKeySystemMediaCapability>}
+   * @return {!Array<MediaKeySystemMediaCapability>}
    * @private
    */
   static getCapabilities_(manifestDb, isVideo) {
@@ -1045,7 +1094,7 @@ shaka.offline.Storage = class {
    * @private
    */
   removeFromStorage_(storage, uri, manifest) {
-    /** @type {!Array.<number>} */
+    /** @type {!Array<number>} */
     const segmentIds = shaka.offline.Storage.getAllSegmentIds_(manifest);
 
     // Count(segments) + Count(manifests)
@@ -1070,7 +1119,7 @@ shaka.offline.Storage = class {
    * Removes any EME sessions that were not successfully removed before.  This
    * returns whether all the sessions were successfully removed.
    *
-   * @return {!Promise.<boolean>}
+   * @return {!Promise<boolean>}
    * @export
    */
   removeEmeSessions() {
@@ -1078,7 +1127,7 @@ shaka.offline.Storage = class {
   }
 
   /**
-   * @return {!Promise.<boolean>}
+   * @return {!Promise<boolean>}
    * @private
    */
   async removeEmeSessions_() {
@@ -1098,7 +1147,7 @@ shaka.offline.Storage = class {
     try {
       await muxer.init();
 
-      /** @type {!Array.<shaka.extern.EmeSessionStorageCell>} */
+      /** @type {!Array<shaka.extern.EmeSessionStorageCell>} */
       const cells = [];
       muxer.forEachEmeSessionCell((c) => cells.push(c));
 
@@ -1126,7 +1175,7 @@ shaka.offline.Storage = class {
   /**
    * Lists all the stored content available.
    *
-   * @return {!Promise.<!Array.<shaka.extern.StoredContent>>}  A Promise to an
+   * @return {!Promise<!Array<shaka.extern.StoredContent>>}  A Promise to an
    *   array of structures representing all stored content.  The "offlineUri"
    *   member of the structure is the URI that should be given to Player.load()
    *   to play this piece of content offline.  The "appMetadata" member is the
@@ -1140,13 +1189,13 @@ shaka.offline.Storage = class {
   /**
    * See |shaka.offline.Storage.list| for details.
    *
-   * @return {!Promise.<!Array.<shaka.extern.StoredContent>>}
+   * @return {!Promise<!Array<shaka.extern.StoredContent>>}
    * @private
    */
   async list_() {
     this.requireSupport_();
 
-    /** @type {!Array.<shaka.extern.StoredContent>} */
+    /** @type {!Array<shaka.extern.StoredContent>} */
     const result = [];
 
     /** @type {!shaka.offline.StorageMuxer} */
@@ -1189,7 +1238,7 @@ shaka.offline.Storage = class {
    * @param {string} uri
    * @param {shaka.extern.ManifestParser} parser
    * @param {shaka.extern.PlayerConfiguration} config
-   * @return {!Promise.<shaka.extern.Manifest>}
+   * @return {!Promise<shaka.extern.Manifest>}
    */
   async parseManifest(uri, parser, config) {
     let error = null;
@@ -1218,8 +1267,6 @@ shaka.offline.Storage = class {
         error = e;
       },
       isLowLatencyMode: () => false,
-      isAutoLowLatencyMode: () => false,
-      enableLowLatencyMode: () => {},
       updateDuration: () => {},
       newDrmInfo: (stream) => {},
       onManifestUpdated: () => {},
@@ -1265,7 +1312,7 @@ shaka.offline.Storage = class {
   /**
    * @param {string} uri
    * @param {shaka.extern.Manifest} manifest
-   * @return {!Promise.<shaka.extern.Stream>}
+   * @return {!Promise<shaka.extern.Stream>}
    * @private
    */
   async createExternalImageStream_(uri, manifest) {
@@ -1448,7 +1495,7 @@ shaka.offline.Storage = class {
 
   /**
    * @param {string} uri
-   * @return {!Promise.<string>}
+   * @return {!Promise<string>}
    * @private
    */
   async getTextMimetype_(uri) {
@@ -1456,7 +1503,6 @@ shaka.offline.Storage = class {
     try {
       goog.asserts.assert(
           this.networkingEngine_, 'Need networking engine.');
-      // eslint-disable-next-line require-atomic-updates
       mimeType = await shaka.net.NetworkingUtils.getMimeType(uri,
           this.networkingEngine_,
           this.config_.streaming.retryParameters);
@@ -1480,7 +1526,7 @@ shaka.offline.Storage = class {
    * @param {string} uri
    * @param {!shaka.net.NetworkingEngine} netEngine
    * @param {shaka.extern.RetryParameters} retryParams
-   * @return {!Promise.<BufferSource>}
+   * @return {!Promise<BufferSource>}
    * @private
    */
   async getTextData_(uri, netEngine, retryParams) {
@@ -1500,15 +1546,16 @@ shaka.offline.Storage = class {
    * @param {shaka.extern.Manifest} manifest
    * @param {function(shaka.util.Error)} onError
    * @param {shaka.extern.PlayerConfiguration} config
-   * @return {!Promise.<!shaka.media.DrmEngine>}
+   * @param {boolean} usePersistentLicense
+   * @return {!Promise<!shaka.drm.DrmEngine>}
    */
-  async createDrmEngine(manifest, onError, config) {
+  async createDrmEngine(manifest, onError, config, usePersistentLicense) {
     goog.asserts.assert(
         this.networkingEngine_,
         'Cannot call |createDrmEngine| after |destroy|');
 
-    /** @type {!shaka.media.DrmEngine} */
-    const drmEngine = new shaka.media.DrmEngine({
+    /** @type {!shaka.drm.DrmEngine} */
+    const drmEngine = new shaka.drm.DrmEngine({
       netEngine: this.networkingEngine_,
       onError: onError,
       onKeyStatus: () => {},
@@ -1517,8 +1564,7 @@ shaka.offline.Storage = class {
     });
 
     drmEngine.configure(config.drm);
-    await drmEngine.initForStorage(
-        manifest.variants, config.offline.usePersistentLicense);
+    await drmEngine.initForStorage(manifest.variants, usePersistentLicense);
     await drmEngine.createOrLoad();
 
     return drmEngine;
@@ -1529,18 +1575,18 @@ shaka.offline.Storage = class {
    *
    * @param {!shaka.offline.DownloadManager} downloader
    * @param {shaka.offline.StreamBandwidthEstimator} estimator
-   * @param {!shaka.media.DrmEngine} drmEngine
+   * @param {!shaka.drm.DrmEngine} drmEngine
    * @param {shaka.extern.Manifest} manifest
    * @param {shaka.extern.PlayerConfiguration} config
    * @return {{
-   *   streams: !Array.<shaka.extern.StreamDB>,
-   *   toDownload: !Array.<!shaka.offline.DownloadInfo>
+   *   streams: !Array<shaka.extern.StreamDB>,
+   *   toDownload: !Array<!shaka.offline.DownloadInfo>
    * }}
    * @private
    */
   createStreams_(downloader, estimator, drmEngine, manifest, config) {
-    // Download infos are stored based on their refId, to dedup them.
-    /** @type {!Map.<string, !shaka.offline.DownloadInfo>} */
+    // Download infos are stored based on their refId, to deduplicate them.
+    /** @type {!Map<string, !shaka.offline.DownloadInfo>} */
     const toDownload = new Map();
 
     // Find the streams we want to download and create a stream db instance
@@ -1580,7 +1626,7 @@ shaka.offline.Storage = class {
    * @param {shaka.extern.Manifest} manifest
    * @param {shaka.extern.Stream} stream
    * @param {shaka.extern.PlayerConfiguration} config
-   * @param {!Map.<string, !shaka.offline.DownloadInfo>} toDownload
+   * @param {!Map<string, !shaka.offline.DownloadInfo>} toDownload
    * @return {shaka.extern.StreamDB}
    * @private
    */
@@ -1628,7 +1674,7 @@ shaka.offline.Storage = class {
     const numberOfParallelDownloads = config.offline.numberOfParallelDownloads;
     let groupId = numberOfParallelDownloads === 0 ? stream.id : 0;
 
-    shaka.offline.Storage.forEachSegment_(stream, startTime, (segment) => {
+    shaka.offline.Storage.forEachSegment_(stream, startTime, (segment, pos) => {
       const pendingSegmentRefId =
           shaka.offline.DownloadInfo.idForSegmentRef(segment);
       let pendingInitSegmentRefId = undefined;
@@ -1642,7 +1688,8 @@ shaka.offline.Storage = class {
             segment,
             estimateId,
             groupId,
-            /* isInitSegment= */ false);
+            /* isInitSegment= */ false,
+            pos);
         toDownload.set(pendingSegmentRefId, segmentDownload);
       }
 
@@ -1657,7 +1704,8 @@ shaka.offline.Storage = class {
               segment.initSegmentReference,
               estimateId,
               groupId,
-              /* isInitSegment= */ true);
+              /* isInitSegment= */ true,
+              pos);
           toDownload.set(pendingInitSegmentRefId, initDownload);
         }
       }
@@ -1690,7 +1738,7 @@ shaka.offline.Storage = class {
   /**
    * @param {shaka.extern.Stream} stream
    * @param {number} startTime
-   * @param {function(!shaka.media.SegmentReference)} callback
+   * @param {function(!shaka.media.SegmentReference, number)} callback
    * @private
    */
   static forEachSegment_(stream, startTime, callback) {
@@ -1704,7 +1752,7 @@ shaka.offline.Storage = class {
     /** @type {?shaka.media.SegmentReference} */
     let ref = stream.segmentIndex.get(i);
     while (ref) {
-      callback(ref);
+      callback(ref, i);
       ref = stream.segmentIndex.get(++i);
     }
   }
@@ -1782,11 +1830,11 @@ shaka.offline.Storage = class {
 
   /**
    * @param {shaka.extern.ManifestDB} manifest
-   * @return {!Array.<number>}
+   * @return {!Array<number>}
    * @private
    */
   static getAllSegmentIds_(manifest) {
-    /** @type {!Set.<number>} */
+    /** @type {!Set<number>} */
     const ids = new Set();
 
     // Get every segment for every stream in the manifest.
@@ -1839,7 +1887,7 @@ shaka.offline.Storage = class {
 
     const sessionIdCell = muxer.getEmeSessionCell();
 
-    /** @type {!Array.<shaka.extern.EmeSessionDB>} */
+    /** @type {!Array<shaka.extern.EmeSessionDB>} */
     const sessions = manifestDb.sessionIds.map((sessionId) => {
       return {
         sessionId: sessionId,
@@ -1869,11 +1917,11 @@ shaka.offline.Storage = class {
    * Get the set of all streams in |manifest|.
    *
    * @param {shaka.extern.Manifest} manifest
-   * @return {!Set.<shaka.extern.Stream>}
+   * @return {!Set<shaka.extern.Stream>}
    * @private
    */
   static getAllStreamsFromManifest_(manifest) {
-    /** @type {!Set.<shaka.extern.Stream>} */
+    /** @type {!Set<shaka.extern.Stream>} */
     const set = new Set();
 
     for (const variant of manifest.variants) {
@@ -1944,6 +1992,7 @@ shaka.offline.Storage.defaultSystemIds_ = new Map()
     .set('com.microsoft.playready.software',
         '9a04f07998404286ab92e65be0885f95')
     .set('com.microsoft.playready.hardware',
-        '9a04f07998404286ab92e65be0885f95');
+        '9a04f07998404286ab92e65be0885f95')
+    .set('com.huawei.wiseplay', '3d5e6d359b9a41e8b843dd3c6e72c42c');
 
 shaka.Player.registerSupportPlugin('offline', shaka.offline.Storage.support);