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 segmentData =
  548.               ref.getSegmentData(/* allowDeleteOnSingleUse= */ false);
  549.           if (ref.aesKey && !segmentData) {
  550.             data = await shaka.media.SegmentUtils.aesDecrypt(
  551.                 data, ref.aesKey, download.refPosition);
  552.           }
  553.           const id = shaka.offline.DownloadInfo.idForSegmentRef(ref);
  554.           // Store the data.
  555.           const dataKeys = await storage.addSegments([{data}]);
  556.           ensureNotAbortedOrDestroyed();
  558.           // Store the necessary update to the manifest, to be processed later.
  559.           pendingManifestUpdates[id] = dataKeys[0];
  560.           pendingDataSize += data.byteLength;
  561.         };
  563.         const ref = /** @type {!shaka.media.SegmentReference} */ (
  564.           download.ref);
  565.         const segmentData =
  566.             ref.getSegmentData(/* allowDeleteOnSingleUse= */ false);
  567.         if (segmentData) {
  568.           downloader.queueData(download.groupId,
  569.               segmentData, estimateId, isInitSegment, onDownloaded);
  570.         } else {
  571.           downloader.queue(download.groupId,
  572.               request, estimateId, isInitSegment, onDownloaded);
  573.         }
  574.       }
  575.       await downloader.waitToFinish();
  576.       ensureNotAbortedOrDestroyed();
  578.       if (updateDRM && !downloader.isAborted()) {
  579.         // Re-store the manifest, to attach session IDs.
  580.         // These were (maybe) discovered inside the downloader; we can only add
  581.         // them now, at the end, since the manifestDB is in flux during the
  582.         // process of downloading and storing, and assignSegmentsToManifest
  583.         // does not know about the DRM engine.
  584.         this.setManifestDrmFields_(
  585.             manifest, manifestDB, drmEngine, usePersistentLicense);
  586.         await storage.updateManifest(manifestId, manifestDB);
  587.       }
  588.     };
  590.     const usingBgFetch = false; // TODO: Get.
  592.     try {
  593.       if (this.getManifestIsEncrypted_(manifest) && usingBgFetch &&
  594.           !this.getManifestIncludesInitData_(manifest)) {
  595.         // Background fetch can't make DRM sessions, so if we have to get the
  596.         // init data from the init segments, download those first before
  597.         // anything else.
  598.         await download(toDownload.filter((info) => info.isInitSegment), true);
  599.         ensureNotAbortedOrDestroyed();
  600.         toDownload = toDownload.filter((info) => !info.isInitSegment);
  602.         // Copy these and reset them now, before calling await.
  603.         const manifestUpdates = pendingManifestUpdates;
  604.         const dataSize = pendingDataSize;
  605.         pendingManifestUpdates = {};
  606.         pendingDataSize = 0;
  608.         await shaka.offline.Storage.assignSegmentsToManifest(
  609.             storage, manifestId, manifestDB, manifestUpdates, dataSize,
  610.             () => this.ensureNotDestroyed_());
  611.         ensureNotAbortedOrDestroyed();
  612.       }
  614.       if (!usingBgFetch) {
  615.         await download(toDownload, false);
  616.         ensureNotAbortedOrDestroyed();
  618.         // Copy these and reset them now, before calling await.
  619.         const manifestUpdates = pendingManifestUpdates;
  620.         const dataSize = pendingDataSize;
  621.         pendingManifestUpdates = {};
  622.         pendingDataSize = 0;
  624.         await shaka.offline.Storage.assignSegmentsToManifest(
  625.             storage, manifestId, manifestDB, manifestUpdates, dataSize,
  626.             () => ensureNotAbortedOrDestroyed());
  627.         ensureNotAbortedOrDestroyed();
  629.         goog.asserts.assert(
  630.             !manifestDB.isIncomplete, 'The manifest should be complete by now');
  631.       } else {
  632.         // TODO: Send the request to the service worker. Don't await the result.
  633.       }
  634.     } catch (error) {
  635.       const dataKeys = Object.values(pendingManifestUpdates);
  636.       // Remove these pending segments that are not yet linked to the manifest.
  637.       await storage.removeSegments(dataKeys, (key) => {});
  639.       throw error;
  640.     }
  641.   }
  643.   /**
  644.    * Removes all of the contents for a given manifest, statelessly.
  645.    *
  646.    * @param {number} manifestId
  647.    * @return {!Promise}
  648.    */
  649.   static async cleanStoredManifest(manifestId) {
  650.     const muxer = new shaka.offline.StorageMuxer();
  651.     await muxer.init();
  652.     const activeHandle = await muxer.getActive();
  653.     const uri = shaka.offline.OfflineUri.manifest(
  654.         activeHandle.path.mechanism,
  655.         activeHandle.path.cell,
  656.         manifestId);
  657.     await muxer.destroy();
  658.     const storage = new shaka.offline.Storage();
  659.     await storage.remove(uri.toString());
  660.   }
  662.   /**
  663.    * Updates the given manifest, assigns database keys to segments, then stores
  664.    * the updated manifest.
  665.    *
  666.    * It is up to the caller to ensure that this method is not called
  667.    * concurrently on the same manifest.
  668.    *
  669.    * @param {shaka.extern.StorageCell} storage
  670.    * @param {number} manifestId
  671.    * @param {!shaka.extern.ManifestDB} manifestDB
  672.    * @param {!Object<string, number>} manifestUpdates
  673.    * @param {number} dataSizeUpdate
  674.    * @param {function()} throwIfAbortedFn  A function that should throw if the
  675.    *   download has been aborted.
  676.    * @return {!Promise}
  677.    */
  678.   static async assignSegmentsToManifest(
  679.       storage, manifestId, manifestDB, manifestUpdates, dataSizeUpdate,
  680.       throwIfAbortedFn) {
  681.     let manifestUpdated = false;
  683.     try {
  684.       // Assign the stored data to the manifest.
  685.       let complete = true;
  686.       for (const stream of manifestDB.streams) {
  687.         for (const segment of stream.segments) {
  688.           let dataKey = segment.pendingSegmentRefId ?
  689.               manifestUpdates[segment.pendingSegmentRefId] : null;
  690.           if (dataKey != null) {
  691.             segment.dataKey = dataKey;
  692.             // Now that the segment has been associated with the appropriate
  693.             // dataKey, the pendingSegmentRefId is no longer necessary.
  694.             segment.pendingSegmentRefId = undefined;
  695.           }
  697.           dataKey = segment.pendingInitSegmentRefId ?
  698.               manifestUpdates[segment.pendingInitSegmentRefId] : null;
  699.           if (dataKey != null) {
  700.             segment.initSegmentKey = dataKey;
  701.             // Now that the init segment has been associated with the
  702.             // appropriate initSegmentKey, the pendingInitSegmentRefId is no
  703.             // longer necessary.
  704.             segment.pendingInitSegmentRefId = undefined;
  705.           }
  707.           if (segment.pendingSegmentRefId) {
  708.             complete = false;
  709.           }
  710.           if (segment.pendingInitSegmentRefId) {
  711.             complete = false;
  712.           }
  713.         }
  714.       }
  716.       // Update the size of the manifest.
  717.       manifestDB.size += dataSizeUpdate;
  719.       // Mark the manifest as complete, if all segments are downloaded.
  720.       if (complete) {
  721.         manifestDB.isIncomplete = false;
  722.       }
  724.       // Update the manifest.
  725.       await storage.updateManifest(manifestId, manifestDB);
  726.       manifestUpdated = true;
  727.       throwIfAbortedFn();
  728.     } catch (e) {
  729.       await shaka.offline.Storage.cleanStoredManifest(manifestId);
  731.       if (!manifestUpdated) {
  732.         const dataKeys = Object.values(manifestUpdates);
  733.         // The cleanStoredManifest method will not "see" any segments that have
  734.         // been downloaded but not assigned to the manifest yet. So un-store
  735.         // them separately.
  736.         await storage.removeSegments(dataKeys, (key) => {});
  737.       }
  739.       throw e;
  740.     }
  741.   }
  743.   /**
  744.    * Filter |manifest| such that it will only contain the variants and text
  745.    * streams that we want to store and can actually play.
  746.    *
  747.    * @param {shaka.extern.Manifest} manifest
  748.    * @param {!shaka.drm.DrmEngine} drmEngine
  749.    * @param {shaka.extern.PlayerConfiguration} config
  750.    * @param {boolean} usePersistentLicense
  751.    * @return {!Promise}
  752.    * @private
  753.    */
  754.   async filterManifest_(manifest, drmEngine, config, usePersistentLicense) {
  755.     // Filter the manifest based on the restrictions given in the player
  756.     // configuration.
  757.     const maxHwRes = {width: Infinity, height: Infinity};
  758.     shaka.util.StreamUtils.filterByRestrictions(
  759.         manifest, config.restrictions, maxHwRes);
  761.     // Filter the manifest based on what we know MediaCapabilities will be able
  762.     // to play later (no point storing something we can't play).
  763.     await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
  764.         drmEngine, manifest, usePersistentLicense,
  765.         config.drm.preferredKeySystems, config.drm.keySystemsMapping);
  767.     // Gather all tracks.
  768.     const allTracks = [];
  770.     // Choose the codec that has the lowest average bandwidth.
  771.     const preferredDecodingAttributes = config.preferredDecodingAttributes;
  772.     const preferredVideoCodecs = config.preferredVideoCodecs;
  773.     const preferredAudioCodecs = config.preferredAudioCodecs;
  774.     const preferredTextFormats = config.preferredTextFormats;
  776.     shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
  777.         manifest, preferredVideoCodecs, preferredAudioCodecs,
  778.         preferredDecodingAttributes, preferredTextFormats);
  780.     for (const variant of manifest.variants) {
  781.       goog.asserts.assert(
  782.           shaka.util.StreamUtils.isPlayable(variant),
  783.           'We should have already filtered by "is playable"');
  785.       allTracks.push(shaka.util.StreamUtils.variantToTrack(variant));
  786.     }
  788.     for (const text of manifest.textStreams) {
  789.       allTracks.push(shaka.util.StreamUtils.textStreamToTrack(text));
  790.     }
  792.     for (const image of manifest.imageStreams) {
  793.       allTracks.push(shaka.util.StreamUtils.imageStreamToTrack(image));
  794.     }
  796.     // Let the application choose which tracks to store.
  797.     const chosenTracks =
  798.         await config.offline.trackSelectionCallback(allTracks);
  799.     const duration = manifest.presentationTimeline.getDuration();
  800.     let sizeEstimate = 0;
  801.     for (const track of chosenTracks) {
  802.       const trackSize = track.bandwidth * duration / 8;
  803.       sizeEstimate += trackSize;
  804.     }
  805.     try {
  806.       const allowedDownload =
  807.           await config.offline.downloadSizeCallback(sizeEstimate);
  808.       if (!allowedDownload) {
  809.         throw new shaka.util.Error(
  810.             shaka.util.Error.Severity.CRITICAL,
  811.             shaka.util.Error.Category.STORAGE,
  812.             shaka.util.Error.Code.STORAGE_LIMIT_REACHED);
  813.       }
  814.     } catch (e) {
  815.       // It is necessary to be able to catch the STORAGE_LIMIT_REACHED error
  816.       if (e instanceof shaka.util.Error) {
  817.         throw e;
  818.       }
  819.       shaka.log.warning(
  820.           'downloadSizeCallback has produced an unexpected error', e);
  821.       throw new shaka.util.Error(
  822.           shaka.util.Error.Severity.CRITICAL,
  823.           shaka.util.Error.Category.STORAGE,
  824.           shaka.util.Error.Code.DOWNLOAD_SIZE_CALLBACK_ERROR);
  825.     }
  827.     /** @type {!Set<number>} */
  828.     const variantIds = new Set();
  829.     /** @type {!Set<number>} */
  830.     const textIds = new Set();
  831.     /** @type {!Set<number>} */
  832.     const imageIds = new Set();
  834.     // Collect the IDs of the chosen tracks.
  835.     for (const track of chosenTracks) {
  836.       if (track.type == 'variant') {
  837.         variantIds.add(track.id);
  838.       }
  839.       if (track.type == 'text') {
  840.         textIds.add(track.id);
  841.       }
  842.       if (track.type == 'image') {
  843.         imageIds.add(track.id);
  844.       }
  845.     }
  847.     // Filter the manifest to keep only what the app chose.
  848.     manifest.variants =
  849.         manifest.variants.filter((variant) => variantIds.has(variant.id));
  850.     manifest.textStreams =
  851.         manifest.textStreams.filter((stream) => textIds.has(stream.id));
  852.     manifest.imageStreams =
  853.         manifest.imageStreams.filter((stream) => imageIds.has(stream.id));
  855.     // Check the post-filtered manifest for characteristics that may indicate
  856.     // issues with how the app selected tracks.
  857.     shaka.offline.Storage.validateManifest_(manifest);
  858.   }
  860.   /**
  861.    * Create a download manager and download the manifest.
  862.    * This also sets up download infos for each segment to be downloaded.
  863.    *
  864.    * @param {!shaka.drm.DrmEngine} drmEngine
  865.    * @param {shaka.extern.Manifest} manifest
  866.    * @param {string} uri
  867.    * @param {!Object} metadata
  868.    * @param {shaka.extern.PlayerConfiguration} config
  869.    * @param {!shaka.offline.DownloadManager} downloader
  870.    * @param {boolean} usePersistentLicense
  871.    * @return {{
  872.    *   manifestDB: shaka.extern.ManifestDB,
  873.    *   toDownload: !Array<!shaka.offline.DownloadInfo>
  874.    * }}
  875.    * @private
  876.    */
  877.   makeManifestDB_(drmEngine, manifest, uri, metadata, config, downloader,
  878.       usePersistentLicense) {
  879.     const pendingContent = shaka.offline.StoredContentUtils.fromManifest(
  880.         uri, manifest, /* size= */ 0, metadata);
  881.     // In https://github.com/shaka-project/shaka-player/issues/2652, we found
  882.     // that this callback would be removed by the compiler if we reference the
  883.     // config in the onProgress closure below.  Reading it into a local
  884.     // variable first seems to work around this apparent compiler bug.
  885.     const progressCallback = config.offline.progressCallback;
  887.     const onProgress = (progress, size) => {
  888.       // Update the size of the stored content before issuing a progress
  889.       // update.
  890.       pendingContent.size = size;
  891.       progressCallback(pendingContent, progress);
  892.     };
  893.     const onInitData = (initData, systemId) => {
  894.       if (needsInitData && usePersistentLicense &&
  895.           currentSystemId == systemId) {
  896.         drmEngine.newInitData('cenc', initData);
  897.       }
  898.     };
  899.     downloader.setCallbacks(onProgress, onInitData);
  901.     const needsInitData = this.getManifestIsEncrypted_(manifest) &&
  902.                           !this.getManifestIncludesInitData_(manifest);
  904.     let currentSystemId = null;
  905.     if (needsInitData) {
  906.       const drmInfo = drmEngine.getDrmInfo();
  907.       currentSystemId =
  908.           shaka.offline.Storage.defaultSystemIds_.get(drmInfo.keySystem);
  909.     }
  911.     // Make the estimator, which is used to make the download registries.
  912.     const estimator = new shaka.offline.StreamBandwidthEstimator();
  913.     for (const stream of manifest.textStreams) {
  914.       estimator.addText(stream);
  915.     }
  916.     for (const stream of manifest.imageStreams) {
  917.       estimator.addImage(stream);
  918.     }
  919.     for (const variant of manifest.variants) {
  920.       estimator.addVariant(variant);
  921.     }
  922.     const {streams, toDownload} = this.createStreams_(
  923.         downloader, estimator, drmEngine, manifest, config);
  925.     const drmInfo = drmEngine.getDrmInfo();
  926.     if (drmInfo && usePersistentLicense) {
  927.       // Don't store init data, since we have stored sessions.
  928.       drmInfo.initData = [];
  929.     }
  931.     const manifestDB = {
  932.       creationTime: Date.now(),
  933.       originalManifestUri: uri,
  934.       duration: manifest.presentationTimeline.getDuration(),
  935.       size: 0,
  936.       expiration: drmEngine.getExpiration(),
  937.       streams,
  938.       sessionIds: usePersistentLicense ? drmEngine.getSessionIds() : [],
  939.       drmInfo,
  940.       appMetadata: metadata,
  941.       isIncomplete: true,
  942.       sequenceMode: manifest.sequenceMode,
  943.       type: manifest.type,
  944.     };
  946.     return {manifestDB, toDownload};
  947.   }
  949.   /**
  950.    * @param {shaka.extern.Manifest} manifest
  951.    * @return {boolean}
  952.    * @private
  953.    */
  954.   getManifestIsEncrypted_(manifest) {
  955.     return manifest.variants.some((variant) => {
  956.       const videoEncrypted = variant.video && variant.video.encrypted;
  957.       const audioEncrypted = variant.audio && variant.audio.encrypted;
  958.       return videoEncrypted || audioEncrypted;
  959.     });
  960.   }
  962.   /**
  963.    * @param {shaka.extern.Manifest} manifest
  964.    * @return {boolean}
  965.    * @private
  966.    */
  967.   getManifestIncludesInitData_(manifest) {
  968.     return manifest.variants.some((variant) => {
  969.       const videoDrmInfos = variant.video ? variant.video.drmInfos : [];
  970.       const audioDrmInfos = variant.audio ? variant.audio.drmInfos : [];
  971.       const drmInfos = videoDrmInfos.concat(audioDrmInfos);
  972.       return drmInfos.some((drmInfos) => {
  973.         return drmInfos.initData && drmInfos.initData.length;
  974.       });
  975.     });
  976.   }
  978.   /**
  979.    * @param {shaka.extern.Manifest} manifest
  980.    * @param {shaka.extern.ManifestDB} manifestDB
  981.    * @param {!shaka.drm.DrmEngine} drmEngine
  982.    * @param {boolean} usePersistentLicense
  983.    * @private
  984.    */
  985.   setManifestDrmFields_(manifest, manifestDB, drmEngine, usePersistentLicense) {
  986.     manifestDB.expiration = drmEngine.getExpiration();
  988.     const sessions = drmEngine.getSessionIds();
  989.     manifestDB.sessionIds = usePersistentLicense ? sessions : [];
  991.     if (this.getManifestIsEncrypted_(manifest) &&
  992.         usePersistentLicense && !sessions.length) {
  993.       throw new shaka.util.Error(
  994.           shaka.util.Error.Severity.CRITICAL,
  995.           shaka.util.Error.Category.STORAGE,
  996.           shaka.util.Error.Code.NO_INIT_DATA_FOR_OFFLINE);
  997.     }
  998.   }
  1000.   /**
  1001.    * Removes the given stored content.  This will also attempt to release the
  1002.    * licenses, if any.
  1003.    *
  1004.    * @param {string} contentUri
  1005.    * @return {!Promise}
  1006.    * @export
  1007.    */
  1008.   remove(contentUri) {
  1009.     return this.startOperation_(this.remove_(contentUri));
  1010.   }
  1012.   /**
  1013.    * See |shaka.offline.Storage.remove| for details.
  1014.    *
  1015.    * @param {string} contentUri
  1016.    * @return {!Promise}
  1017.    * @private
  1018.    */
  1019.   async remove_(contentUri) {
  1020.     this.requireSupport_();
  1022.     const nullableUri = shaka.offline.OfflineUri.parse(contentUri);
  1023.     if (nullableUri == null || !nullableUri.isManifest()) {
  1024.       throw new shaka.util.Error(
  1025.           shaka.util.Error.Severity.CRITICAL,
  1026.           shaka.util.Error.Category.STORAGE,
  1027.           shaka.util.Error.Code.MALFORMED_OFFLINE_URI,
  1028.           contentUri);
  1029.     }
  1031.     /** @type {!shaka.offline.OfflineUri} */
  1032.     const uri = nullableUri;
  1034.     /** @type {!shaka.offline.StorageMuxer} */
  1035.     const muxer = new shaka.offline.StorageMuxer();
  1037.     try {
  1038.       await muxer.init();
  1040.       const cell = await muxer.getCell(uri.mechanism(), uri.cell());
  1041.       const manifests = await cell.getManifests([uri.key()]);
  1042.       const manifest = manifests[0];
  1044.       await Promise.all([
  1045.         this.removeFromDRM_(uri, manifest, muxer),
  1046.         this.removeFromStorage_(cell, uri, manifest),
  1047.       ]);
  1048.     } finally {
  1049.       await muxer.destroy();
  1050.     }
  1051.   }
  1053.   /**
  1054.    * @param {shaka.extern.ManifestDB} manifestDb
  1055.    * @param {boolean} isVideo
  1056.    * @return {!Array<MediaKeySystemMediaCapability>}
  1057.    * @private
  1058.    */
  1059.   static getCapabilities_(manifestDb, isVideo) {
  1060.     const MimeUtils = shaka.util.MimeUtils;
  1062.     const ret = [];
  1063.     for (const stream of manifestDb.streams) {
  1064.       if (isVideo && stream.type == 'video') {
  1065.         ret.push({
  1066.           contentType: MimeUtils.getFullType(stream.mimeType, stream.codecs),
  1067.           robustness: manifestDb.drmInfo.videoRobustness,
  1068.         });
  1069.       } else if (!isVideo && stream.type == 'audio') {
  1070.         ret.push({
  1071.           contentType: MimeUtils.getFullType(stream.mimeType, stream.codecs),
  1072.           robustness: manifestDb.drmInfo.audioRobustness,
  1073.         });
  1074.       }
  1075.     }
  1076.     return ret;
  1077.   }
  1079.   /**
  1080.    * @param {!shaka.offline.OfflineUri} uri
  1081.    * @param {shaka.extern.ManifestDB} manifestDb
  1082.    * @param {!shaka.offline.StorageMuxer} muxer
  1083.    * @return {!Promise}
  1084.    * @private
  1085.    */
  1086.   async removeFromDRM_(uri, manifestDb, muxer) {
  1087.     goog.asserts.assert(this.networkingEngine_, 'Cannot be destroyed');
  1088.     await shaka.offline.Storage.deleteLicenseFor_(
  1089.         this.networkingEngine_, this.config_.drm, muxer, manifestDb);
  1090.   }
  1092.   /**
  1093.    * @param {shaka.extern.StorageCell} storage
  1094.    * @param {!shaka.offline.OfflineUri} uri
  1095.    * @param {shaka.extern.ManifestDB} manifest
  1096.    * @return {!Promise}
  1097.    * @private
  1098.    */
  1099.   removeFromStorage_(storage, uri, manifest) {
  1100.     /** @type {!Array<number>} */
  1101.     const segmentIds = shaka.offline.Storage.getAllSegmentIds_(manifest);
  1103.     // Count(segments) + Count(manifests)
  1104.     const toRemove = segmentIds.length + 1;
  1105.     let removed = 0;
  1107.     const pendingContent = shaka.offline.StoredContentUtils.fromManifestDB(
  1108.         uri, manifest);
  1110.     const onRemove = (key) => {
  1111.       removed += 1;
  1112.       this.config_.offline.progressCallback(pendingContent, removed / toRemove);
  1113.     };
  1115.     return Promise.all([
  1116.       storage.removeSegments(segmentIds, onRemove),
  1117.       storage.removeManifests([uri.key()], onRemove),
  1118.     ]);
  1119.   }
  1121.   /**
  1122.    * Removes any EME sessions that were not successfully removed before.  This
  1123.    * returns whether all the sessions were successfully removed.
  1124.    *
  1125.    * @return {!Promise<boolean>}
  1126.    * @export
  1127.    */
  1128.   removeEmeSessions() {
  1129.     return this.startOperation_(this.removeEmeSessions_());
  1130.   }
  1132.   /**
  1133.    * @return {!Promise<boolean>}
  1134.    * @private
  1135.    */
  1136.   async removeEmeSessions_() {
  1137.     this.requireSupport_();
  1139.     goog.asserts.assert(this.networkingEngine_, 'Cannot be destroyed');
  1140.     const net = this.networkingEngine_;
  1141.     const config = this.config_.drm;
  1143.     /** @type {!shaka.offline.StorageMuxer} */
  1144.     const muxer = new shaka.offline.StorageMuxer();
  1145.     /** @type {!shaka.offline.SessionDeleter} */
  1146.     const deleter = new shaka.offline.SessionDeleter();
  1148.     let hasRemaining = false;
  1150.     try {
  1151.       await muxer.init();
  1153.       /** @type {!Array<shaka.extern.EmeSessionStorageCell>} */
  1154.       const cells = [];
  1155.       muxer.forEachEmeSessionCell((c) => cells.push(c));
  1157.       // Run these sequentially to avoid creating too many DrmEngine instances
  1158.       // and having multiple CDMs alive at once.  Some embedded platforms may
  1159.       // not support that.
  1160.       for (const sessionIdCell of cells) {
  1161.         /* eslint-disable no-await-in-loop */
  1162.         const sessions = await sessionIdCell.getAll();
  1163.         const deletedSessionIds = await deleter.delete(config, net, sessions);
  1164.         await sessionIdCell.remove(deletedSessionIds);
  1166.         if (deletedSessionIds.length != sessions.length) {
  1167.           hasRemaining = true;
  1168.         }
  1169.         /* eslint-enable no-await-in-loop */
  1170.       }
  1171.     } finally {
  1172.       await muxer.destroy();
  1173.     }
  1175.     return !hasRemaining;
  1176.   }
  1178.   /**
  1179.    * Lists all the stored content available.
  1180.    *
  1181.    * @return {!Promise<!Array<shaka.extern.StoredContent>>}  A Promise to an
  1182.    *   array of structures representing all stored content.  The "offlineUri"
  1183.    *   member of the structure is the URI that should be given to Player.load()
  1184.    *   to play this piece of content offline.  The "appMetadata" member is the
  1185.    *   appMetadata argument you passed to store().
  1186.    * @export
  1187.    */
  1188.   list() {
  1189.     return this.startOperation_(this.list_());
  1190.   }
  1192.   /**
  1193.    * See |shaka.offline.Storage.list| for details.
  1194.    *
  1195.    * @return {!Promise<!Array<shaka.extern.StoredContent>>}
  1196.    * @private
  1197.    */
  1198.   async list_() {
  1199.     this.requireSupport_();
  1201.     /** @type {!Array<shaka.extern.StoredContent>} */
  1202.     const result = [];
  1204.     /** @type {!shaka.offline.StorageMuxer} */
  1205.     const muxer = new shaka.offline.StorageMuxer();
  1206.     try {
  1207.       await muxer.init();
  1209.       let p = Promise.resolve();
  1210.       muxer.forEachCell((path, cell) => {
  1211.         p = p.then(async () => {
  1212.           const manifests = await cell.getAllManifests();
  1214.           manifests.forEach((manifest, key) => {
  1215.             const uri = shaka.offline.OfflineUri.manifest(
  1216.                 path.mechanism,
  1217.                 path.cell,
  1218.                 key);
  1220.             const content = shaka.offline.StoredContentUtils.fromManifestDB(
  1221.                 uri,
  1222.                 manifest);
  1224.             result.push(content);
  1225.           });
  1226.         });
  1227.       });
  1229.       await p;
  1230.     } finally {
  1231.       await muxer.destroy();
  1232.     }
  1234.     return result;
  1235.   }
  1238.   /**
  1239.    * This method is public so that it can be overridden in testing.
  1240.    *
  1241.    * @param {string} uri
  1242.    * @param {shaka.extern.ManifestParser} parser
  1243.    * @param {shaka.extern.PlayerConfiguration} config
  1244.    * @return {!Promise<shaka.extern.Manifest>}
  1245.    */
  1246.   async parseManifest(uri, parser, config) {
  1247.     let error = null;
  1249.     const networkingEngine = this.networkingEngine_;
  1250.     goog.asserts.assert(networkingEngine, 'Should be initialized!');
  1252.     /** @type {shaka.extern.ManifestParser.PlayerInterface} */
  1253.     const playerInterface = {
  1254.       networkingEngine: networkingEngine,
  1256.       // Don't bother filtering now. We will do that later when we have all the
  1257.       // information we need to filter.
  1258.       filter: () => Promise.resolve(),
  1260.       // The responsibility for making mock text streams for closed captions is
  1261.       // handled inside shaka.offline.OfflineManifestParser, before playback.
  1262.       makeTextStreamsForClosedCaptions: (manifest) => {},
  1264.       onTimelineRegionAdded: () => {},
  1265.       onEvent: () => {},
  1267.       // Used to capture an error from the manifest parser. We will check the
  1268.       // error before returning.
  1269.       onError: (e) => {
  1270.         error = e;
  1271.       },
  1272.       isLowLatencyMode: () => false,
  1273.       updateDuration: () => {},
  1274.       newDrmInfo: (stream) => {},
  1275.       onManifestUpdated: () => {},
  1276.       getBandwidthEstimate: () => config.abr.defaultBandwidthEstimate,
  1277.       onMetadata: () => {},
  1278.       disableStream: (stream) => {},
  1279.       addFont: (name, url) => {},
  1280.     };
  1282.     parser.configure(config.manifest);
  1284.     // We may have been destroyed while we were waiting on |getParser| to
  1285.     // resolve.
  1286.     this.ensureNotDestroyed_();
  1288.     const manifest = await parser.start(uri, playerInterface);
  1290.     // We may have been destroyed while we were waiting on |start| to
  1291.     // resolve.
  1292.     this.ensureNotDestroyed_();
  1294.     // Get all the streams that are used in the manifest.
  1295.     const streams =
  1296.         shaka.offline.Storage.getAllStreamsFromManifest_(manifest);
  1298.     // Wait for each stream to create their segment indexes.
  1299.     await Promise.all(shaka.util.Iterables.map(streams, (stream) => {
  1300.       return stream.createSegmentIndex();
  1301.     }));
  1303.     // We may have been destroyed while we were waiting on
  1304.     // |createSegmentIndex| to resolve for each stream.
  1305.     this.ensureNotDestroyed_();
  1307.     // If we saw an error while parsing, surface the error.
  1308.     if (error) {
  1309.       throw error;
  1310.     }
  1312.     return manifest;
  1313.   }
  1315.   /**
  1316.    * @param {string} uri
  1317.    * @param {shaka.extern.Manifest} manifest
  1318.    * @return {!Promise<shaka.extern.Stream>}
  1319.    * @private
  1320.    */
  1321.   async createExternalImageStream_(uri, manifest) {
  1322.     const mimeType = await this.getTextMimetype_(uri);
  1324.     if (mimeType != 'text/vtt') {
  1325.       throw new shaka.util.Error(
  1326.           shaka.util.Error.Severity.RECOVERABLE,
  1327.           shaka.util.Error.Category.TEXT,
  1328.           shaka.util.Error.Code.UNSUPPORTED_EXTERNAL_THUMBNAILS_URI,
  1329.           uri);
  1330.     }
  1332.     goog.asserts.assert(
  1333.         this.networkingEngine_, 'Need networking engine.');
  1334.     const buffer = await this.getTextData_(uri,
  1335.         this.networkingEngine_,
  1336.         this.config_.streaming.retryParameters);
  1338.     const factory = shaka.text.TextEngine.findParser(mimeType);
  1339.     if (!factory) {
  1340.       throw new shaka.util.Error(
  1341.           shaka.util.Error.Severity.CRITICAL,
  1342.           shaka.util.Error.Category.TEXT,
  1343.           shaka.util.Error.Code.MISSING_TEXT_PLUGIN,
  1344.           mimeType);
  1345.     }
  1346.     const TextParser = factory();
  1347.     const time = {
  1348.       periodStart: 0,
  1349.       segmentStart: 0,
  1350.       segmentEnd: manifest.presentationTimeline.getDuration(),
  1351.       vttOffset: 0,
  1352.     };
  1353.     const data = shaka.util.BufferUtils.toUint8(buffer);
  1354.     const cues = TextParser.parseMedia(data, time, uri, /* images= */ []);
  1356.     const references = [];
  1357.     for (const cue of cues) {
  1358.       let uris = null;
  1359.       const getUris = () => {
  1360.         if (uris == null) {
  1361.           uris = shaka.util.ManifestParserUtils.resolveUris(
  1362.               [uri], [cue.payload]);
  1363.         }
  1364.         return uris || [];
  1365.       };
  1366.       const reference = new shaka.media.SegmentReference(
  1367.           cue.startTime,
  1368.           cue.endTime,
  1369.           getUris,
  1370.           /* startByte= */ 0,
  1371.           /* endByte= */ null,
  1372.           /* initSegmentReference= */ null,
  1373.           /* timestampOffset= */ 0,
  1374.           /* appendWindowStart= */ 0,
  1375.           /* appendWindowEnd= */ Infinity,
  1376.       );
  1377.       if (cue.payload.includes('#xywh')) {
  1378.         const spriteInfo = cue.payload.split('#xywh=')[1].split(',');
  1379.         if (spriteInfo.length === 4) {
  1380.           reference.setThumbnailSprite({
  1381.             height: parseInt(spriteInfo[3], 10),
  1382.             positionX: parseInt(spriteInfo[0], 10),
  1383.             positionY: parseInt(spriteInfo[1], 10),
  1384.             width: parseInt(spriteInfo[2], 10),
  1385.           });
  1386.         }
  1387.       }
  1388.       references.push(reference);
  1389.     }
  1391.     let segmentMimeType = mimeType;
  1392.     if (references.length) {
  1393.       segmentMimeType = await shaka.net.NetworkingUtils.getMimeType(
  1394.           references[0].getUris()[0],
  1395.           this.networkingEngine_, this.config_.manifest.retryParameters);
  1396.     }
  1398.     return {
  1399.       id: this.nextExternalStreamId_++,
  1400.       originalId: null,
  1401.       groupId: null,
  1402.       createSegmentIndex: () => Promise.resolve(),
  1403.       segmentIndex: new shaka.media.SegmentIndex(references),
  1404.       mimeType: segmentMimeType || '',
  1405.       codecs: '',
  1406.       kind: '',
  1407.       encrypted: false,
  1408.       drmInfos: [],
  1409.       keyIds: new Set(),
  1410.       language: 'und',
  1411.       originalLanguage: null,
  1412.       label: null,
  1413.       type: shaka.util.ManifestParserUtils.ContentType.IMAGE,
  1414.       primary: false,
  1415.       trickModeVideo: null,
  1416.       dependencyStream: null,
  1417.       emsgSchemeIdUris: null,
  1418.       roles: [],
  1419.       forced: false,
  1420.       channelsCount: null,
  1421.       audioSamplingRate: null,
  1422.       spatialAudio: false,
  1423.       closedCaptions: null,
  1424.       tilesLayout: '1x1',
  1425.       accessibilityPurpose: null,
  1426.       external: true,
  1427.       fastSwitching: false,
  1428.       fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
  1429.           segmentMimeType || '', '')]),
  1430.       isAudioMuxedInVideo: false,
  1431.       baseOriginalId: null,
  1432.     };
  1433.   }
  1435.   /**
  1436.    * @param {shaka.extern.Manifest} manifest
  1437.    * @param {string} uri
  1438.    * @param {string} language
  1439.    * @param {string} kind
  1440.    * @param {string=} mimeType
  1441.    * @param {string=} codec
  1442.    * @private
  1443.    */
  1444.   async createExternalTextStream_(manifest, uri, language, kind, mimeType,
  1445.       codec) {
  1446.     if (!mimeType) {
  1447.       mimeType = await this.getTextMimetype_(uri);
  1448.     }
  1450.     /** @type {shaka.extern.Stream} */
  1451.     const stream = {
  1452.       id: this.nextExternalStreamId_++,
  1453.       originalId: null,
  1454.       groupId: null,
  1455.       createSegmentIndex: () => Promise.resolve(),
  1456.       segmentIndex: shaka.media.SegmentIndex.forSingleSegment(
  1457.           /* startTime= */ 0,
  1458.           /* duration= */ manifest.presentationTimeline.getDuration(),
  1459.           /* uris= */ [uri]),
  1460.       mimeType: mimeType || '',
  1461.       codecs: codec || '',
  1462.       kind: kind,
  1463.       encrypted: false,
  1464.       drmInfos: [],
  1465.       keyIds: new Set(),
  1466.       language: language,
  1467.       originalLanguage: language,
  1468.       label: null,
  1469.       type: shaka.util.ManifestParserUtils.ContentType.TEXT,
  1470.       primary: false,
  1471.       trickModeVideo: null,
  1472.       dependencyStream: null,
  1473.       emsgSchemeIdUris: null,
  1474.       roles: [],
  1475.       forced: false,
  1476.       channelsCount: null,
  1477.       audioSamplingRate: null,
  1478.       spatialAudio: false,
  1479.       closedCaptions: null,
  1480.       accessibilityPurpose: null,
  1481.       external: true,
  1482.       fastSwitching: false,
  1483.       fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
  1484.           mimeType || '', codec || '')]),
  1485.       isAudioMuxedInVideo: false,
  1486.       baseOriginalId: null,
  1487.     };
  1489.     const fullMimeType = shaka.util.MimeUtils.getFullType(
  1490.         stream.mimeType, stream.codecs);
  1491.     const supported = shaka.text.TextEngine.isTypeSupported(fullMimeType);
  1492.     if (!supported) {
  1493.       throw new shaka.util.Error(
  1494.           shaka.util.Error.Severity.CRITICAL,
  1495.           shaka.util.Error.Category.TEXT,
  1496.           shaka.util.Error.Code.MISSING_TEXT_PLUGIN,
  1497.           mimeType);
  1498.     }
  1500.     return stream;
  1501.   }
  1503.   /**
  1504.    * @param {string} uri
  1505.    * @return {!Promise<string>}
  1506.    * @private
  1507.    */
  1508.   async getTextMimetype_(uri) {
  1509.     let mimeType;
  1510.     try {
  1511.       goog.asserts.assert(
  1512.           this.networkingEngine_, 'Need networking engine.');
  1513.       mimeType = await shaka.net.NetworkingUtils.getMimeType(uri,
  1514.           this.networkingEngine_,
  1515.           this.config_.streaming.retryParameters);
  1516.     } catch (error) {}
  1518.     if (mimeType) {
  1519.       return mimeType;
  1520.     }
  1522.     shaka.log.error(
  1523.         'The mimeType has not been provided and it could not be deduced ' +
  1524.         'from its uri.');
  1525.     throw new shaka.util.Error(
  1526.         shaka.util.Error.Severity.RECOVERABLE,
  1527.         shaka.util.Error.Category.TEXT,
  1528.         shaka.util.Error.Code.TEXT_COULD_NOT_GUESS_MIME_TYPE,
  1529.         uri);
  1530.   }
  1532.   /**
  1533.    * @param {string} uri
  1534.    * @param {!shaka.net.NetworkingEngine} netEngine
  1535.    * @param {shaka.extern.RetryParameters} retryParams
  1536.    * @return {!Promise<BufferSource>}
  1537.    * @private
  1538.    */
  1539.   async getTextData_(uri, netEngine, retryParams) {
  1540.     const type = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  1542.     const request = shaka.net.NetworkingEngine.makeRequest([uri], retryParams);
  1543.     request.method = 'GET';
  1545.     const response = await netEngine.request(type, request).promise;
  1547.     return response.data;
  1548.   }
  1550.   /**
  1551.    * This method is public so that it can be override in testing.
  1552.    *
  1553.    * @param {shaka.extern.Manifest} manifest
  1554.    * @param {function(shaka.util.Error)} onError
  1555.    * @param {shaka.extern.PlayerConfiguration} config
  1556.    * @param {boolean} usePersistentLicense
  1557.    * @return {!Promise<!shaka.drm.DrmEngine>}
  1558.    */
  1559.   async createDrmEngine(manifest, onError, config, usePersistentLicense) {
  1560.     goog.asserts.assert(
  1561.         this.networkingEngine_,
  1562.         'Cannot call |createDrmEngine| after |destroy|');
  1564.     /** @type {!shaka.drm.DrmEngine} */
  1565.     const drmEngine = new shaka.drm.DrmEngine({
  1566.       netEngine: this.networkingEngine_,
  1567.       onError: onError,
  1568.       onKeyStatus: () => {},
  1569.       onExpirationUpdated: () => {},
  1570.       onEvent: () => {},
  1571.     });
  1573.     drmEngine.configure(config.drm);
  1574.     await drmEngine.initForStorage(manifest.variants, usePersistentLicense);
  1575.     await drmEngine.createOrLoad();
  1577.     return drmEngine;
  1578.   }
  1580.   /**
  1581.    * Converts manifest Streams to database Streams.
  1582.    *
  1583.    * @param {!shaka.offline.DownloadManager} downloader
  1584.    * @param {shaka.offline.StreamBandwidthEstimator} estimator
  1585.    * @param {!shaka.drm.DrmEngine} drmEngine
  1586.    * @param {shaka.extern.Manifest} manifest
  1587.    * @param {shaka.extern.PlayerConfiguration} config
  1588.    * @return {{
  1589.    *   streams: !Array<shaka.extern.StreamDB>,
  1590.    *   toDownload: !Array<!shaka.offline.DownloadInfo>
  1591.    * }}
  1592.    * @private
  1593.    */
  1594.   createStreams_(downloader, estimator, drmEngine, manifest, config) {
  1595.     // Download infos are stored based on their refId, to deduplicate them.
  1596.     /** @type {!Map<string, !shaka.offline.DownloadInfo>} */
  1597.     const toDownload = new Map();
  1599.     // Find the streams we want to download and create a stream db instance
  1600.     // for each of them.
  1601.     const streamSet =
  1602.         shaka.offline.Storage.getAllStreamsFromManifest_(manifest);
  1603.     const streamDBs = new Map();
  1605.     for (const stream of streamSet) {
  1606.       const streamDB = this.createStream_(
  1607.           downloader, estimator, manifest, stream, config, toDownload);
  1608.       streamDBs.set(stream.id, streamDB);
  1609.     }
  1611.     // Connect streams and variants together.
  1612.     for (const variant of manifest.variants) {
  1613.       if (variant.audio) {
  1614.         streamDBs.get(variant.audio.id).variantIds.push(variant.id);
  1615.       }
  1616.       if (variant.video) {
  1617.         streamDBs.get(variant.video.id).variantIds.push(variant.id);
  1618.       }
  1619.     }
  1621.     return {
  1622.       streams: Array.from(streamDBs.values()),
  1623.       toDownload: Array.from(toDownload.values()),
  1624.     };
  1625.   }
  1627.   /**
  1628.    * Converts a manifest stream to a database stream.  This will search the
  1629.    * segment index and add all the segments to the download infos.
  1630.    *
  1631.    * @param {!shaka.offline.DownloadManager} downloader
  1632.    * @param {shaka.offline.StreamBandwidthEstimator} estimator
  1633.    * @param {shaka.extern.Manifest} manifest
  1634.    * @param {shaka.extern.Stream} stream
  1635.    * @param {shaka.extern.PlayerConfiguration} config
  1636.    * @param {!Map<string, !shaka.offline.DownloadInfo>} toDownload
  1637.    * @return {shaka.extern.StreamDB}
  1638.    * @private
  1639.    */
  1640.   createStream_(downloader, estimator, manifest, stream, config, toDownload) {
  1641.     /** @type {shaka.extern.StreamDB} */
  1642.     const streamDb = {
  1643.       id: stream.id,
  1644.       originalId: stream.originalId,
  1645.       groupId: stream.groupId,
  1646.       primary: stream.primary,
  1647.       type: stream.type,
  1648.       mimeType: stream.mimeType,
  1649.       codecs: stream.codecs,
  1650.       frameRate: stream.frameRate,
  1651.       pixelAspectRatio: stream.pixelAspectRatio,
  1652.       hdr: stream.hdr,
  1653.       colorGamut: stream.colorGamut,
  1654.       videoLayout: stream.videoLayout,
  1655.       kind: stream.kind,
  1656.       language: stream.language,
  1657.       originalLanguage: stream.originalLanguage,
  1658.       label: stream.label,
  1659.       width: stream.width || null,
  1660.       height: stream.height || null,
  1661.       encrypted: stream.encrypted,
  1662.       keyIds: stream.keyIds,
  1663.       segments: [],
  1664.       variantIds: [],
  1665.       roles: stream.roles,
  1666.       forced: stream.forced,
  1667.       channelsCount: stream.channelsCount,
  1668.       audioSamplingRate: stream.audioSamplingRate,
  1669.       spatialAudio: stream.spatialAudio,
  1670.       closedCaptions: stream.closedCaptions,
  1671.       tilesLayout: stream.tilesLayout,
  1672.       mssPrivateData: stream.mssPrivateData,
  1673.       external: stream.external,
  1674.       fastSwitching: stream.fastSwitching,
  1675.       isAudioMuxedInVideo: stream.isAudioMuxedInVideo,
  1676.     };
  1678.     const startTime =
  1679.         manifest.presentationTimeline.getSegmentAvailabilityStart();
  1681.     const numberOfParallelDownloads = config.offline.numberOfParallelDownloads;
  1682.     let groupId = numberOfParallelDownloads === 0 ? stream.id : 0;
  1684.     shaka.offline.Storage.forEachSegment_(stream, startTime, (segment, pos) => {
  1685.       const pendingSegmentRefId =
  1686.           shaka.offline.DownloadInfo.idForSegmentRef(segment);
  1687.       let pendingInitSegmentRefId = undefined;
  1689.       // Set up the download for the segment, which will be downloaded later,
  1690.       // perhaps in a service worker.
  1691.       if (!toDownload.has(pendingSegmentRefId)) {
  1692.         const estimateId = downloader.addDownloadEstimate(
  1693.             estimator.getSegmentEstimate(stream.id, segment));
  1694.         const segmentDownload = new shaka.offline.DownloadInfo(
  1695.             segment,
  1696.             estimateId,
  1697.             groupId,
  1698.             /* isInitSegment= */ false,
  1699.             pos);
  1700.         toDownload.set(pendingSegmentRefId, segmentDownload);
  1701.       }
  1703.       // Set up the download for the init segment, similarly, if there is one.
  1704.       if (segment.initSegmentReference) {
  1705.         pendingInitSegmentRefId = shaka.offline.DownloadInfo.idForSegmentRef(
  1706.             segment.initSegmentReference);
  1707.         if (!toDownload.has(pendingInitSegmentRefId)) {
  1708.           const estimateId = downloader.addDownloadEstimate(
  1709.               estimator.getInitSegmentEstimate(stream.id));
  1710.           const initDownload = new shaka.offline.DownloadInfo(
  1711.               segment.initSegmentReference,
  1712.               estimateId,
  1713.               groupId,
  1714.               /* isInitSegment= */ true,
  1715.               pos);
  1716.           toDownload.set(pendingInitSegmentRefId, initDownload);
  1717.         }
  1718.       }
  1720.       /** @type {!shaka.extern.SegmentDB} */
  1721.       const segmentDB = {
  1722.         pendingInitSegmentRefId,
  1723.         initSegmentKey: pendingInitSegmentRefId ? 0 : null,
  1724.         startTime: segment.startTime,
  1725.         endTime: segment.endTime,
  1726.         appendWindowStart: segment.appendWindowStart,
  1727.         appendWindowEnd: segment.appendWindowEnd,
  1728.         timestampOffset: segment.timestampOffset,
  1729.         tilesLayout: segment.tilesLayout,
  1730.         pendingSegmentRefId,
  1731.         dataKey: 0,
  1732.         mimeType: segment.mimeType,
  1733.         codecs: segment.codecs,
  1734.         thumbnailSprite: segment.thumbnailSprite,
  1735.       };
  1736.       streamDb.segments.push(segmentDB);
  1737.       if (numberOfParallelDownloads !== 0) {
  1738.         groupId = (groupId + 1) % numberOfParallelDownloads;
  1739.       }
  1740.     });
  1742.     return streamDb;
  1743.   }
  1745.   /**
  1746.    * @param {shaka.extern.Stream} stream
  1747.    * @param {number} startTime
  1748.    * @param {function(!shaka.media.SegmentReference, number)} callback
  1749.    * @private
  1750.    */
  1751.   static forEachSegment_(stream, startTime, callback) {
  1752.     /** @type {?number} */
  1753.     let i = stream.segmentIndex.find(startTime);
  1755.     if (i == null) {
  1756.       return;
  1757.     }
  1759.     /** @type {?shaka.media.SegmentReference} */
  1760.     let ref = stream.segmentIndex.get(i);
  1761.     while (ref) {
  1762.       callback(ref, i);
  1763.       ref = stream.segmentIndex.get(++i);
  1764.     }
  1765.   }
  1767.   /**
  1768.    * Throws an error if the object is destroyed.
  1769.    * @private
  1770.    */
  1771.   ensureNotDestroyed_() {
  1772.     if (this.destroyer_.destroyed()) {
  1773.       throw new shaka.util.Error(
  1774.           shaka.util.Error.Severity.CRITICAL,
  1775.           shaka.util.Error.Category.STORAGE,
  1776.           shaka.util.Error.Code.OPERATION_ABORTED);
  1777.     }
  1778.   }
  1780.   /**
  1781.    * Used by functions that need storage support to ensure that the current
  1782.    * platform has storage support before continuing. This should only be
  1783.    * needed to be used at the start of public methods.
  1784.    *
  1785.    * @private
  1786.    */
  1787.   requireSupport_() {
  1788.     if (!shaka.offline.Storage.support()) {
  1789.       throw new shaka.util.Error(
  1790.           shaka.util.Error.Severity.CRITICAL,
  1791.           shaka.util.Error.Category.STORAGE,
  1792.           shaka.util.Error.Code.STORAGE_NOT_SUPPORTED);
  1793.     }
  1794.   }
  1796.   /**
  1797.    * Perform an action. Track the action's progress so that when we destroy
  1798.    * we will wait until all the actions have completed before allowing destroy
  1799.    * to resolve.
  1800.    *
  1801.    * @param {!Promise<T>} action
  1802.    * @return {!Promise<T>}
  1803.    * @template T
  1804.    * @private
  1805.    */
  1806.   async startOperation_(action) {
  1807.     this.openOperations_.push(action);
  1809.     try {
  1810.       // Await |action| so we can use the finally statement to remove |action|
  1811.       // from |openOperations_| when we still have a reference to |action|.
  1812.       return await action;
  1813.     } finally {
  1814.       shaka.util.ArrayUtils.remove(this.openOperations_, action);
  1815.     }
  1816.   }
  1818.   /**
  1819.    * The equivalent of startOperation_, but for abortable operations.
  1820.    *
  1821.    * @param {!shaka.extern.IAbortableOperation<T>} action
  1822.    * @return {!shaka.extern.IAbortableOperation<T>}
  1823.    * @template T
  1824.    * @private
  1825.    */
  1826.   startAbortableOperation_(action) {
  1827.     const promise = action.promise;
  1828.     this.openOperations_.push(promise);
  1830.     // Remove the open operation once the action has completed. So that we
  1831.     // can still return the AbortableOperation, this is done using a |finally|
  1832.     // block, rather than awaiting the result.
  1833.     return action.finally(() => {
  1834.       shaka.util.ArrayUtils.remove(this.openOperations_, promise);
  1835.     });
  1836.   }
  1838.   /**
  1839.    * @param {shaka.extern.ManifestDB} manifest
  1840.    * @return {!Array<number>}
  1841.    * @private
  1842.    */
  1843.   static getAllSegmentIds_(manifest) {
  1844.     /** @type {!Set<number>} */
  1845.     const ids = new Set();
  1847.     // Get every segment for every stream in the manifest.
  1848.     for (const stream of manifest.streams) {
  1849.       for (const segment of stream.segments) {
  1850.         if (segment.initSegmentKey != null) {
  1851.           ids.add(segment.initSegmentKey);
  1852.         }
  1854.         ids.add(segment.dataKey);
  1855.       }
  1856.     }
  1858.     return Array.from(ids);
  1859.   }
  1861.   /**
  1862.    * Delete the on-disk storage and all the content it contains. This should not
  1863.    * be done in normal circumstances. Only do it when storage is rendered
  1864.    * unusable, such as by a version mismatch. No business logic will be run, and
  1865.    * licenses will not be released.
  1866.    *
  1867.    * @return {!Promise}
  1868.    * @export
  1869.    */
  1870.   static async deleteAll() {
  1871.     /** @type {!shaka.offline.StorageMuxer} */
  1872.     const muxer = new shaka.offline.StorageMuxer();
  1873.     try {
  1874.       // Wipe all content from all storage mechanisms.
  1875.       await muxer.erase();
  1876.     } finally {
  1877.       // Destroy the muxer, whether or not erase() succeeded.
  1878.       await muxer.destroy();
  1879.     }
  1880.   }
  1882.   /**
  1883.    * @param {!shaka.net.NetworkingEngine} net
  1884.    * @param {!shaka.extern.DrmConfiguration} drmConfig
  1885.    * @param {!shaka.offline.StorageMuxer} muxer
  1886.    * @param {shaka.extern.ManifestDB} manifestDb
  1887.    * @return {!Promise}
  1888.    * @private
  1889.    */
  1890.   static async deleteLicenseFor_(net, drmConfig, muxer, manifestDb) {
  1891.     if (!manifestDb.drmInfo) {
  1892.       return;
  1893.     }
  1895.     const sessionIdCell = muxer.getEmeSessionCell();
  1897.     /** @type {!Array<shaka.extern.EmeSessionDB>} */
  1898.     const sessions = manifestDb.sessionIds.map((sessionId) => {
  1899.       return {
  1900.         sessionId: sessionId,
  1901.         keySystem: manifestDb.drmInfo.keySystem,
  1902.         licenseUri: manifestDb.drmInfo.licenseServerUri,
  1903.         serverCertificate: manifestDb.drmInfo.serverCertificate,
  1904.         audioCapabilities: shaka.offline.Storage.getCapabilities_(
  1905.             manifestDb,
  1906.             /* isVideo= */ false),
  1907.         videoCapabilities: shaka.offline.Storage.getCapabilities_(
  1908.             manifestDb,
  1909.             /* isVideo= */ true),
  1910.       };
  1911.     });
  1912.     // Try to delete the sessions; any sessions that weren't deleted get stored
  1913.     // in the database so we can try to remove them again later.  This allows us
  1914.     // to still delete the stored content but not "forget" about these sessions.
  1915.     // Later, we can remove the sessions to free up space.
  1916.     const deleter = new shaka.offline.SessionDeleter();
  1917.     const deletedSessionIds = await deleter.delete(drmConfig, net, sessions);
  1918.     await sessionIdCell.remove(deletedSessionIds);
  1919.     await sessionIdCell.add(sessions.filter(
  1920.         (session) => !deletedSessionIds.includes(session.sessionId)));
  1921.   }
  1923.   /**
  1924.    * Get the set of all streams in |manifest|.
  1925.    *
  1926.    * @param {shaka.extern.Manifest} manifest
  1927.    * @return {!Set<shaka.extern.Stream>}
  1928.    * @private
  1929.    */
  1930.   static getAllStreamsFromManifest_(manifest) {
  1931.     /** @type {!Set<shaka.extern.Stream>} */
  1932.     const set = new Set();
  1934.     for (const variant of manifest.variants) {
  1935.       if (variant.audio) {
  1936.         set.add(variant.audio);
  1937.       }
  1938.       if (variant.video) {
  1939.         set.add(variant.video);
  1940.       }
  1941.     }
  1943.     for (const text of manifest.textStreams) {
  1944.       set.add(text);
  1945.     }
  1947.     for (const image of manifest.imageStreams) {
  1948.       set.add(image);
  1949.     }
  1951.     return set;
  1952.   }
  1954.   /**
  1955.    * Go over a manifest and issue warnings for any suspicious properties.
  1956.    *
  1957.    * @param {shaka.extern.Manifest} manifest
  1958.    * @private
  1959.    */
  1960.   static validateManifest_(manifest) {
  1961.     const videos = new Set(manifest.variants.map((v) => v.video));
  1962.     const audios = new Set(manifest.variants.map((v) => v.audio));
  1963.     const texts = manifest.textStreams;
  1965.     if (videos.size > 1) {
  1966.       shaka.log.warning('Multiple video tracks selected to be stored');
  1967.     }
  1969.     for (const audio1 of audios) {
  1970.       for (const audio2 of audios) {
  1971.         if (audio1 != audio2 && audio1.language == audio2.language) {
  1972.           shaka.log.warning(
  1973.               'Similar audio tracks were selected to be stored',
  1974.               audio1.id,
  1975.               audio2.id);
  1976.         }
  1977.       }
  1978.     }
  1980.     for (const text1 of texts) {
  1981.       for (const text2 of texts) {
  1982.         if (text1 != text2 && text1.language == text2.language) {
  1983.           shaka.log.warning(
  1984.               'Similar text tracks were selected to be stored',
  1985.               text1.id,
  1986.               text2.id);
  1987.         }
  1988.       }
  1989.     }
  1990.   }
  1991. };
  1993. shaka.offline.Storage.defaultSystemIds_ = new Map()
  1994.     .set('org.w3.clearkey', '1077efecc0b24d02ace33c1e52e2fb4b')
  1995.     .set('com.widevine.alpha', 'edef8ba979d64acea3c827dcd51d21ed')
  1996.     .set('com.microsoft.playready', '9a04f07998404286ab92e65be0885f95')
  1997.     .set('com.microsoft.playready.recommendation',
  1998.         '9a04f07998404286ab92e65be0885f95')
  1999.     .set('com.microsoft.playready.software',
  2000.         '9a04f07998404286ab92e65be0885f95')
  2001.     .set('com.microsoft.playready.hardware',
  2002.         '9a04f07998404286ab92e65be0885f95')
  2003.     .set('com.huawei.wiseplay', '3d5e6d359b9a41e8b843dd3c6e72c42c');
  2005. shaka.Player.registerSupportPlugin('offline', shaka.offline.Storage.support);