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