Source: lib/offline/storage.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.offline.Storage');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.Player');
  11. goog.require('shaka.drm.DrmEngine');
  12. goog.require('shaka.log');
  13. goog.require('shaka.media.ManifestParser');
  14. goog.require('shaka.media.SegmentIndex');
  15. goog.require('shaka.media.SegmentReference');
  16. goog.require('shaka.media.SegmentUtils');
  17. goog.require('shaka.net.NetworkingEngine');
  18. goog.require('shaka.net.NetworkingUtils');
  19. goog.require('shaka.offline.DownloadInfo');
  20. goog.require('shaka.offline.DownloadManager');
  21. goog.require('shaka.offline.OfflineUri');
  22. goog.require('shaka.offline.SessionDeleter');
  23. goog.require('shaka.offline.StorageMuxer');
  24. goog.require('shaka.offline.StoredContentUtils');
  25. goog.require('shaka.offline.StreamBandwidthEstimator');
  26. goog.require('shaka.text.TextEngine');
  27. goog.require('shaka.util.AbortableOperation');
  28. goog.require('shaka.util.ArrayUtils');
  29. goog.require('shaka.util.BufferUtils');
  30. goog.require('shaka.util.ConfigUtils');
  31. goog.require('shaka.util.Destroyer');
  32. goog.require('shaka.util.Error');
  33. goog.require('shaka.util.IDestroyable');
  34. goog.require('shaka.util.Iterables');
  35. goog.require('shaka.util.ManifestParserUtils');
  36. goog.require('shaka.util.MimeUtils');
  37. goog.require('shaka.util.Platform');
  38. goog.require('shaka.util.PlayerConfiguration');
  39. goog.require('shaka.util.StreamUtils');
  40. goog.requireType('shaka.media.SegmentReference');
  41. goog.requireType('shaka.offline.StorageCellHandle');
  44. /**
  45.  * @summary
  46.  * This manages persistent offline data including storage, listing, and deleting
  47.  * stored manifests.  Playback of offline manifests are done through the Player
  48.  * using a special URI (see shaka.offline.OfflineUri).
  49.  *
  50.  * First, check support() to see if offline is supported by the platform.
  51.  * Second, configure() the storage object with callbacks to your application.
  52.  * Third, call store(), remove(), or list() as needed.
  53.  * When done, call destroy().
  54.  *
  55.  * @implements {shaka.util.IDestroyable}
  56.  * @export
  57.  */
  58. shaka.offline.Storage = class {
  59.   /**
  60.    * @param {!shaka.Player=} player
  61.    *    A player instance to share a networking engine and configuration with.
  62.    *    When initializing with a player, storage is only valid as long as
  63.    *    |destroy| has not been called on the player instance. When omitted,
  64.    *    storage will manage its own networking engine and configuration.
  65.    */
  66.   constructor(player) {
  67.     // It is an easy mistake to make to pass a Player proxy from CastProxy.
  68.     // Rather than throw a vague exception later, throw an explicit and clear
  69.     // one now.
  70.     //
  71.     // TODO(vaage): After we decide whether or not we want to support
  72.     //  initializing storage with a player proxy, we should either remove
  73.     //  this error or rename the error.
  74.     if (player && player.constructor != shaka.Player) {
  75.       throw new shaka.util.Error(
  76.           shaka.util.Error.Severity.CRITICAL,
  77.           shaka.util.Error.Category.STORAGE,
  78.           shaka.util.Error.Code.LOCAL_PLAYER_INSTANCE_REQUIRED);
  79.     }
  81.     /** @private {?shaka.extern.PlayerConfiguration} */
  82.     this.config_ = null;
  84.     /** @private {shaka.net.NetworkingEngine} */
  85.     this.networkingEngine_ = null;
  87.     // Initialize |config_| and |networkingEngine_| based on whether or not
  88.     // we were given a player instance.
  89.     if (player) {
  90.       this.config_ = player.getSharedConfiguration();
  91.       this.networkingEngine_ = player.getNetworkingEngine();
  93.       goog.asserts.assert(
  94.           this.networkingEngine_,
  95.           'Storage should not be initialized with a player that had ' +
  96.               '|destroy| called on it.');
  97.     } else {
  98.       this.config_ = shaka.util.PlayerConfiguration.createDefault();
  99.       this.networkingEngine_ = new shaka.net.NetworkingEngine();
  100.     }
  102.     /**
  103.      * A list of open operations that are being performed by this instance of
  104.      * |shaka.offline.Storage|.
  105.      *
  106.      * @private {!Array<!Promise>}
  107.      */
  108.     this.openOperations_ = [];
  110.     /**
  111.      * A list of open download managers that are being used to download things.
  112.      *
  113.      * @private {!Array<!shaka.offline.DownloadManager>}
  114.      */
  115.     this.openDownloadManagers_ = [];
  117.     /**
  118.      * Storage should only destroy the networking engine if it was initialized
  119.      * without a player instance. Store this as a flag here to avoid including
  120.      * the player object in the destroyer's closure.
  121.      *
  122.      * @type {boolean}
  123.      */
  124.     const destroyNetworkingEngine = !player;
  126.     /** @private {!shaka.util.Destroyer} */
  127.     this.destroyer_ = new shaka.util.Destroyer(async () => {
  128.       // Cancel all in-progress store operations.
  129.       await Promise.all(this.openDownloadManagers_.map((dl) => dl.abortAll()));
  131.       // Wait for all remaining open operations to end. Wrap each operations so
  132.       // that a single rejected promise won't cause |Promise.all| to return
  133.       // early or to return a rejected Promise.
  134.       const noop = () => {};
  135.       const awaits = [];
  136.       for (const op of this.openOperations_) {
  137.         awaits.push(op.then(noop, noop));
  138.       }
  139.       await Promise.all(awaits);
  141.       // Wait until after all the operations have finished before we destroy
  142.       // the networking engine to avoid any unexpected errors.
  143.       if (destroyNetworkingEngine) {
  144.         await this.networkingEngine_.destroy();
  145.       }
  147.       // Drop all references to internal objects to help with GC.
  148.       this.config_ = null;
  149.       this.networkingEngine_ = null;
  150.     });
  152.     /**
  153.      * Contains an ID for use with creating streams.  The manifest parser should
  154.      * start with small IDs, so this starts with a large one.
  155.      * @private {number}
  156.      */
  157.     this.nextExternalStreamId_ = 1e9;
  158.   }
  161.   /**
  162.    * Gets whether offline storage is supported.  Returns true if offline storage
  163.    * is supported for clear content.  Support for offline storage of encrypted
  164.    * content will not be determined until storage is attempted.
  165.    *
  166.    * @return {boolean}
  167.    * @export
  168.    */
  169.   static support() {
  170.     // Our Storage system is useless without MediaSource.  MediaSource allows us
  171.     // to pull data from anywhere (including our Storage system) and feed it to
  172.     // the video element.
  173.     if (!shaka.util.Platform.supportsMediaSource()) {
  174.       return false;
  175.     }
  177.     return shaka.offline.StorageMuxer.support();
  178.   }
  180.   /**
  181.    * @override
  182.    * @export
  183.    */
  184.   destroy() {
  185.     return this.destroyer_.destroy();
  186.   }
  188.   /**
  189.    * Sets configuration values for Storage.  This is associated with
  190.    * Player.configure and will change the player instance given at
  191.    * initialization.
  192.    *
  193.    * @param {string|!Object} config This should either be a field name or an
  194.    *   object following the form of {@link shaka.extern.PlayerConfiguration},
  195.    *   where you may omit any field you do not wish to change.
  196.    * @param {*=} value This should be provided if the previous parameter
  197.    *   was a string field name.
  198.    * @return {boolean}
  199.    * @export
  200.    */
  201.   configure(config, value) {
  202.     goog.asserts.assert(typeof(config) == 'object' || arguments.length == 2,
  203.         'String configs should have values!');
  205.     // ('fieldName', value) format
  206.     if (arguments.length == 2 && typeof(config) == 'string') {
  207.       config = shaka.util.ConfigUtils.convertToConfigObject(config, value);
  208.     }
  209.     goog.asserts.assert(typeof(config) == 'object', 'Should be an object!');
  211.     goog.asserts.assert(
  212.         this.config_, 'Cannot reconfigure storage after calling destroy.');
  213.     return shaka.util.PlayerConfiguration.mergeConfigObjects(
  214.         /* destination= */ this.config_, /* updates= */ config );
  215.   }
  217.   /**
  218.    * Return a copy of the current configuration.  Modifications of the returned
  219.    * value will not affect the Storage instance's active configuration.  You
  220.    * must call storage.configure() to make changes.
  221.    *
  222.    * @return {shaka.extern.PlayerConfiguration}
  223.    * @export
  224.    */
  225.   getConfiguration() {
  226.     goog.asserts.assert(this.config_, 'Config must not be null!');
  228.     const ret = shaka.util.PlayerConfiguration.createDefault();
  229.     shaka.util.PlayerConfiguration.mergeConfigObjects(
  230.         ret, this.config_, shaka.util.PlayerConfiguration.createDefault());
  231.     return ret;
  232.   }
  234.   /**
  235.    * Return the networking engine that storage is using. If storage was
  236.    * initialized with a player instance, then the networking engine returned
  237.    * will be the same as |player.getNetworkingEngine()|.
  238.    *
  239.    * The returned value will only be null if |destroy| was called before
  240.    * |getNetworkingEngine|.
  241.    *
  242.    * @return {shaka.net.NetworkingEngine}
  243.    * @export
  244.    */
  245.   getNetworkingEngine() {
  246.     return this.networkingEngine_;
  247.   }
  249.   /**
  250.    * Stores the given manifest.  If the content is encrypted, and encrypted
  251.    * content cannot be stored on this platform, the Promise will be rejected
  252.    * with error code 6001, REQUESTED_KEY_SYSTEM_CONFIG_UNAVAILABLE.
  253.    * Multiple assets can be downloaded at the same time, but note that since
  254.    * the storage instance has a single networking engine, multiple storage
  255.    * objects will be necessary if some assets require unique network filters.
  256.    * This snapshots the storage config at the time of the call, so it will not
  257.    * honor any changes to config mid-store operation.
  258.    *
  259.    * @param {string} uri The URI of the manifest to store.
  260.    * @param {!Object=} appMetadata An arbitrary object from the application
  261.    *   that will be stored along-side the offline content.  Use this for any
  262.    *   application-specific metadata you need associated with the stored
  263.    *   content.  For details on the data types that can be stored here, please
  264.    *   refer to {@link https://bit.ly/StructClone}
  265.    * @param {?string=} mimeType
  266.    *   The mime type for the content |manifestUri| points to.
  267.    * @param {?Array<string>=} externalThumbnails
  268.    *   The external thumbnails to store along the main content.
  269.    * @param {?Array<shaka.extern.ExtraText>=} externalText
  270.    *   The external text to store along the main content.
  271.    * @return {!shaka.extern.IAbortableOperation.<shaka.extern.StoredContent>}
  272.    *   An AbortableOperation that resolves with a structure representing what
  273.    *   was stored.  The "offlineUri" member is the URI that should be given to
  274.    *   Player.load() to play this piece of content offline.  The "appMetadata"
  275.    *   member is the appMetadata argument you passed to store().
  276.    *   If you want to cancel this download, call the "abort" method on
  277.    *   AbortableOperation.
  278.    * @export
  279.    */
  280.   store(uri, appMetadata, mimeType, externalThumbnails, externalText) {
  281.     goog.asserts.assert(
  282.         this.networkingEngine_,
  283.         'Cannot call |store| after calling |destroy|.');
  285.     // Get a copy of the current config.
  286.     const config = this.getConfiguration();
  288.     const getParser = async () => {
  289.       goog.asserts.assert(
  290.           this.networkingEngine_, 'Should not call |store| after |destroy|');
  292.       if (!mimeType) {
  293.         mimeType = await shaka.net.NetworkingUtils.getMimeType(
  294.             uri, this.networkingEngine_, config.manifest.retryParameters);
  295.       }
  297.       const factory = shaka.media.ManifestParser.getFactory(
  298.           uri,
  299.           mimeType || null);
  301.       return factory();
  302.     };
  304.     /** @type {!shaka.offline.DownloadManager} */
  305.     const downloader =
  306.         new shaka.offline.DownloadManager(this.networkingEngine_);
  307.     this.openDownloadManagers_.push(downloader);
  309.     const storeOp = this.store_(
  310.         uri, appMetadata || {}, externalThumbnails || [], externalText || [],
  311.         getParser, config, downloader);
  312.     const abortableStoreOp = new shaka.util.AbortableOperation(storeOp, () => {
  313.       return downloader.abortAll();
  314.     });
  315.     abortableStoreOp.finally(() => {
  316.       shaka.util.ArrayUtils.remove(this.openDownloadManagers_, downloader);
  317.     });
  319.     return this.startAbortableOperation_(abortableStoreOp);
  320.   }
  322.   /**
  323.    * See |shaka.offline.Storage.store| for details.
  324.    *
  325.    * @param {string} uri
  326.    * @param {!Object} appMetadata
  327.    * @param {!Array<string>} externalThumbnails
  328.    * @param {!Array<shaka.extern.ExtraText>} externalText
  329.    * @param {function(): !Promise<shaka.extern.ManifestParser>} getParser
  330.    * @param {shaka.extern.PlayerConfiguration} config
  331.    * @param {!shaka.offline.DownloadManager} downloader
  332.    * @return {!Promise<shaka.extern.StoredContent>}
  333.    * @private
  334.    */
  335.   async store_(uri, appMetadata, externalThumbnails, externalText,
  336.       getParser, config, downloader) {
  337.     this.requireSupport_();
  339.     // Since we will need to use |parser|, |drmEngine|, |activeHandle|, and
  340.     // |muxer| in the catch/finally blocks, we need to define them out here.
  341.     // Since they may not get initialized when we enter the catch/finally block,
  342.     // we need to assume that they may be null/undefined when we get there.
  344.     /** @type {?shaka.extern.ManifestParser} */
  345.     let parser = null;
  346.     /** @type {?shaka.drm.DrmEngine} */
  347.     let drmEngine = null;
  348.     /** @type {shaka.offline.StorageMuxer} */
  349.     const muxer = new shaka.offline.StorageMuxer();
  350.     /** @type {?shaka.offline.StorageCellHandle} */
  351.     let activeHandle = null;
  352.     /** @type {?number} */
  353.     let manifestId = null;
  355.     // This will be used to store any errors from drm engine. Whenever drm
  356.     // engine is passed to another function to do work, we should check if this
  357.     // was set.
  358.     let drmError = null;
  360.     try {
  361.       parser = await getParser();
  363.       const manifest = await this.parseManifest(uri, parser, config);
  365.       // Check if we were asked to destroy ourselves while we were "away"
  366.       // downloading the manifest.
  367.       this.ensureNotDestroyed_();
  369.       // Check if we can even download this type of manifest before trying to
  370.       // create the drm engine.
  371.       const canDownload = !manifest.presentationTimeline.isLive() &&
  372.                           !manifest.presentationTimeline.isInProgress();
  373.       if (!canDownload) {
  374.         throw new shaka.util.Error(
  375.             shaka.util.Error.Severity.CRITICAL,
  376.             shaka.util.Error.Category.STORAGE,
  377.             shaka.util.Error.Code.CANNOT_STORE_LIVE_OFFLINE,
  378.             uri);
  379.       }
  381.       for (const thumbnailUri of externalThumbnails) {
  382.         const imageStream =
  383.             // eslint-disable-next-line no-await-in-loop
  384.             await this.createExternalImageStream_(thumbnailUri, manifest);
  385.         manifest.imageStreams.push(imageStream);
  386.         this.ensureNotDestroyed_();
  387.       }
  389.       for (const text of externalText) {
  390.         const textStream =
  391.             // eslint-disable-next-line no-await-in-loop
  392.             await this.createExternalTextStream_(manifest,
  393.                 text.uri, text.language, text.kind, text.mime, text.codecs);
  394.         manifest.textStreams.push(textStream);
  395.         this.ensureNotDestroyed_();
  396.       }
  398.       shaka.drm.DrmEngine.configureClearKey(
  399.           config.drm.clearKeys, manifest.variants);
  401.       const clearKeyDataLicenseServerUri = manifest.variants.some((v) => {
  402.         if (v.audio) {
  403.           for (const drmInfo of v.audio.drmInfos) {
  404.             if (drmInfo.licenseServerUri.startsWith('data:')) {
  405.               return true;
  406.             }
  407.           }
  408.         }
  409.         if (v.video) {
  410.           for (const drmInfo of v.video.drmInfos) {
  411.             if (drmInfo.licenseServerUri.startsWith('data:')) {
  412.               return true;
  413.             }
  414.           }
  415.         }
  416.         return false;
  417.       });
  419.       let usePersistentLicense = config.offline.usePersistentLicense;
  420.       if (clearKeyDataLicenseServerUri) {
  421.         usePersistentLicense = false;
  422.       }
  424.       // Create the DRM engine, and load the keys in the manifest.
  425.       drmEngine = await this.createDrmEngine(
  426.           manifest,
  427.           (e) => { drmError = drmError || e; },
  428.           config,
  429.           usePersistentLicense);
  431.       // We could have been asked to destroy ourselves while we were "away"
  432.       // creating the drm engine.
  433.       this.ensureNotDestroyed_();
  434.       if (drmError) {
  435.         throw drmError;
  436.       }
  438.       await this.filterManifest_(
  439.           manifest, drmEngine, config, usePersistentLicense);
  441.       await muxer.init();
  442.       this.ensureNotDestroyed_();
  444.       // Get the cell that we are saving the manifest to. Once we get a cell
  445.       // we will only reference the cell and not the muxer so that the manifest
  446.       // and segments will all be saved to the same cell.
  447.       activeHandle = await muxer.getActive();
  448.       this.ensureNotDestroyed_();
  450.       goog.asserts.assert(drmEngine, 'drmEngine should be non-null here.');
  451.       const {manifestDB, toDownload} = this.makeManifestDB_(
  452.           drmEngine, manifest, uri, appMetadata, config, downloader,
  453.           usePersistentLicense);
  455.       // Store the empty manifest, before downloading the segments.
  456.       const ids = await activeHandle.cell.addManifests([manifestDB]);
  457.       this.ensureNotDestroyed_();
  458.       manifestId = ids[0];
  460.       goog.asserts.assert(drmEngine, 'drmEngine should be non-null here.');
  461.       this.ensureNotDestroyed_();
  462.       if (drmError) {
  463.         throw drmError;
  464.       }
  466.       await this.downloadSegments_(toDownload, manifestId, manifestDB,
  467.           downloader, config, activeHandle.cell, manifest, drmEngine,
  468.           usePersistentLicense);
  469.       this.ensureNotDestroyed_();
  471.       this.setManifestDrmFields_(
  472.           manifest, manifestDB, drmEngine, usePersistentLicense);
  473.       await activeHandle.cell.updateManifest(manifestId, manifestDB);
  474.       this.ensureNotDestroyed_();
  476.       const offlineUri = shaka.offline.OfflineUri.manifest(
  477.           activeHandle.path.mechanism, activeHandle.path.cell, manifestId);
  479.       return shaka.offline.StoredContentUtils.fromManifestDB(
  480.           offlineUri, manifestDB);
  481.     } catch (e) {
  482.       if (manifestId != null) {
  483.         await shaka.offline.Storage.cleanStoredManifest(manifestId);
  484.       }
  486.       // If we already had an error, ignore this error to avoid hiding
  487.       // the original error.
  488.       throw drmError || e;
  489.     } finally {
  490.       await muxer.destroy();
  492.       if (parser) {
  493.         await parser.stop();
  494.       }
  496.       if (drmEngine) {
  497.         await drmEngine.destroy();
  498.       }
  499.     }
  500.   }
  502.   /**
  503.    * Download and then store the contents of each segment.
  504.    * The promise this returns will wait for local downloads.
  505.    *
  506.    * @param {!Array<!shaka.offline.DownloadInfo>} toDownload
  507.    * @param {number} manifestId
  508.    * @param {shaka.extern.ManifestDB} manifestDB
  509.    * @param {!shaka.offline.DownloadManager} downloader
  510.    * @param {shaka.extern.PlayerConfiguration} config
  511.    * @param {shaka.extern.StorageCell} storage
  512.    * @param {shaka.extern.Manifest} manifest
  513.    * @param {!shaka.drm.DrmEngine} drmEngine
  514.    * @param {boolean} usePersistentLicense
  515.    * @return {!Promise}
  516.    * @private
  517.    */
  518.   async downloadSegments_(
  519.       toDownload, manifestId, manifestDB, downloader, config, storage,
  520.       manifest, drmEngine, usePersistentLicense) {
  521.     let pendingManifestUpdates = {};
  522.     let pendingDataSize = 0;
  524.     const ensureNotAbortedOrDestroyed = () => {
  525.       if (this.destroyer_.destroyed() || downloader.isAborted()) {
  526.         throw new shaka.util.Error(
  527.             shaka.util.Error.Severity.CRITICAL,
  528.             shaka.util.Error.Category.STORAGE,
  529.             shaka.util.Error.Code.OPERATION_ABORTED);
  530.       }
  531.     };
  533.     /**
  534.      * @param {!Array<!shaka.offline.DownloadInfo>} toDownload
  535.      * @param {boolean} updateDRM
  536.      */
  537.     const download = async (toDownload, updateDRM) => {
  538.       for (const download of toDownload) {
  539.         ensureNotAbortedOrDestroyed();
  540.         const request = download.makeSegmentRequest(config);
  541.         const estimateId = download.estimateId;
  542.         const isInitSegment = download.isInitSegment;
  544.         const onDownloaded = async (data) => {
  545.           const ref = /** @type {!shaka.media.SegmentReference} */ (
  546.             download.ref);
  547.           const id = shaka.offline.DownloadInfo.idForSegmentRef(ref);
  548.           if (ref.aesKey) {
  549.             data = await shaka.media.SegmentUtils.aesDecrypt(
  550.                 data, ref.aesKey, download.refPosition);
  551.           }
  552.           // Store the data.
  553.           const dataKeys = await storage.addSegments([{data}]);
  554.           ensureNotAbortedOrDestroyed();
  556.           // Store the necessary update to the manifest, to be processed later.
  557.           pendingManifestUpdates[id] = dataKeys[0];
  558.           pendingDataSize += data.byteLength;
  559.         };
  561.         const ref = /** @type {!shaka.media.SegmentReference} */ (
  562.           download.ref);
  563.         const segmentData = ref.getSegmentData();
  564.         if (segmentData) {
  565.           downloader.queueData(download.groupId,
  566.               segmentData, estimateId, isInitSegment, onDownloaded);
  567.         } else {
  568.           downloader.queue(download.groupId,
  569.               request, estimateId, isInitSegment, onDownloaded);
  570.         }
  571.       }
  572.       await downloader.waitToFinish();
  573.       ensureNotAbortedOrDestroyed();
  575.       if (updateDRM && !downloader.isAborted()) {
  576.         // Re-store the manifest, to attach session IDs.
  577.         // These were (maybe) discovered inside the downloader; we can only add
  578.         // them now, at the end, since the manifestDB is in flux during the
  579.         // process of downloading and storing, and assignSegmentsToManifest
  580.         // does not know about the DRM engine.
  581.         this.setManifestDrmFields_(
  582.             manifest, manifestDB, drmEngine, usePersistentLicense);
  583.         await storage.updateManifest(manifestId, manifestDB);
  584.       }
  585.     };
  587.     const usingBgFetch = false; // TODO: Get.
  589.     try {
  590.       if (this.getManifestIsEncrypted_(manifest) && usingBgFetch &&
  591.           !this.getManifestIncludesInitData_(manifest)) {
  592.         // Background fetch can't make DRM sessions, so if we have to get the
  593.         // init data from the init segments, download those first before
  594.         // anything else.
  595.         await download(toDownload.filter((info) => info.isInitSegment), true);
  596.         ensureNotAbortedOrDestroyed();
  597.         toDownload = toDownload.filter((info) => !info.isInitSegment);
  599.         // Copy these and reset them now, before calling await.
  600.         const manifestUpdates = pendingManifestUpdates;
  601.         const dataSize = pendingDataSize;
  602.         pendingManifestUpdates = {};
  603.         pendingDataSize = 0;
  605.         await shaka.offline.Storage.assignSegmentsToManifest(
  606.             storage, manifestId, manifestDB, manifestUpdates, dataSize,
  607.             () => this.ensureNotDestroyed_());
  608.         ensureNotAbortedOrDestroyed();
  609.       }
  611.       if (!usingBgFetch) {
  612.         await download(toDownload, false);
  613.         ensureNotAbortedOrDestroyed();
  615.         // Copy these and reset them now, before calling await.
  616.         const manifestUpdates = pendingManifestUpdates;
  617.         const dataSize = pendingDataSize;
  618.         pendingManifestUpdates = {};
  619.         pendingDataSize = 0;
  621.         await shaka.offline.Storage.assignSegmentsToManifest(
  622.             storage, manifestId, manifestDB, manifestUpdates, dataSize,
  623.             () => ensureNotAbortedOrDestroyed());
  624.         ensureNotAbortedOrDestroyed();
  626.         goog.asserts.assert(
  627.             !manifestDB.isIncomplete, 'The manifest should be complete by now');
  628.       } else {
  629.         // TODO: Send the request to the service worker. Don't await the result.
  630.       }
  631.     } catch (error) {
  632.       const dataKeys = Object.values(pendingManifestUpdates);
  633.       // Remove these pending segments that are not yet linked to the manifest.
  634.       await storage.removeSegments(dataKeys, (key) => {});
  636.       throw error;
  637.     }
  638.   }
  640.   /**
  641.    * Removes all of the contents for a given manifest, statelessly.
  642.    *
  643.    * @param {number} manifestId
  644.    * @return {!Promise}
  645.    */
  646.   static async cleanStoredManifest(manifestId) {
  647.     const muxer = new shaka.offline.StorageMuxer();
  648.     await muxer.init();
  649.     const activeHandle = await muxer.getActive();
  650.     const uri = shaka.offline.OfflineUri.manifest(
  651.         activeHandle.path.mechanism,
  652.         activeHandle.path.cell,
  653.         manifestId);
  654.     await muxer.destroy();
  655.     const storage = new shaka.offline.Storage();
  656.     await storage.remove(uri.toString());
  657.   }
  659.   /**
  660.    * Updates the given manifest, assigns database keys to segments, then stores
  661.    * the updated manifest.
  662.    *
  663.    * It is up to the caller to ensure that this method is not called
  664.    * concurrently on the same manifest.
  665.    *
  666.    * @param {shaka.extern.StorageCell} storage
  667.    * @param {number} manifestId
  668.    * @param {!shaka.extern.ManifestDB} manifestDB
  669.    * @param {!Object<string, number>} manifestUpdates
  670.    * @param {number} dataSizeUpdate
  671.    * @param {function()} throwIfAbortedFn  A function that should throw if the
  672.    *   download has been aborted.
  673.    * @return {!Promise}
  674.    */
  675.   static async assignSegmentsToManifest(
  676.       storage, manifestId, manifestDB, manifestUpdates, dataSizeUpdate,
  677.       throwIfAbortedFn) {
  678.     let manifestUpdated = false;
  680.     try {
  681.       // Assign the stored data to the manifest.
  682.       let complete = true;
  683.       for (const stream of manifestDB.streams) {
  684.         for (const segment of stream.segments) {
  685.           let dataKey = segment.pendingSegmentRefId ?
  686.               manifestUpdates[segment.pendingSegmentRefId] : null;
  687.           if (dataKey != null) {
  688.             segment.dataKey = dataKey;
  689.             // Now that the segment has been associated with the appropriate
  690.             // dataKey, the pendingSegmentRefId is no longer necessary.
  691.             segment.pendingSegmentRefId = undefined;
  692.           }
  694.           dataKey = segment.pendingInitSegmentRefId ?
  695.               manifestUpdates[segment.pendingInitSegmentRefId] : null;
  696.           if (dataKey != null) {
  697.             segment.initSegmentKey = dataKey;
  698.             // Now that the init segment has been associated with the
  699.             // appropriate initSegmentKey, the pendingInitSegmentRefId is no
  700.             // longer necessary.
  701.             segment.pendingInitSegmentRefId = undefined;
  702.           }
  704.           if (segment.pendingSegmentRefId) {
  705.             complete = false;
  706.           }
  707.           if (segment.pendingInitSegmentRefId) {
  708.             complete = false;
  709.           }
  710.         }
  711.       }
  713.       // Update the size of the manifest.
  714.       manifestDB.size += dataSizeUpdate;
  716.       // Mark the manifest as complete, if all segments are downloaded.
  717.       if (complete) {
  718.         manifestDB.isIncomplete = false;
  719.       }
  721.       // Update the manifest.
  722.       await storage.updateManifest(manifestId, manifestDB);
  723.       manifestUpdated = true;
  724.       throwIfAbortedFn();
  725.     } catch (e) {
  726.       await shaka.offline.Storage.cleanStoredManifest(manifestId);
  728.       if (!manifestUpdated) {
  729.         const dataKeys = Object.values(manifestUpdates);
  730.         // The cleanStoredManifest method will not "see" any segments that have
  731.         // been downloaded but not assigned to the manifest yet. So un-store
  732.         // them separately.
  733.         await storage.removeSegments(dataKeys, (key) => {});
  734.       }
  736.       throw e;
  737.     }
  738.   }
  740.   /**
  741.    * Filter |manifest| such that it will only contain the variants and text
  742.    * streams that we want to store and can actually play.
  743.    *
  744.    * @param {shaka.extern.Manifest} manifest
  745.    * @param {!shaka.drm.DrmEngine} drmEngine
  746.    * @param {shaka.extern.PlayerConfiguration} config
  747.    * @param {boolean} usePersistentLicense
  748.    * @return {!Promise}
  749.    * @private
  750.    */
  751.   async filterManifest_(manifest, drmEngine, config, usePersistentLicense) {
  752.     // Filter the manifest based on the restrictions given in the player
  753.     // configuration.
  754.     const maxHwRes = {width: Infinity, height: Infinity};
  755.     shaka.util.StreamUtils.filterByRestrictions(
  756.         manifest, config.restrictions, maxHwRes);
  758.     // Filter the manifest based on what we know MediaCapabilities will be able
  759.     // to play later (no point storing something we can't play).
  760.     await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
  761.         drmEngine, manifest, usePersistentLicense,
  762.         config.drm.preferredKeySystems, config.drm.keySystemsMapping);
  764.     // Gather all tracks.
  765.     const allTracks = [];
  767.     // Choose the codec that has the lowest average bandwidth.
  768.     const preferredDecodingAttributes = config.preferredDecodingAttributes;
  769.     const preferredVideoCodecs = config.preferredVideoCodecs;
  770.     const preferredAudioCodecs = config.preferredAudioCodecs;
  771.     const preferredTextFormats = config.preferredTextFormats;
  773.     shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
  774.         manifest, preferredVideoCodecs, preferredAudioCodecs,
  775.         preferredDecodingAttributes, preferredTextFormats);
  777.     for (const variant of manifest.variants) {
  778.       goog.asserts.assert(
  779.           shaka.util.StreamUtils.isPlayable(variant),
  780.           'We should have already filtered by "is playable"');
  782.       allTracks.push(shaka.util.StreamUtils.variantToTrack(variant));
  783.     }
  785.     for (const text of manifest.textStreams) {
  786.       allTracks.push(shaka.util.StreamUtils.textStreamToTrack(text));
  787.     }
  789.     for (const image of manifest.imageStreams) {
  790.       allTracks.push(shaka.util.StreamUtils.imageStreamToTrack(image));
  791.     }
  793.     // Let the application choose which tracks to store.
  794.     const chosenTracks =
  795.         await config.offline.trackSelectionCallback(allTracks);
  796.     const duration = manifest.presentationTimeline.getDuration();
  797.     let sizeEstimate = 0;
  798.     for (const track of chosenTracks) {
  799.       const trackSize = track.bandwidth * duration / 8;
  800.       sizeEstimate += trackSize;
  801.     }
  802.     try {
  803.       const allowedDownload =
  804.           await config.offline.downloadSizeCallback(sizeEstimate);
  805.       if (!allowedDownload) {
  806.         throw new shaka.util.Error(
  807.             shaka.util.Error.Severity.CRITICAL,
  808.             shaka.util.Error.Category.STORAGE,
  809.             shaka.util.Error.Code.STORAGE_LIMIT_REACHED);
  810.       }
  811.     } catch (e) {
  812.       // It is necessary to be able to catch the STORAGE_LIMIT_REACHED error
  813.       if (e instanceof shaka.util.Error) {
  814.         throw e;
  815.       }
  816.       shaka.log.warning(
  817.           'downloadSizeCallback has produced an unexpected error', e);
  818.       throw new shaka.util.Error(
  819.           shaka.util.Error.Severity.CRITICAL,
  820.           shaka.util.Error.Category.STORAGE,
  821.           shaka.util.Error.Code.DOWNLOAD_SIZE_CALLBACK_ERROR);
  822.     }
  824.     /** @type {!Set<number>} */
  825.     const variantIds = new Set();
  826.     /** @type {!Set<number>} */
  827.     const textIds = new Set();
  828.     /** @type {!Set<number>} */
  829.     const imageIds = new Set();
  831.     // Collect the IDs of the chosen tracks.
  832.     for (const track of chosenTracks) {
  833.       if (track.type == 'variant') {
  834.         variantIds.add(track.id);
  835.       }
  836.       if (track.type == 'text') {
  837.         textIds.add(track.id);
  838.       }
  839.       if (track.type == 'image') {
  840.         imageIds.add(track.id);
  841.       }
  842.     }
  844.     // Filter the manifest to keep only what the app chose.
  845.     manifest.variants =
  846.         manifest.variants.filter((variant) => variantIds.has(variant.id));
  847.     manifest.textStreams =
  848.         manifest.textStreams.filter((stream) => textIds.has(stream.id));
  849.     manifest.imageStreams =
  850.         manifest.imageStreams.filter((stream) => imageIds.has(stream.id));
  852.     // Check the post-filtered manifest for characteristics that may indicate
  853.     // issues with how the app selected tracks.
  854.     shaka.offline.Storage.validateManifest_(manifest);
  855.   }
  857.   /**
  858.    * Create a download manager and download the manifest.
  859.    * This also sets up download infos for each segment to be downloaded.
  860.    *
  861.    * @param {!shaka.drm.DrmEngine} drmEngine
  862.    * @param {shaka.extern.Manifest} manifest
  863.    * @param {string} uri
  864.    * @param {!Object} metadata
  865.    * @param {shaka.extern.PlayerConfiguration} config
  866.    * @param {!shaka.offline.DownloadManager} downloader
  867.    * @param {boolean} usePersistentLicense
  868.    * @return {{
  869.    *   manifestDB: shaka.extern.ManifestDB,
  870.    *   toDownload: !Array<!shaka.offline.DownloadInfo>
  871.    * }}
  872.    * @private
  873.    */
  874.   makeManifestDB_(drmEngine, manifest, uri, metadata, config, downloader,
  875.       usePersistentLicense) {
  876.     const pendingContent = shaka.offline.StoredContentUtils.fromManifest(
  877.         uri, manifest, /* size= */ 0, metadata);
  878.     // In https://github.com/shaka-project/shaka-player/issues/2652, we found
  879.     // that this callback would be removed by the compiler if we reference the
  880.     // config in the onProgress closure below.  Reading it into a local
  881.     // variable first seems to work around this apparent compiler bug.
  882.     const progressCallback = config.offline.progressCallback;
  884.     const onProgress = (progress, size) => {
  885.       // Update the size of the stored content before issuing a progress
  886.       // update.
  887.       pendingContent.size = size;
  888.       progressCallback(pendingContent, progress);
  889.     };
  890.     const onInitData = (initData, systemId) => {
  891.       if (needsInitData && usePersistentLicense &&
  892.           currentSystemId == systemId) {
  893.         drmEngine.newInitData('cenc', initData);
  894.       }
  895.     };
  896.     downloader.setCallbacks(onProgress, onInitData);
  898.     const needsInitData = this.getManifestIsEncrypted_(manifest) &&
  899.                           !this.getManifestIncludesInitData_(manifest);
  901.     let currentSystemId = null;
  902.     if (needsInitData) {
  903.       const drmInfo = drmEngine.getDrmInfo();
  904.       currentSystemId =
  905.           shaka.offline.Storage.defaultSystemIds_.get(drmInfo.keySystem);
  906.     }
  908.     // Make the estimator, which is used to make the download registries.
  909.     const estimator = new shaka.offline.StreamBandwidthEstimator();
  910.     for (const stream of manifest.textStreams) {
  911.       estimator.addText(stream);
  912.     }
  913.     for (const stream of manifest.imageStreams) {
  914.       estimator.addImage(stream);
  915.     }
  916.     for (const variant of manifest.variants) {
  917.       estimator.addVariant(variant);
  918.     }
  919.     const {streams, toDownload} = this.createStreams_(
  920.         downloader, estimator, drmEngine, manifest, config);
  922.     const drmInfo = drmEngine.getDrmInfo();
  923.     if (drmInfo && usePersistentLicense) {
  924.       // Don't store init data, since we have stored sessions.
  925.       drmInfo.initData = [];
  926.     }
  928.     const manifestDB = {
  929.       creationTime: Date.now(),
  930.       originalManifestUri: uri,
  931.       duration: manifest.presentationTimeline.getDuration(),
  932.       size: 0,
  933.       expiration: drmEngine.getExpiration(),
  934.       streams,
  935.       sessionIds: usePersistentLicense ? drmEngine.getSessionIds() : [],
  936.       drmInfo,
  937.       appMetadata: metadata,
  938.       isIncomplete: true,
  939.       sequenceMode: manifest.sequenceMode,
  940.       type: manifest.type,
  941.     };
  943.     return {manifestDB, toDownload};
  944.   }
  946.   /**
  947.    * @param {shaka.extern.Manifest} manifest
  948.    * @return {boolean}
  949.    * @private
  950.    */
  951.   getManifestIsEncrypted_(manifest) {
  952.     return manifest.variants.some((variant) => {
  953.       const videoEncrypted = variant.video && variant.video.encrypted;
  954.       const audioEncrypted = variant.audio && variant.audio.encrypted;
  955.       return videoEncrypted || audioEncrypted;
  956.     });
  957.   }
  959.   /**
  960.    * @param {shaka.extern.Manifest} manifest
  961.    * @return {boolean}
  962.    * @private
  963.    */
  964.   getManifestIncludesInitData_(manifest) {
  965.     return manifest.variants.some((variant) => {
  966.       const videoDrmInfos = variant.video ? variant.video.drmInfos : [];
  967.       const audioDrmInfos = variant.audio ? variant.audio.drmInfos : [];
  968.       const drmInfos = videoDrmInfos.concat(audioDrmInfos);
  969.       return drmInfos.some((drmInfos) => {
  970.         return drmInfos.initData && drmInfos.initData.length;
  971.       });
  972.     });
  973.   }
  975.   /**
  976.    * @param {shaka.extern.Manifest} manifest
  977.    * @param {shaka.extern.ManifestDB} manifestDB
  978.    * @param {!shaka.drm.DrmEngine} drmEngine
  979.    * @param {boolean} usePersistentLicense
  980.    * @private
  981.    */
  982.   setManifestDrmFields_(manifest, manifestDB, drmEngine, usePersistentLicense) {
  983.     manifestDB.expiration = drmEngine.getExpiration();
  985.     const sessions = drmEngine.getSessionIds();
  986.     manifestDB.sessionIds = usePersistentLicense ? sessions : [];
  988.     if (this.getManifestIsEncrypted_(manifest) &&
  989.         usePersistentLicense && !sessions.length) {
  990.       throw new shaka.util.Error(
  991.           shaka.util.Error.Severity.CRITICAL,
  992.           shaka.util.Error.Category.STORAGE,
  993.           shaka.util.Error.Code.NO_INIT_DATA_FOR_OFFLINE);
  994.     }
  995.   }
  997.   /**
  998.    * Removes the given stored content.  This will also attempt to release the
  999.    * licenses, if any.
  1000.    *
  1001.    * @param {string} contentUri
  1002.    * @return {!Promise}
  1003.    * @export
  1004.    */
  1005.   remove(contentUri) {
  1006.     return this.startOperation_(this.remove_(contentUri));
  1007.   }
  1009.   /**
  1010.    * See |shaka.offline.Storage.remove| for details.
  1011.    *
  1012.    * @param {string} contentUri
  1013.    * @return {!Promise}
  1014.    * @private
  1015.    */
  1016.   async remove_(contentUri) {
  1017.     this.requireSupport_();
  1019.     const nullableUri = shaka.offline.OfflineUri.parse(contentUri);
  1020.     if (nullableUri == null || !nullableUri.isManifest()) {
  1021.       throw new shaka.util.Error(
  1022.           shaka.util.Error.Severity.CRITICAL,
  1023.           shaka.util.Error.Category.STORAGE,
  1024.           shaka.util.Error.Code.MALFORMED_OFFLINE_URI,
  1025.           contentUri);
  1026.     }
  1028.     /** @type {!shaka.offline.OfflineUri} */
  1029.     const uri = nullableUri;
  1031.     /** @type {!shaka.offline.StorageMuxer} */
  1032.     const muxer = new shaka.offline.StorageMuxer();
  1034.     try {
  1035.       await muxer.init();
  1037.       const cell = await muxer.getCell(uri.mechanism(), uri.cell());
  1038.       const manifests = await cell.getManifests([uri.key()]);
  1039.       const manifest = manifests[0];
  1041.       await Promise.all([
  1042.         this.removeFromDRM_(uri, manifest, muxer),
  1043.         this.removeFromStorage_(cell, uri, manifest),
  1044.       ]);
  1045.     } finally {
  1046.       await muxer.destroy();
  1047.     }
  1048.   }
  1050.   /**
  1051.    * @param {shaka.extern.ManifestDB} manifestDb
  1052.    * @param {boolean} isVideo
  1053.    * @return {!Array<MediaKeySystemMediaCapability>}
  1054.    * @private
  1055.    */
  1056.   static getCapabilities_(manifestDb, isVideo) {
  1057.     const MimeUtils = shaka.util.MimeUtils;
  1059.     const ret = [];
  1060.     for (const stream of manifestDb.streams) {
  1061.       if (isVideo && stream.type == 'video') {
  1062.         ret.push({
  1063.           contentType: MimeUtils.getFullType(stream.mimeType, stream.codecs),
  1064.           robustness: manifestDb.drmInfo.videoRobustness,
  1065.         });
  1066.       } else if (!isVideo && stream.type == 'audio') {
  1067.         ret.push({
  1068.           contentType: MimeUtils.getFullType(stream.mimeType, stream.codecs),
  1069.           robustness: manifestDb.drmInfo.audioRobustness,
  1070.         });
  1071.       }
  1072.     }
  1073.     return ret;
  1074.   }
  1076.   /**
  1077.    * @param {!shaka.offline.OfflineUri} uri
  1078.    * @param {shaka.extern.ManifestDB} manifestDb
  1079.    * @param {!shaka.offline.StorageMuxer} muxer
  1080.    * @return {!Promise}
  1081.    * @private
  1082.    */
  1083.   async removeFromDRM_(uri, manifestDb, muxer) {
  1084.     goog.asserts.assert(this.networkingEngine_, 'Cannot be destroyed');
  1085.     await shaka.offline.Storage.deleteLicenseFor_(
  1086.         this.networkingEngine_, this.config_.drm, muxer, manifestDb);
  1087.   }
  1089.   /**
  1090.    * @param {shaka.extern.StorageCell} storage
  1091.    * @param {!shaka.offline.OfflineUri} uri
  1092.    * @param {shaka.extern.ManifestDB} manifest
  1093.    * @return {!Promise}
  1094.    * @private
  1095.    */
  1096.   removeFromStorage_(storage, uri, manifest) {
  1097.     /** @type {!Array<number>} */
  1098.     const segmentIds = shaka.offline.Storage.getAllSegmentIds_(manifest);
  1100.     // Count(segments) + Count(manifests)
  1101.     const toRemove = segmentIds.length + 1;
  1102.     let removed = 0;
  1104.     const pendingContent = shaka.offline.StoredContentUtils.fromManifestDB(
  1105.         uri, manifest);
  1107.     const onRemove = (key) => {
  1108.       removed += 1;
  1109.       this.config_.offline.progressCallback(pendingContent, removed / toRemove);
  1110.     };
  1112.     return Promise.all([
  1113.       storage.removeSegments(segmentIds, onRemove),
  1114.       storage.removeManifests([uri.key()], onRemove),
  1115.     ]);
  1116.   }
  1118.   /**
  1119.    * Removes any EME sessions that were not successfully removed before.  This
  1120.    * returns whether all the sessions were successfully removed.
  1121.    *
  1122.    * @return {!Promise<boolean>}
  1123.    * @export
  1124.    */
  1125.   removeEmeSessions() {
  1126.     return this.startOperation_(this.removeEmeSessions_());
  1127.   }
  1129.   /**
  1130.    * @return {!Promise<boolean>}
  1131.    * @private
  1132.    */
  1133.   async removeEmeSessions_() {
  1134.     this.requireSupport_();
  1136.     goog.asserts.assert(this.networkingEngine_, 'Cannot be destroyed');
  1137.     const net = this.networkingEngine_;
  1138.     const config = this.config_.drm;
  1140.     /** @type {!shaka.offline.StorageMuxer} */
  1141.     const muxer = new shaka.offline.StorageMuxer();
  1142.     /** @type {!shaka.offline.SessionDeleter} */
  1143.     const deleter = new shaka.offline.SessionDeleter();
  1145.     let hasRemaining = false;
  1147.     try {
  1148.       await muxer.init();
  1150.       /** @type {!Array<shaka.extern.EmeSessionStorageCell>} */
  1151.       const cells = [];
  1152.       muxer.forEachEmeSessionCell((c) => cells.push(c));
  1154.       // Run these sequentially to avoid creating too many DrmEngine instances
  1155.       // and having multiple CDMs alive at once.  Some embedded platforms may
  1156.       // not support that.
  1157.       for (const sessionIdCell of cells) {
  1158.         /* eslint-disable no-await-in-loop */
  1159.         const sessions = await sessionIdCell.getAll();
  1160.         const deletedSessionIds = await deleter.delete(config, net, sessions);
  1161.         await sessionIdCell.remove(deletedSessionIds);
  1163.         if (deletedSessionIds.length != sessions.length) {
  1164.           hasRemaining = true;
  1165.         }
  1166.         /* eslint-enable no-await-in-loop */
  1167.       }
  1168.     } finally {
  1169.       await muxer.destroy();
  1170.     }
  1172.     return !hasRemaining;
  1173.   }
  1175.   /**
  1176.    * Lists all the stored content available.
  1177.    *
  1178.    * @return {!Promise<!Array<shaka.extern.StoredContent>>}  A Promise to an
  1179.    *   array of structures representing all stored content.  The "offlineUri"
  1180.    *   member of the structure is the URI that should be given to Player.load()
  1181.    *   to play this piece of content offline.  The "appMetadata" member is the
  1182.    *   appMetadata argument you passed to store().
  1183.    * @export
  1184.    */
  1185.   list() {
  1186.     return this.startOperation_(this.list_());
  1187.   }
  1189.   /**
  1190.    * See |shaka.offline.Storage.list| for details.
  1191.    *
  1192.    * @return {!Promise<!Array<shaka.extern.StoredContent>>}
  1193.    * @private
  1194.    */
  1195.   async list_() {
  1196.     this.requireSupport_();
  1198.     /** @type {!Array<shaka.extern.StoredContent>} */
  1199.     const result = [];
  1201.     /** @type {!shaka.offline.StorageMuxer} */
  1202.     const muxer = new shaka.offline.StorageMuxer();
  1203.     try {
  1204.       await muxer.init();
  1206.       let p = Promise.resolve();
  1207.       muxer.forEachCell((path, cell) => {
  1208.         p = p.then(async () => {
  1209.           const manifests = await cell.getAllManifests();
  1211.           manifests.forEach((manifest, key) => {
  1212.             const uri = shaka.offline.OfflineUri.manifest(
  1213.                 path.mechanism,
  1214.                 path.cell,
  1215.                 key);
  1217.             const content = shaka.offline.StoredContentUtils.fromManifestDB(
  1218.                 uri,
  1219.                 manifest);
  1221.             result.push(content);
  1222.           });
  1223.         });
  1224.       });
  1226.       await p;
  1227.     } finally {
  1228.       await muxer.destroy();
  1229.     }
  1231.     return result;
  1232.   }
  1235.   /**
  1236.    * This method is public so that it can be overridden in testing.
  1237.    *
  1238.    * @param {string} uri
  1239.    * @param {shaka.extern.ManifestParser} parser
  1240.    * @param {shaka.extern.PlayerConfiguration} config
  1241.    * @return {!Promise<shaka.extern.Manifest>}
  1242.    */
  1243.   async parseManifest(uri, parser, config) {
  1244.     let error = null;
  1246.     const networkingEngine = this.networkingEngine_;
  1247.     goog.asserts.assert(networkingEngine, 'Should be initialized!');
  1249.     /** @type {shaka.extern.ManifestParser.PlayerInterface} */
  1250.     const playerInterface = {
  1251.       networkingEngine: networkingEngine,
  1253.       // Don't bother filtering now. We will do that later when we have all the
  1254.       // information we need to filter.
  1255.       filter: () => Promise.resolve(),
  1257.       // The responsibility for making mock text streams for closed captions is
  1258.       // handled inside shaka.offline.OfflineManifestParser, before playback.
  1259.       makeTextStreamsForClosedCaptions: (manifest) => {},
  1261.       onTimelineRegionAdded: () => {},
  1262.       onEvent: () => {},
  1264.       // Used to capture an error from the manifest parser. We will check the
  1265.       // error before returning.
  1266.       onError: (e) => {
  1267.         error = e;
  1268.       },
  1269.       isLowLatencyMode: () => false,
  1270.       updateDuration: () => {},
  1271.       newDrmInfo: (stream) => {},
  1272.       onManifestUpdated: () => {},
  1273.       getBandwidthEstimate: () => config.abr.defaultBandwidthEstimate,
  1274.       onMetadata: () => {},
  1275.       disableStream: (stream) => {},
  1276.       addFont: (name, url) => {},
  1277.     };
  1279.     parser.configure(config.manifest);
  1281.     // We may have been destroyed while we were waiting on |getParser| to
  1282.     // resolve.
  1283.     this.ensureNotDestroyed_();
  1285.     const manifest = await parser.start(uri, playerInterface);
  1287.     // We may have been destroyed while we were waiting on |start| to
  1288.     // resolve.
  1289.     this.ensureNotDestroyed_();
  1291.     // Get all the streams that are used in the manifest.
  1292.     const streams =
  1293.         shaka.offline.Storage.getAllStreamsFromManifest_(manifest);
  1295.     // Wait for each stream to create their segment indexes.
  1296.     await Promise.all(shaka.util.Iterables.map(streams, (stream) => {
  1297.       return stream.createSegmentIndex();
  1298.     }));
  1300.     // We may have been destroyed while we were waiting on
  1301.     // |createSegmentIndex| to resolve for each stream.
  1302.     this.ensureNotDestroyed_();
  1304.     // If we saw an error while parsing, surface the error.
  1305.     if (error) {
  1306.       throw error;
  1307.     }
  1309.     return manifest;
  1310.   }
  1312.   /**
  1313.    * @param {string} uri
  1314.    * @param {shaka.extern.Manifest} manifest
  1315.    * @return {!Promise<shaka.extern.Stream>}
  1316.    * @private
  1317.    */
  1318.   async createExternalImageStream_(uri, manifest) {
  1319.     const mimeType = await this.getTextMimetype_(uri);
  1321.     if (mimeType != 'text/vtt') {
  1322.       throw new shaka.util.Error(
  1323.           shaka.util.Error.Severity.RECOVERABLE,
  1324.           shaka.util.Error.Category.TEXT,
  1325.           shaka.util.Error.Code.UNSUPPORTED_EXTERNAL_THUMBNAILS_URI,
  1326.           uri);
  1327.     }
  1329.     goog.asserts.assert(
  1330.         this.networkingEngine_, 'Need networking engine.');
  1331.     const buffer = await this.getTextData_(uri,
  1332.         this.networkingEngine_,
  1333.         this.config_.streaming.retryParameters);
  1335.     const factory = shaka.text.TextEngine.findParser(mimeType);
  1336.     if (!factory) {
  1337.       throw new shaka.util.Error(
  1338.           shaka.util.Error.Severity.CRITICAL,
  1339.           shaka.util.Error.Category.TEXT,
  1340.           shaka.util.Error.Code.MISSING_TEXT_PLUGIN,
  1341.           mimeType);
  1342.     }
  1343.     const TextParser = factory();
  1344.     const time = {
  1345.       periodStart: 0,
  1346.       segmentStart: 0,
  1347.       segmentEnd: manifest.presentationTimeline.getDuration(),
  1348.       vttOffset: 0,
  1349.     };
  1350.     const data = shaka.util.BufferUtils.toUint8(buffer);
  1351.     const cues = TextParser.parseMedia(data, time, uri, /* images= */ []);
  1353.     const references = [];
  1354.     for (const cue of cues) {
  1355.       let uris = null;
  1356.       const getUris = () => {
  1357.         if (uris == null) {
  1358.           uris = shaka.util.ManifestParserUtils.resolveUris(
  1359.               [uri], [cue.payload]);
  1360.         }
  1361.         return uris || [];
  1362.       };
  1363.       const reference = new shaka.media.SegmentReference(
  1364.           cue.startTime,
  1365.           cue.endTime,
  1366.           getUris,
  1367.           /* startByte= */ 0,
  1368.           /* endByte= */ null,
  1369.           /* initSegmentReference= */ null,
  1370.           /* timestampOffset= */ 0,
  1371.           /* appendWindowStart= */ 0,
  1372.           /* appendWindowEnd= */ Infinity,
  1373.       );
  1374.       if (cue.payload.includes('#xywh')) {
  1375.         const spriteInfo = cue.payload.split('#xywh=')[1].split(',');
  1376.         if (spriteInfo.length === 4) {
  1377.           reference.setThumbnailSprite({
  1378.             height: parseInt(spriteInfo[3], 10),
  1379.             positionX: parseInt(spriteInfo[0], 10),
  1380.             positionY: parseInt(spriteInfo[1], 10),
  1381.             width: parseInt(spriteInfo[2], 10),
  1382.           });
  1383.         }
  1384.       }
  1385.       references.push(reference);
  1386.     }
  1388.     let segmentMimeType = mimeType;
  1389.     if (references.length) {
  1390.       segmentMimeType = await shaka.net.NetworkingUtils.getMimeType(
  1391.           references[0].getUris()[0],
  1392.           this.networkingEngine_, this.config_.manifest.retryParameters);
  1393.     }
  1395.     return {
  1396.       id: this.nextExternalStreamId_++,
  1397.       originalId: null,
  1398.       groupId: null,
  1399.       createSegmentIndex: () => Promise.resolve(),
  1400.       segmentIndex: new shaka.media.SegmentIndex(references),
  1401.       mimeType: segmentMimeType || '',
  1402.       codecs: '',
  1403.       kind: '',
  1404.       encrypted: false,
  1405.       drmInfos: [],
  1406.       keyIds: new Set(),
  1407.       language: 'und',
  1408.       originalLanguage: null,
  1409.       label: null,
  1410.       type: shaka.util.ManifestParserUtils.ContentType.IMAGE,
  1411.       primary: false,
  1412.       trickModeVideo: null,
  1413.       emsgSchemeIdUris: null,
  1414.       roles: [],
  1415.       forced: false,
  1416.       channelsCount: null,
  1417.       audioSamplingRate: null,
  1418.       spatialAudio: false,
  1419.       closedCaptions: null,
  1420.       tilesLayout: '1x1',
  1421.       accessibilityPurpose: null,
  1422.       external: true,
  1423.       fastSwitching: false,
  1424.       fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
  1425.           segmentMimeType || '', '')]),
  1426.       isAudioMuxedInVideo: false,
  1427.     };
  1428.   }
  1430.   /**
  1431.    * @param {shaka.extern.Manifest} manifest
  1432.    * @param {string} uri
  1433.    * @param {string} language
  1434.    * @param {string} kind
  1435.    * @param {string=} mimeType
  1436.    * @param {string=} codec
  1437.    * @private
  1438.    */
  1439.   async createExternalTextStream_(manifest, uri, language, kind, mimeType,
  1440.       codec) {
  1441.     if (!mimeType) {
  1442.       mimeType = await this.getTextMimetype_(uri);
  1443.     }
  1445.     /** @type {shaka.extern.Stream} */
  1446.     const stream = {
  1447.       id: this.nextExternalStreamId_++,
  1448.       originalId: null,
  1449.       groupId: null,
  1450.       createSegmentIndex: () => Promise.resolve(),
  1451.       segmentIndex: shaka.media.SegmentIndex.forSingleSegment(
  1452.           /* startTime= */ 0,
  1453.           /* duration= */ manifest.presentationTimeline.getDuration(),
  1454.           /* uris= */ [uri]),
  1455.       mimeType: mimeType || '',
  1456.       codecs: codec || '',
  1457.       kind: kind,
  1458.       encrypted: false,
  1459.       drmInfos: [],
  1460.       keyIds: new Set(),
  1461.       language: language,
  1462.       originalLanguage: language,
  1463.       label: null,
  1464.       type: shaka.util.ManifestParserUtils.ContentType.TEXT,
  1465.       primary: false,
  1466.       trickModeVideo: null,
  1467.       emsgSchemeIdUris: null,
  1468.       roles: [],
  1469.       forced: false,
  1470.       channelsCount: null,
  1471.       audioSamplingRate: null,
  1472.       spatialAudio: false,
  1473.       closedCaptions: null,
  1474.       accessibilityPurpose: null,
  1475.       external: true,
  1476.       fastSwitching: false,
  1477.       fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
  1478.           mimeType || '', codec || '')]),
  1479.       isAudioMuxedInVideo: false,
  1480.     };
  1482.     const fullMimeType = shaka.util.MimeUtils.getFullType(
  1483.         stream.mimeType, stream.codecs);
  1484.     const supported = shaka.text.TextEngine.isTypeSupported(fullMimeType);
  1485.     if (!supported) {
  1486.       throw new shaka.util.Error(
  1487.           shaka.util.Error.Severity.CRITICAL,
  1488.           shaka.util.Error.Category.TEXT,
  1489.           shaka.util.Error.Code.MISSING_TEXT_PLUGIN,
  1490.           mimeType);
  1491.     }
  1493.     return stream;
  1494.   }
  1496.   /**
  1497.    * @param {string} uri
  1498.    * @return {!Promise<string>}
  1499.    * @private
  1500.    */
  1501.   async getTextMimetype_(uri) {
  1502.     let mimeType;
  1503.     try {
  1504.       goog.asserts.assert(
  1505.           this.networkingEngine_, 'Need networking engine.');
  1506.       mimeType = await shaka.net.NetworkingUtils.getMimeType(uri,
  1507.           this.networkingEngine_,
  1508.           this.config_.streaming.retryParameters);
  1509.     } catch (error) {}
  1511.     if (mimeType) {
  1512.       return mimeType;
  1513.     }
  1515.     shaka.log.error(
  1516.         'The mimeType has not been provided and it could not be deduced ' +
  1517.         'from its uri.');
  1518.     throw new shaka.util.Error(
  1519.         shaka.util.Error.Severity.RECOVERABLE,
  1520.         shaka.util.Error.Category.TEXT,
  1521.         shaka.util.Error.Code.TEXT_COULD_NOT_GUESS_MIME_TYPE,
  1522.         uri);
  1523.   }
  1525.   /**
  1526.    * @param {string} uri
  1527.    * @param {!shaka.net.NetworkingEngine} netEngine
  1528.    * @param {shaka.extern.RetryParameters} retryParams
  1529.    * @return {!Promise<BufferSource>}
  1530.    * @private
  1531.    */
  1532.   async getTextData_(uri, netEngine, retryParams) {
  1533.     const type = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  1535.     const request = shaka.net.NetworkingEngine.makeRequest([uri], retryParams);
  1536.     request.method = 'GET';
  1538.     const response = await netEngine.request(type, request).promise;
  1540.     return response.data;
  1541.   }
  1543.   /**
  1544.    * This method is public so that it can be override in testing.
  1545.    *
  1546.    * @param {shaka.extern.Manifest} manifest
  1547.    * @param {function(shaka.util.Error)} onError
  1548.    * @param {shaka.extern.PlayerConfiguration} config
  1549.    * @param {boolean} usePersistentLicense
  1550.    * @return {!Promise<!shaka.drm.DrmEngine>}
  1551.    */
  1552.   async createDrmEngine(manifest, onError, config, usePersistentLicense) {
  1553.     goog.asserts.assert(
  1554.         this.networkingEngine_,
  1555.         'Cannot call |createDrmEngine| after |destroy|');
  1557.     /** @type {!shaka.drm.DrmEngine} */
  1558.     const drmEngine = new shaka.drm.DrmEngine({
  1559.       netEngine: this.networkingEngine_,
  1560.       onError: onError,
  1561.       onKeyStatus: () => {},
  1562.       onExpirationUpdated: () => {},
  1563.       onEvent: () => {},
  1564.     });
  1566.     drmEngine.configure(config.drm);
  1567.     await drmEngine.initForStorage(manifest.variants, usePersistentLicense);
  1568.     await drmEngine.createOrLoad();
  1570.     return drmEngine;
  1571.   }
  1573.   /**
  1574.    * Converts manifest Streams to database Streams.
  1575.    *
  1576.    * @param {!shaka.offline.DownloadManager} downloader
  1577.    * @param {shaka.offline.StreamBandwidthEstimator} estimator
  1578.    * @param {!shaka.drm.DrmEngine} drmEngine
  1579.    * @param {shaka.extern.Manifest} manifest
  1580.    * @param {shaka.extern.PlayerConfiguration} config
  1581.    * @return {{
  1582.    *   streams: !Array<shaka.extern.StreamDB>,
  1583.    *   toDownload: !Array<!shaka.offline.DownloadInfo>
  1584.    * }}
  1585.    * @private
  1586.    */
  1587.   createStreams_(downloader, estimator, drmEngine, manifest, config) {
  1588.     // Download infos are stored based on their refId, to deduplicate them.
  1589.     /** @type {!Map<string, !shaka.offline.DownloadInfo>} */
  1590.     const toDownload = new Map();
  1592.     // Find the streams we want to download and create a stream db instance
  1593.     // for each of them.
  1594.     const streamSet =
  1595.         shaka.offline.Storage.getAllStreamsFromManifest_(manifest);
  1596.     const streamDBs = new Map();
  1598.     for (const stream of streamSet) {
  1599.       const streamDB = this.createStream_(
  1600.           downloader, estimator, manifest, stream, config, toDownload);
  1601.       streamDBs.set(stream.id, streamDB);
  1602.     }
  1604.     // Connect streams and variants together.
  1605.     for (const variant of manifest.variants) {
  1606.       if (variant.audio) {
  1607.         streamDBs.get(variant.audio.id).variantIds.push(variant.id);
  1608.       }
  1609.       if (variant.video) {
  1610.         streamDBs.get(variant.video.id).variantIds.push(variant.id);
  1611.       }
  1612.     }
  1614.     return {
  1615.       streams: Array.from(streamDBs.values()),
  1616.       toDownload: Array.from(toDownload.values()),
  1617.     };
  1618.   }
  1620.   /**
  1621.    * Converts a manifest stream to a database stream.  This will search the
  1622.    * segment index and add all the segments to the download infos.
  1623.    *
  1624.    * @param {!shaka.offline.DownloadManager} downloader
  1625.    * @param {shaka.offline.StreamBandwidthEstimator} estimator
  1626.    * @param {shaka.extern.Manifest} manifest
  1627.    * @param {shaka.extern.Stream} stream
  1628.    * @param {shaka.extern.PlayerConfiguration} config
  1629.    * @param {!Map<string, !shaka.offline.DownloadInfo>} toDownload
  1630.    * @return {shaka.extern.StreamDB}
  1631.    * @private
  1632.    */
  1633.   createStream_(downloader, estimator, manifest, stream, config, toDownload) {
  1634.     /** @type {shaka.extern.StreamDB} */
  1635.     const streamDb = {
  1636.       id: stream.id,
  1637.       originalId: stream.originalId,
  1638.       groupId: stream.groupId,
  1639.       primary: stream.primary,
  1640.       type: stream.type,
  1641.       mimeType: stream.mimeType,
  1642.       codecs: stream.codecs,
  1643.       frameRate: stream.frameRate,
  1644.       pixelAspectRatio: stream.pixelAspectRatio,
  1645.       hdr: stream.hdr,
  1646.       colorGamut: stream.colorGamut,
  1647.       videoLayout: stream.videoLayout,
  1648.       kind: stream.kind,
  1649.       language: stream.language,
  1650.       originalLanguage: stream.originalLanguage,
  1651.       label: stream.label,
  1652.       width: stream.width || null,
  1653.       height: stream.height || null,
  1654.       encrypted: stream.encrypted,
  1655.       keyIds: stream.keyIds,
  1656.       segments: [],
  1657.       variantIds: [],
  1658.       roles: stream.roles,
  1659.       forced: stream.forced,
  1660.       channelsCount: stream.channelsCount,
  1661.       audioSamplingRate: stream.audioSamplingRate,
  1662.       spatialAudio: stream.spatialAudio,
  1663.       closedCaptions: stream.closedCaptions,
  1664.       tilesLayout: stream.tilesLayout,
  1665.       mssPrivateData: stream.mssPrivateData,
  1666.       external: stream.external,
  1667.       fastSwitching: stream.fastSwitching,
  1668.       isAudioMuxedInVideo: stream.isAudioMuxedInVideo,
  1669.     };
  1671.     const startTime =
  1672.         manifest.presentationTimeline.getSegmentAvailabilityStart();
  1674.     const numberOfParallelDownloads = config.offline.numberOfParallelDownloads;
  1675.     let groupId = numberOfParallelDownloads === 0 ? stream.id : 0;
  1677.     shaka.offline.Storage.forEachSegment_(stream, startTime, (segment, pos) => {
  1678.       const pendingSegmentRefId =
  1679.           shaka.offline.DownloadInfo.idForSegmentRef(segment);
  1680.       let pendingInitSegmentRefId = undefined;
  1682.       // Set up the download for the segment, which will be downloaded later,
  1683.       // perhaps in a service worker.
  1684.       if (!toDownload.has(pendingSegmentRefId)) {
  1685.         const estimateId = downloader.addDownloadEstimate(
  1686.             estimator.getSegmentEstimate(stream.id, segment));
  1687.         const segmentDownload = new shaka.offline.DownloadInfo(
  1688.             segment,
  1689.             estimateId,
  1690.             groupId,
  1691.             /* isInitSegment= */ false,
  1692.             pos);
  1693.         toDownload.set(pendingSegmentRefId, segmentDownload);
  1694.       }
  1696.       // Set up the download for the init segment, similarly, if there is one.
  1697.       if (segment.initSegmentReference) {
  1698.         pendingInitSegmentRefId = shaka.offline.DownloadInfo.idForSegmentRef(
  1699.             segment.initSegmentReference);
  1700.         if (!toDownload.has(pendingInitSegmentRefId)) {
  1701.           const estimateId = downloader.addDownloadEstimate(
  1702.               estimator.getInitSegmentEstimate(stream.id));
  1703.           const initDownload = new shaka.offline.DownloadInfo(
  1704.               segment.initSegmentReference,
  1705.               estimateId,
  1706.               groupId,
  1707.               /* isInitSegment= */ true,
  1708.               pos);
  1709.           toDownload.set(pendingInitSegmentRefId, initDownload);
  1710.         }
  1711.       }
  1713.       /** @type {!shaka.extern.SegmentDB} */
  1714.       const segmentDB = {
  1715.         pendingInitSegmentRefId,
  1716.         initSegmentKey: pendingInitSegmentRefId ? 0 : null,
  1717.         startTime: segment.startTime,
  1718.         endTime: segment.endTime,
  1719.         appendWindowStart: segment.appendWindowStart,
  1720.         appendWindowEnd: segment.appendWindowEnd,
  1721.         timestampOffset: segment.timestampOffset,
  1722.         tilesLayout: segment.tilesLayout,
  1723.         pendingSegmentRefId,
  1724.         dataKey: 0,
  1725.         mimeType: segment.mimeType,
  1726.         codecs: segment.codecs,
  1727.         thumbnailSprite: segment.thumbnailSprite,
  1728.       };
  1729.       streamDb.segments.push(segmentDB);
  1730.       if (numberOfParallelDownloads !== 0) {
  1731.         groupId = (groupId + 1) % numberOfParallelDownloads;
  1732.       }
  1733.     });
  1735.     return streamDb;
  1736.   }
  1738.   /**
  1739.    * @param {shaka.extern.Stream} stream
  1740.    * @param {number} startTime
  1741.    * @param {function(!shaka.media.SegmentReference, number)} callback
  1742.    * @private
  1743.    */
  1744.   static forEachSegment_(stream, startTime, callback) {
  1745.     /** @type {?number} */
  1746.     let i = stream.segmentIndex.find(startTime);
  1748.     if (i == null) {
  1749.       return;
  1750.     }
  1752.     /** @type {?shaka.media.SegmentReference} */
  1753.     let ref = stream.segmentIndex.get(i);
  1754.     while (ref) {
  1755.       callback(ref, i);
  1756.       ref = stream.segmentIndex.get(++i);
  1757.     }
  1758.   }
  1760.   /**
  1761.    * Throws an error if the object is destroyed.
  1762.    * @private
  1763.    */
  1764.   ensureNotDestroyed_() {
  1765.     if (this.destroyer_.destroyed()) {
  1766.       throw new shaka.util.Error(
  1767.           shaka.util.Error.Severity.CRITICAL,
  1768.           shaka.util.Error.Category.STORAGE,
  1769.           shaka.util.Error.Code.OPERATION_ABORTED);
  1770.     }
  1771.   }
  1773.   /**
  1774.    * Used by functions that need storage support to ensure that the current
  1775.    * platform has storage support before continuing. This should only be
  1776.    * needed to be used at the start of public methods.
  1777.    *
  1778.    * @private
  1779.    */
  1780.   requireSupport_() {
  1781.     if (!shaka.offline.Storage.support()) {
  1782.       throw new shaka.util.Error(
  1783.           shaka.util.Error.Severity.CRITICAL,
  1784.           shaka.util.Error.Category.STORAGE,
  1785.           shaka.util.Error.Code.STORAGE_NOT_SUPPORTED);
  1786.     }
  1787.   }
  1789.   /**
  1790.    * Perform an action. Track the action's progress so that when we destroy
  1791.    * we will wait until all the actions have completed before allowing destroy
  1792.    * to resolve.
  1793.    *
  1794.    * @param {!Promise<T>} action
  1795.    * @return {!Promise<T>}
  1796.    * @template T
  1797.    * @private
  1798.    */
  1799.   async startOperation_(action) {
  1800.     this.openOperations_.push(action);
  1802.     try {
  1803.       // Await |action| so we can use the finally statement to remove |action|
  1804.       // from |openOperations_| when we still have a reference to |action|.
  1805.       return await action;
  1806.     } finally {
  1807.       shaka.util.ArrayUtils.remove(this.openOperations_, action);
  1808.     }
  1809.   }
  1811.   /**
  1812.    * The equivalent of startOperation_, but for abortable operations.
  1813.    *
  1814.    * @param {!shaka.extern.IAbortableOperation<T>} action
  1815.    * @return {!shaka.extern.IAbortableOperation<T>}
  1816.    * @template T
  1817.    * @private
  1818.    */
  1819.   startAbortableOperation_(action) {
  1820.     const promise = action.promise;
  1821.     this.openOperations_.push(promise);
  1823.     // Remove the open operation once the action has completed. So that we
  1824.     // can still return the AbortableOperation, this is done using a |finally|
  1825.     // block, rather than awaiting the result.
  1826.     return action.finally(() => {
  1827.       shaka.util.ArrayUtils.remove(this.openOperations_, promise);
  1828.     });
  1829.   }
  1831.   /**
  1832.    * @param {shaka.extern.ManifestDB} manifest
  1833.    * @return {!Array<number>}
  1834.    * @private
  1835.    */
  1836.   static getAllSegmentIds_(manifest) {
  1837.     /** @type {!Set<number>} */
  1838.     const ids = new Set();
  1840.     // Get every segment for every stream in the manifest.
  1841.     for (const stream of manifest.streams) {
  1842.       for (const segment of stream.segments) {
  1843.         if (segment.initSegmentKey != null) {
  1844.           ids.add(segment.initSegmentKey);
  1845.         }
  1847.         ids.add(segment.dataKey);
  1848.       }
  1849.     }
  1851.     return Array.from(ids);
  1852.   }
  1854.   /**
  1855.    * Delete the on-disk storage and all the content it contains. This should not
  1856.    * be done in normal circumstances. Only do it when storage is rendered
  1857.    * unusable, such as by a version mismatch. No business logic will be run, and
  1858.    * licenses will not be released.
  1859.    *
  1860.    * @return {!Promise}
  1861.    * @export
  1862.    */
  1863.   static async deleteAll() {
  1864.     /** @type {!shaka.offline.StorageMuxer} */
  1865.     const muxer = new shaka.offline.StorageMuxer();
  1866.     try {
  1867.       // Wipe all content from all storage mechanisms.
  1868.       await muxer.erase();
  1869.     } finally {
  1870.       // Destroy the muxer, whether or not erase() succeeded.
  1871.       await muxer.destroy();
  1872.     }
  1873.   }
  1875.   /**
  1876.    * @param {!shaka.net.NetworkingEngine} net
  1877.    * @param {!shaka.extern.DrmConfiguration} drmConfig
  1878.    * @param {!shaka.offline.StorageMuxer} muxer
  1879.    * @param {shaka.extern.ManifestDB} manifestDb
  1880.    * @return {!Promise}
  1881.    * @private
  1882.    */
  1883.   static async deleteLicenseFor_(net, drmConfig, muxer, manifestDb) {
  1884.     if (!manifestDb.drmInfo) {
  1885.       return;
  1886.     }
  1888.     const sessionIdCell = muxer.getEmeSessionCell();
  1890.     /** @type {!Array<shaka.extern.EmeSessionDB>} */
  1891.     const sessions = manifestDb.sessionIds.map((sessionId) => {
  1892.       return {
  1893.         sessionId: sessionId,
  1894.         keySystem: manifestDb.drmInfo.keySystem,
  1895.         licenseUri: manifestDb.drmInfo.licenseServerUri,
  1896.         serverCertificate: manifestDb.drmInfo.serverCertificate,
  1897.         audioCapabilities: shaka.offline.Storage.getCapabilities_(
  1898.             manifestDb,
  1899.             /* isVideo= */ false),
  1900.         videoCapabilities: shaka.offline.Storage.getCapabilities_(
  1901.             manifestDb,
  1902.             /* isVideo= */ true),
  1903.       };
  1904.     });
  1905.     // Try to delete the sessions; any sessions that weren't deleted get stored
  1906.     // in the database so we can try to remove them again later.  This allows us
  1907.     // to still delete the stored content but not "forget" about these sessions.
  1908.     // Later, we can remove the sessions to free up space.
  1909.     const deleter = new shaka.offline.SessionDeleter();
  1910.     const deletedSessionIds = await deleter.delete(drmConfig, net, sessions);
  1911.     await sessionIdCell.remove(deletedSessionIds);
  1912.     await sessionIdCell.add(sessions.filter(
  1913.         (session) => !deletedSessionIds.includes(session.sessionId)));
  1914.   }
  1916.   /**
  1917.    * Get the set of all streams in |manifest|.
  1918.    *
  1919.    * @param {shaka.extern.Manifest} manifest
  1920.    * @return {!Set<shaka.extern.Stream>}
  1921.    * @private
  1922.    */
  1923.   static getAllStreamsFromManifest_(manifest) {
  1924.     /** @type {!Set<shaka.extern.Stream>} */
  1925.     const set = new Set();
  1927.     for (const variant of manifest.variants) {
  1928.       if (variant.audio) {
  1929.         set.add(variant.audio);
  1930.       }
  1931.       if (variant.video) {
  1932.         set.add(variant.video);
  1933.       }
  1934.     }
  1936.     for (const text of manifest.textStreams) {
  1937.       set.add(text);
  1938.     }
  1940.     for (const image of manifest.imageStreams) {
  1941.       set.add(image);
  1942.     }
  1944.     return set;
  1945.   }
  1947.   /**
  1948.    * Go over a manifest and issue warnings for any suspicious properties.
  1949.    *
  1950.    * @param {shaka.extern.Manifest} manifest
  1951.    * @private
  1952.    */
  1953.   static validateManifest_(manifest) {
  1954.     const videos = new Set(manifest.variants.map((v) => v.video));
  1955.     const audios = new Set(manifest.variants.map((v) => v.audio));
  1956.     const texts = manifest.textStreams;
  1958.     if (videos.size > 1) {
  1959.       shaka.log.warning('Multiple video tracks selected to be stored');
  1960.     }
  1962.     for (const audio1 of audios) {
  1963.       for (const audio2 of audios) {
  1964.         if (audio1 != audio2 && audio1.language == audio2.language) {
  1965.           shaka.log.warning(
  1966.               'Similar audio tracks were selected to be stored',
  1967.               audio1.id,
  1968.               audio2.id);
  1969.         }
  1970.       }
  1971.     }
  1973.     for (const text1 of texts) {
  1974.       for (const text2 of texts) {
  1975.         if (text1 != text2 && text1.language == text2.language) {
  1976.           shaka.log.warning(
  1977.               'Similar text tracks were selected to be stored',
  1978.               text1.id,
  1979.               text2.id);
  1980.         }
  1981.       }
  1982.     }
  1983.   }
  1984. };
  1986. shaka.offline.Storage.defaultSystemIds_ = new Map()
  1987.     .set('org.w3.clearkey', '1077efecc0b24d02ace33c1e52e2fb4b')
  1988.     .set('com.widevine.alpha', 'edef8ba979d64acea3c827dcd51d21ed')
  1989.     .set('com.microsoft.playready', '9a04f07998404286ab92e65be0885f95')
  1990.     .set('com.microsoft.playready.recommendation',
  1991.         '9a04f07998404286ab92e65be0885f95')
  1992.     .set('com.microsoft.playready.software',
  1993.         '9a04f07998404286ab92e65be0885f95')
  1994.     .set('com.microsoft.playready.hardware',
  1995.         '9a04f07998404286ab92e65be0885f95')
  1996.     .set('com.huawei.wiseplay', '3d5e6d359b9a41e8b843dd3c6e72c42c');
  1998. shaka.Player.registerSupportPlugin('offline', shaka.offline.Storage.support);