storage_integration.js

/*! @license
 * Shaka Player
 * Copyright 2016 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */

goog.require('goog.asserts');
goog.require('shaka.Player');
goog.require('shaka.media.DrmEngine');
goog.require('shaka.media.ManifestParser');
goog.require('shaka.media.SegmentIndex');
goog.require('shaka.net.NetworkingEngine.RequestType');
goog.require('shaka.offline.ManifestConverter');
goog.require('shaka.offline.OfflineUri');
goog.require('shaka.offline.Storage');
goog.require('shaka.offline.StorageMuxer');
goog.require('shaka.test.FakeDrmEngine');
goog.require('shaka.test.FakeManifestParser');
goog.require('shaka.test.FakeNetworkingEngine');
goog.require('shaka.test.Loader');
goog.require('shaka.test.ManifestGenerator');
goog.require('shaka.test.TestScheme');
goog.require('shaka.test.Util');
goog.require('shaka.util.AbortableOperation');
goog.require('shaka.util.BufferUtils');
goog.require('shaka.util.Error');
goog.require('shaka.util.EventManager');
goog.require('shaka.util.PlayerConfiguration');
goog.require('shaka.util.PublicPromise');
goog.require('shaka.util.Uint8ArrayUtils');
goog.requireType('shaka.media.SegmentReference');

/** @return {boolean} */
function storageSupport() {
  return shaka.offline.Storage.support();
}

/** @return {!Promise.<boolean>} */
async function drmStorageSupport() {
  if (!shaka.offline.Storage.support()) {
    return false;
  }

  const support = await shaka.Player.probeSupport();
  const widevineSupport = support.drm['com.widevine.alpha'];
  return !!(widevineSupport && widevineSupport.persistentState);
}

filterDescribe('Storage', storageSupport, () => {
  const Util = shaka.test.Util;

  const englishUS = 'en-us';
  const frenchCanadian = 'fr-ca';
  const fakeMimeType = 'application/test';

  const manifestWithPerStreamBandwidthUri =
      'fake:manifest-with-per-stream-bandwidth';
  const manifestWithoutPerStreamBandwidthUri =
      'fake:manifest-without-per-stream-bandwidth';
  const manifestWithNonZeroStartUri = 'fake:manifest-with-non-zero-start';
  const manifestWithLiveTimelineUri = 'fake:manifest-with-live-timeline';
  const manifestWithAlternateSegmentsUri = 'fake:manifest-with-alt-segments';
  const manifestWithVideoInitSegmentsUri =
      'fake:manifest-with-video-init-segments';

  const initSegmentUri = 'fake:init-segment';
  const segment1Uri = 'fake:segment-1';
  const segment2Uri = 'fake:segment-2';
  const segment3Uri = 'fake:segment-3';
  const segment4Uri = 'fake:segment-4';

  const alternateInitSegmentUri = 'fake:alt-init-segment';
  const alternateSegment1Uri = 'fake:alt-segment-1';
  const alternateSegment2Uri = 'fake:alt-segment-2';
  const alternateSegment3Uri = 'fake:alt-segment-3';
  const alternateSegment4Uri = 'fake:alt-segment-4';

  const noMetadata = {};

  const kbps = (k) => k * 1000;

  beforeEach(async () => {
    // Make sure we start with a clean slate between each run.
    await eraseStorage();

    shaka.media.ManifestParser.registerParserByMime(
        fakeMimeType, () => new FakeManifestParser());
  });

  afterEach(async () => {
    shaka.media.ManifestParser.unregisterParserByMime(fakeMimeType);
    // Make sure we don't leave anything behind.
    await eraseStorage();
  });

  describe('storage delete all', () => {
    /** @type {!shaka.Player} */
    let player;

    beforeEach(() => {
      // Use a real Player since Storage only uses the configuration and
      // networking engine.  This allows us to use Player.configure in these
      // tests.
      player = new shaka.Player();
    });

    afterEach(async () => {
      await player.destroy();
    });

    it('removes all content from storage', async () => {
      const testSchemeMimeType = 'application/x-test-manifest';
      const manifestUri = 'test:sintel';

      // Store a piece of content.
      await withStorage((storage) => {
        return storage.store(
            manifestUri, noMetadata, testSchemeMimeType).promise;
      });

      // Make sure that the content can be found.
      await withStorage(async (storage) => {
        const content = await storage.list();
        expect(content).toBeTruthy();
        expect(content.length).toBe(1);
      });

      // Ask storage to erase everything.
      await shaka.offline.Storage.deleteAll();

      // Make sure that all content that was previously found is no gone.
      await withStorage(async (storage) => {
        const content = await storage.list();
        expect(content).toBeTruthy();
        expect(content.length).toBe(0);
      });
    });

    /**
     * @param {function(!shaka.offline.Storage)|
     *         function(!shaka.offline.Storage):!Promise} action
     * @return {!Promise}
     */
    async function withStorage(action) {
      /** @type {!shaka.offline.Storage} */
      const storage = new shaka.offline.Storage(player);

      try {
        await action(storage);
      } finally {
        await storage.destroy();
      }
    }
  });

  filterDescribe('persistent license', drmStorageSupport, () => {
    /** @type {!shaka.Player} */
    let player;
    /** @type {!shaka.offline.Storage} */
    let storage;

    beforeEach(() => {
      // Use a real Player since Storage only uses the configuration and
      // networking engine.  This allows us to use Player.configure in these
      // tests.
      player = new shaka.Player();
      storage = new shaka.offline.Storage(player);
    });

    afterEach(async () => {
      await storage.destroy();
      await player.destroy();
    });

    // TODO: Make a test to ensure that setting delayLicenseRequestUntilPlayed
    // to true doesn't break storage, once we have working tests for storing DRM
    // content.
    // See issue #2218.

    // Quarantined due to http://crbug.com/1019298 where a load cannot happen
    // immediately after a remove.  This can sometimes be fixed with a delay,
    // but it is extremely flaky, so these are disabled until the bug is fixed.
    quarantinedIt('removes persistent license', async () => {
      const testSchemeMimeType = 'application/x-test-manifest';

      // PART 1 - Download and store content that has a persistent license
      //          associated with it.
      const stored = await storage.store(
          'test:sintel-enc', noMetadata, testSchemeMimeType).promise;
      goog.asserts.assert(stored.offlineUri != null, 'URI should not be null!');

      /** @type {shaka.offline.OfflineUri} */
      const uri = shaka.offline.OfflineUri.parse(stored.offlineUri);
      goog.asserts.assert(uri, 'Stored offline uri should be non-null');

      const manifest = await getStoredManifest(uri);
      expect(manifest.offlineSessionIds).toBeTruthy();
      expect(manifest.offlineSessionIds.length).toBeTruthy();

      // PART 2 - Check that the licences are stored.
      await withDrm(player, manifest, (drm) => {
        return Promise.all(manifest.offlineSessionIds.map(async (session) => {
          const foundSession = await loadOfflineSession(drm, session);
          expect(foundSession).toBeTruthy();
        }));
      });

      // PART 3 - Remove the manifest from storage. This should remove all
      // the sessions.
      await storage.remove(uri.toString());

      // PART 4 - Check that the licenses were removed.
      const p = withDrm(player, manifest, (drm) => {
        return Promise.all(manifest.offlineSessionIds.map(async (session) => {
          const notFoundSession = await loadOfflineSession(drm, session);
          expect(notFoundSession).toBeFalsy();
        }));
      });
      const expected = Util.jasmineError(new shaka.util.Error(
          shaka.util.Error.Severity.CRITICAL,
          shaka.util.Error.Category.DRM,
          shaka.util.Error.Code.OFFLINE_SESSION_REMOVED));
      await expectAsync(p).toBeRejectedWith(expected);
    });

    quarantinedIt('defers removing licenses on error', async () => {
      const testSchemeMimeType = 'application/x-test-manifest';

      // PART 1 - Download and store content that has a persistent license
      //          associated with it.
      const stored = await storage.store(
          'test:sintel-enc', noMetadata, testSchemeMimeType).promise;
      goog.asserts.assert(stored.offlineUri != null, 'URI should not be null!');

      /** @type {shaka.offline.OfflineUri} */
      const uri = shaka.offline.OfflineUri.parse(stored.offlineUri);
      goog.asserts.assert(uri, 'Stored offline uri should be non-null');
      const manifest = await getStoredManifest(uri);

      // PART 2 - Add an error so the release license message fails.
      storage.getNetworkingEngine().registerRequestFilter(
          (type, request) => {
            if (type == shaka.net.NetworkingEngine.RequestType.LICENSE) {
              throw new Error('Error should be ignored');
            }
          });

      // PART 3 - Remove the manifest from storage. This should ignore the
      // error with the EME session.  It should also store the session for
      // later removal.
      await storage.remove(uri.toString());

      // PART 4 - Verify the media was deleted but the session still exists.
      const storedContents = await storage.list();
      expect(storedContents).toEqual([]);

      await withDrm(player, manifest, (drm) => {
        return Promise.all(manifest.offlineSessionIds.map(async (session) => {
          const foundSession = await loadOfflineSession(drm, session);
          expect(foundSession).toBeTruthy();
        }));
      });

      // PART 5 - Disable the error and remove the EME session.
      storage.getNetworkingEngine().clearAllRequestFilters();
      const didRemoveAll = await storage.removeEmeSessions();
      expect(didRemoveAll).toBe(true);

      // PART 6 - Check that the licenses were removed.
      const p = withDrm(player, manifest, (drm) => {
        return Promise.all(manifest.offlineSessionIds.map(async (session) => {
          const notFoundSession = await loadOfflineSession(drm, session);
          expect(notFoundSession).toBeFalsy();
        }));
      });
      const expected = Util.jasmineError(new shaka.util.Error(
          shaka.util.Error.Severity.CRITICAL,
          shaka.util.Error.Category.DRM,
          shaka.util.Error.Code.OFFLINE_SESSION_REMOVED));
      await expectAsync(p).toBeRejectedWith(expected);
    });
  });

  describe('default track selection callback', () => {
    const PlayerConfiguration = shaka.util.PlayerConfiguration;

    it('selects the largest SD video with middle quality audio', () => {
      const tracks = [
        variantTrack(0, 360, englishUS, kbps(1.0)),
        variantTrack(1, 480, englishUS, kbps(2.0)),
        variantTrack(2, 480, englishUS, kbps(2.1)),
        variantTrack(3, 480, englishUS, kbps(2.2)),
        variantTrack(4, 720, englishUS, kbps(3.0)),
        variantTrack(5, 1080, englishUS, kbps(4.0)),
      ];

      const selected =
          PlayerConfiguration.defaultTrackSelect(tracks, englishUS);
      expect(selected).toBeTruthy();
      expect(selected.length).toBe(1);
      expect(selected[0]).toBeTruthy();
      expect(selected[0].language).toBe(englishUS);
      expect(selected[0].height).toBe(480);
      expect(selected[0].bandwidth).toBe(kbps(2.1));
    });

    it('selects all text tracks', () => {
      const tracks = [
        textTrack(0, englishUS),
        textTrack(1, frenchCanadian),
      ];

      const selected =
          PlayerConfiguration.defaultTrackSelect(tracks, englishUS);
      expect(selected).toBeTruthy();
      expect(selected.length).toBe(2);
      for (const track of tracks) {
        expect(selected).toContain(track);
      }
    });

    describe('language matching', () => {
      it('finds exact match', () => {
        const tracks = [
          variantTrack(0, 480, 'eng-us', kbps(1)),
          variantTrack(1, 480, 'fr-ca', kbps(1)),
          variantTrack(2, 480, 'eng-ca', kbps(1)),
        ];

        const selected =
            PlayerConfiguration.defaultTrackSelect(tracks, 'eng-us');
        expect(selected).toBeTruthy();
        expect(selected.length).toBe(1);
        expect(selected[0]).toBeTruthy();
        expect(selected[0].language).toBe('eng-us');
      });

      it('finds exact match with only base', () => {
        const tracks = [
          variantTrack(0, 480, 'eng-us', kbps(1)),
          variantTrack(1, 480, 'fr-ca', kbps(1)),
          variantTrack(2, 480, 'eng-ca', kbps(1)),
          variantTrack(3, 480, 'eng', kbps(1)),
        ];

        const selected = PlayerConfiguration.defaultTrackSelect(tracks, 'eng');
        expect(selected).toBeTruthy();
        expect(selected.length).toBe(1);
        expect(selected[0]).toBeTruthy();
        expect(selected[0].language).toBe('eng');
      });

      it('finds base match when exact match is not found', () => {
        const tracks = [
          variantTrack(0, 480, 'eng-us', kbps(1)),
          variantTrack(1, 480, 'fr-ca', kbps(1)),
          variantTrack(2, 480, 'eng-ca', kbps(1)),
        ];

        const selected = PlayerConfiguration.defaultTrackSelect(tracks, 'fr');
        expect(selected).toBeTruthy();
        expect(selected.length).toBe(1);
        expect(selected[0]).toBeTruthy();
        expect(selected[0].language).toBe('fr-ca');
      });

      it('finds common base when exact match is not found', () => {
        const tracks = [
          variantTrack(0, 480, 'eng-us', kbps(1)),
          variantTrack(1, 480, 'fr-ca', kbps(1)),
          variantTrack(2, 480, 'eng-ca', kbps(1)),
        ];

        const selected =
            PlayerConfiguration.defaultTrackSelect(tracks, 'fr-uk');
        expect(selected).toBeTruthy();
        expect(selected.length).toBe(1);
        expect(selected[0]).toBeTruthy();
        expect(selected[0].language).toBe('fr-ca');
      });

      it('finds primary track when no match is found', () => {
        const tracks = [
          variantTrack(0, 480, 'eng-us', kbps(1)),
          variantTrack(1, 480, 'fr-ca', kbps(1)),
          variantTrack(2, 480, 'eng-ca', kbps(1)),
        ];

        tracks[0].primary = true;

        const selected = PlayerConfiguration.defaultTrackSelect(tracks, 'de');
        expect(selected).toBeTruthy();
        expect(selected.length).toBe(1);
        expect(selected[0]).toBeTruthy();
        expect(selected[0].language).toBe('eng-us');
      });
    });  // describe('language matching')
  });  // describe('default track selection callback')


  describe('no support', () => {
    const expectedError = Util.jasmineError(new shaka.util.Error(
        shaka.util.Error.Severity.CRITICAL,
        shaka.util.Error.Category.STORAGE,
        shaka.util.Error.Code.STORAGE_NOT_SUPPORTED));

    /** @type {!shaka.Player} */
    let player;
    /** @type {!shaka.offline.Storage} */
    let storage;

    // CAUTION: Do not put overrideSupport() or clearSupport() in
    // beforEach/afterEach.  They change what is supported at a static level.
    // When the test is run, a shim will call the support check and the test
    // will be skipped if overrideSupport() has been called already.  A shim of
    // afterEach will call the same check and skip afterEach's body, too, and
    // the clean up will never happen.  So the calls to overrideSupport() and
    // clearSupport() must be in each test using try/finally.

    beforeEach(() => {
      player = new shaka.Player();
      storage = new shaka.offline.Storage(player);
      // NOTE: See above "CAUTION" comment about overrideSupport/clearSupport.
    });

    afterEach(async () => {
      await storage.destroy();
      await player.destroy();
      // NOTE: See above "CAUTION" comment about overrideSupport/clearSupport.
    });

    it('throws error using list', async () => {
      try {
        shaka.offline.StorageMuxer.overrideSupport(new Map());

        await expectAsync(storage.list()).toBeRejectedWith(expectedError);
      } finally {
        shaka.offline.StorageMuxer.clearOverride();
      }
    });

    it('throws error using store', async () => {
      try {
        shaka.offline.StorageMuxer.overrideSupport(new Map());

        const store = storage.store('any-uri', noMetadata, fakeMimeType);
        await expectAsync(store.promise).toBeRejectedWith(expectedError);
      } finally {
        shaka.offline.StorageMuxer.clearOverride();
      }
    });

    it('throws error using remove', async () => {
      try {
        shaka.offline.StorageMuxer.overrideSupport(new Map());

        const remove = storage.remove('any-uri');
        await expectAsync(remove).toBeRejectedWith(expectedError);
      } finally {
        shaka.offline.StorageMuxer.clearOverride();
      }
    });
  });

  // Test that progress will be reported as we expect when manifests have
  // stream-level bandwidth information and when manifests only have
  // variant-level bandwidth information.
  //
  // Since we build our promise chains to allow each stream to be downloaded
  // in parallel (implementation detail) progress can be non-deterministic
  // as we see different promise resolution orders between browsers (and
  // runs). So to control this, we force resolution order for our network
  // requests in these tests.
  //
  // To allow us to control the network order, our manifests for these tests
  // could not repeat/reuse segments uris.
  describe('reports progress on store', () => {
    const audioSegment1Uri = 'fake:audio-segment-1';
    const audioSegment2Uri = 'fake:audio-segment-2';
    const audioSegment3Uri = 'fake:audio-segment-3';
    const audioSegment4Uri = 'fake:audio-segment-4';

    const videoSegment1Uri = 'fake:video-segment-1';
    const videoSegment2Uri = 'fake:video-segment-2';
    const videoSegment3Uri = 'fake:video-segment-3';
    const videoSegment4Uri = 'fake:video-segment-4';

    /** @type {!shaka.offline.Storage} */
    let storage;

    /** @type {!Object.<string, function():!Promise.<ArrayBuffer>>} */
    let fakeResponses = {};

    let compiledShaka;

    beforeAll(async () => {
      compiledShaka =
          await shaka.test.Loader.loadShaka(getClientArg('uncompiled'));

      compiledShaka.net.NetworkingEngine.registerScheme(
          'fake', (uri, req, type, progress) => {
            if (fakeResponses[uri]) {
              const operation = async () => {
                const data = await fakeResponses[uri]();
                return {
                  uri,
                  data,
                  headers: {},
                };
              };
              return shaka.util.AbortableOperation.notAbortable(operation());
            } else {
              return shaka.util.AbortableOperation.failed(
                  new shaka.util.Error(
                      shaka.util.Error.Severity.RECOVERABLE,
                      shaka.util.Error.Category.NETWORK,
                      shaka.util.Error.Code.HTTP_ERROR));
            }
          });
    });

    beforeEach(async () => {
      await shaka.test.TestScheme.createManifests(compiledShaka, '_compiled');

      storage = new compiledShaka.offline.Storage();

      // Since we are using specific manifest with only one video and one audio
      // we can return all the tracks.
      storage.configure({
        offline: {
          trackSelectionCallback: (tracks) => { return tracks; },
        },
      });

      // Use these promises to ensure that the data from networking
      // engine arrives in the correct order.
      const delays = {};
      delays[audioSegment1Uri] = new shaka.util.PublicPromise();
      delays[audioSegment2Uri] = new shaka.util.PublicPromise();
      delays[audioSegment3Uri] = new shaka.util.PublicPromise();
      delays[audioSegment4Uri] = new shaka.util.PublicPromise();
      delays[videoSegment1Uri] = new shaka.util.PublicPromise();
      delays[videoSegment2Uri] = new shaka.util.PublicPromise();
      delays[videoSegment3Uri] = new shaka.util.PublicPromise();
      delays[videoSegment4Uri] = new shaka.util.PublicPromise();

      /**
       * Since the promise chains will be built so that each stream can be
       * downloaded in parallel, we can force the network requests to
       * resolve in lock-step (audio seg 0, video seg 0, audio seg 1,
       * video seg 1, ...).
       *
       * @param {string} segment A URI
       * @param {?string} dependingOn Another URI, or null
       */
      function setResponseFor(segment, dependingOn) {
        fakeResponses[segment] = async () => {
          if (dependingOn) {
            await delays[dependingOn];
          }

          // Tell anyone waiting on |segment| that they are clear to execute
          // now.
          delays[segment].resolve();
          return new ArrayBuffer(16);
        };
      }
      fakeResponses = {};
      setResponseFor(audioSegment1Uri, null);
      setResponseFor(audioSegment2Uri, videoSegment1Uri);
      setResponseFor(audioSegment3Uri, videoSegment2Uri);
      setResponseFor(audioSegment4Uri, videoSegment3Uri);
      setResponseFor(videoSegment1Uri, audioSegment1Uri);
      setResponseFor(videoSegment2Uri, audioSegment2Uri);
      setResponseFor(videoSegment3Uri, audioSegment3Uri);
      setResponseFor(videoSegment4Uri, audioSegment4Uri);
    });

    afterEach(async () => {
      await storage.destroy();
    });

    afterAll(() => {
      compiledShaka.net.NetworkingEngine.unregisterScheme('fake');
    });

    it('uses stream bandwidth', async () => {
      /**
       * These numbers are the overall progress based on the segment sizes
       * per stream. We assume a specific download order for the content
       * based on the order of the streams and segments.
       *
       * Since the audio stream has smaller segments, its contribution to
       * the overall progress is much smaller than the video stream segments.
       *
       * @type {!Array.<number>}
       */
      const progressSteps = [
        0.057, 0.250, 0.307, 0.500, 0.557, 0.750, 0.807, 1.000,
      ];
      const manifest = makeWithStreamBandwidth();
      await runProgressTest(manifest, progressSteps);
    });

    it('uses variant bandwidth when stream bandwidth is unavailable',
        async () => {
          /**
           * These numbers are the overall progress based on the segment sizes
           * per stream. We assume a specific download order for the content
           * based on the order of the streams and segments.
           *
           * Since we do not have per-stream bandwidth, the amount each
           * influences the overall progress is based on the stream type,
           * storage's default bandwidth assumptions, and the variant's
           * bandwidth.
           *
           * In this example we see a larger difference between the audio and
           * video contributions to progress.
           *
           * @type {!Array.<number>}
           */
          const progressSteps = [
            0.241, 0.250, 0.491, 0.500, 0.741, 0.750, 0.991, 1.000,
          ];
          const manifest = makeWithVariantBandwidth();
          await runProgressTest(manifest, progressSteps);
        });

    /**
     * Download |manifest| and make sure that the reported progress matches
     * |expectedProgressSteps|.
     *
     * @param {shaka.extern.Manifest} manifest
     * @param {!Array.<number>} expectedProgressSteps
     */
    async function runProgressTest(manifest, expectedProgressSteps) {
      /**
       * Create a copy of the array so that we are not modifying the original
       * while we are tracking progress.
       *
       * @type {!Array.<number>}
       */
      const remainingProgress = expectedProgressSteps.slice();

      const progressCallback = (content, progress) => {
        expect(progress).toBeCloseTo(remainingProgress.shift());
      };

      storage.configure({
        offline: {
          progressCallback: progressCallback,
        },
      });
      compiledShaka.media.ManifestParser.registerParserByMime(
          fakeMimeType, () => new shaka.test.FakeManifestParser(manifest));

      // Store a manifest with bandwidth only for the variant (no per
      // stream bandwidth). This should result in a less accurate
      // progression of progress values as default values will be used.
      await storage.store('uri-wont-matter', noMetadata, fakeMimeType).promise;

      // We should have hit all the progress steps.
      expect(remainingProgress.length).toBe(0);
    }

    /**
     * Build a custom manifest for testing progress. Each segment will be
     * unique so that there will only be one request per segment uri (we
     * often reuse segments in our tests).
     *
     * This manifest will have the variant-level bandwidth value and per-stream
     * bandwidth values.
     *
     * @return {shaka.extern.Manifest}
     */
    function makeWithStreamBandwidth() {
      const manifest = shaka.test.ManifestGenerator.generate((manifest) => {
        manifest.presentationTimeline.setDuration(20);
        manifest.addVariant(0, (variant) => {
          variant.language = englishUS;
          variant.bandwidth = kbps(13);
          variant.addVideo(1, (stream) => {
            stream.bandwidth = kbps(10);
            stream.size(100, 200);
          });
          variant.addAudio(2, (stream) => {
            stream.language = englishUS;
            stream.bandwidth = kbps(3);
          });
        });
      }, compiledShaka);

      const audio = manifest.variants[0].audio;
      goog.asserts.assert(audio, 'Created manifest with audio, where is it?');
      overrideSegmentIndex(audio, [
        makeReference(audioSegment1Uri, 0, 1, compiledShaka),
        makeReference(audioSegment2Uri, 1, 2, compiledShaka),
        makeReference(audioSegment3Uri, 2, 3, compiledShaka),
        makeReference(audioSegment4Uri, 3, 4, compiledShaka),
      ]);

      const video = manifest.variants[0].video;
      goog.asserts.assert(video, 'Created manifest with video, where is it?');
      overrideSegmentIndex(video, [
        makeReference(videoSegment1Uri, 0, 1, compiledShaka),
        makeReference(videoSegment2Uri, 1, 2, compiledShaka),
        makeReference(videoSegment3Uri, 2, 3, compiledShaka),
        makeReference(videoSegment4Uri, 3, 4, compiledShaka),
      ]);

      return manifest;
    }

    /**
     * Build a custom manifest for testing progress. Each segment will be
     * unique so that there will only be one request per segment uri (we
     * often reuse segments in our tests).
     *
     * This manifest will only have the variant-level bandwidth value.
     *
     * @return {shaka.extern.Manifest}
     */
    function makeWithVariantBandwidth() {
      // Start with the manifest that had per-stream bandwidths. Then remove
      // the per-stream values.
      const manifest = makeWithStreamBandwidth();
      goog.asserts.assert(
          manifest.variants.length == 1,
          'Expecting manifest to only have one variant');

      const variant = manifest.variants[0];
      goog.asserts.assert(
          variant.audio,
          'Expecting manifest to have audio stream');
      goog.asserts.assert(
          variant.video,
          'Expecting manigest to have video stream');

      // Remove the per stream bandwidth information.
      variant.audio.bandwidth = undefined;
      variant.video.bandwidth = undefined;

      return manifest;
    }
  });

  describe('basic function', () => {
    /**
     * Keep a reference to the networking engine so that we can interrupt
     * networking calls.
     *
     * @type {!shaka.test.FakeNetworkingEngine}
     */
    let netEngine;
    /** @type {!shaka.Player} */
    let player;
    /** @type {!shaka.offline.Storage} */
    let storage;
    /** @type {!shaka.util.EventManager} */
    let eventManager;
    /** @type {!HTMLVideoElement} */
    const videoElement = /** @type {!HTMLVideoElement} */(
      document.createElement('video'));

    beforeEach(() => {
      netEngine = makeNetworkEngine();

      // Use a real Player since Storage only uses the configuration and
      // networking engine.  This allows us to use Player.configure in these
      // tests.
      player = new shaka.Player(videoElement, ((player) => {
        player.createNetworkingEngine = () => netEngine;
      }));

      storage = new shaka.offline.Storage(player);

      eventManager = new shaka.util.EventManager();
    });

    afterEach(async () => {
      eventManager.release();
      await storage.destroy();
      await player.destroy();
    });

    it('stores and lists content', async () => {
      /** @type {!Array.<string>} */
      const manifestUris = [
        manifestWithPerStreamBandwidthUri,
        manifestWithoutPerStreamBandwidthUri,
        manifestWithNonZeroStartUri,
      ];

      // NOTE: We're working around an apparent compiler bug here, with Closure
      // version v20180402.  "Violation: Using properties of unknown types is
      // not allowed; add an explicit type to the variable.  The property "next"
      // on type "Iterator<?>".
      for (let i = 0; i < manifestUris.length; ++i) {
        const uri = manifestUris[i];
        // eslint-disable-next-line no-await-in-loop
        await storage.store(uri, noMetadata, fakeMimeType).promise;
      }

      const content = await storage.list();
      const originalUris = content.map((c) => c.originalManifestUri);
      expect(originalUris.length).toBe(manifestUris.length);

      // NOTE: We're working around an apparent compiler bug here.  See comment
      // above.
      for (let i = 0; i < manifestUris.length; ++i) {
        const uri = manifestUris[i];
        expect(originalUris).toContain(uri);
      }
    });

    it('snapshots config when store is called', async () => {
      /** @type {!jasmine.Spy} */
      const selectTracksOne =
          jasmine.createSpy('selectTracksOne').and.callFake((tracks) => tracks);
      /** @type {!jasmine.Spy} */
      const selectTracksTwo =
          jasmine.createSpy('selectTracksTwo').and.callFake((tracks) => tracks);
      /** @type {!jasmine.Spy} */
      const selectTracksBad =
          jasmine.createSpy('selectTracksBad').and.callFake((tracks) => []);

      storage.configure('offline.trackSelectionCallback', selectTracksOne);
      const storeOne = storage.store(
          manifestWithPerStreamBandwidthUri, noMetadata, fakeMimeType);
      storage.configure('offline.trackSelectionCallback', selectTracksTwo);
      const storeTwo = storage.store(
          manifestWithPerStreamBandwidthUri, noMetadata, fakeMimeType);
      storage.configure('offline.trackSelectionCallback', selectTracksBad);
      await Promise.all([storeOne.promise, storeTwo.promise]);

      expect(selectTracksOne).toHaveBeenCalled();
      expect(selectTracksTwo).toHaveBeenCalled();
      expect(selectTracksBad).not.toHaveBeenCalled();
    });

    it('only stores chosen tracks', async () => {
      // Change storage to only store one track so that it will be easy
      // for us to ensure that only the one track was stored.
      const selectTracks = (tracks) => {
        const selected = tracks.filter((t) => t.language == frenchCanadian);
        expect(selected.length).toBe(1);
        return selected;
      };
      storage.configure({
        offline: {
          trackSelectionCallback: selectTracks,
        },
      });

      const stored = await storage.store(
          manifestWithPerStreamBandwidthUri, noMetadata, fakeMimeType).promise;
      goog.asserts.assert(stored.offlineUri != null, 'URI should not be null!');
      expect(stored.tracks.length).toBe(1);
      expect(stored.tracks[0].language).toBe(frenchCanadian);

      // Pull the manifest out of storage so that we can ensure that it only
      // has one variant.
      /** @type {shaka.offline.OfflineUri} */
      const uri = shaka.offline.OfflineUri.parse(stored.offlineUri);

      /** @type {!shaka.offline.StorageMuxer} */
      const muxer = new shaka.offline.StorageMuxer();

      try {
        await muxer.init();
        const cell = await muxer.getCell(uri.mechanism(), uri.cell());
        const manifests = await cell.getManifests([uri.key()]);
        expect(manifests.length).toBe(1);

        const manifest = manifests[0];
        // There should be 2 streams, an audio and a video stream.
        expect(manifest.streams.length).toBe(2);

        const audio = manifest.streams.filter(
            (s) => s.type == 'audio')[0];
        expect(audio.language).toBe(frenchCanadian);
      } finally {
        await muxer.destroy();
      }
    });

    it('can choose tracks asynchronously', async () => {
      storage.configure({
        offline: {
          trackSelectionCallback: async (tracks) => {
            await Util.delay(0.1);
            const selected = tracks.filter((t) => t.language == frenchCanadian);
            expect(selected.length).toBe(1);
            return selected;
          },
        },
      });

      const stored = await storage.store(
          manifestWithPerStreamBandwidthUri, noMetadata, fakeMimeType).promise;
      expect(stored.tracks.length).toBe(1);
      expect(stored.tracks[0].language).toBe(frenchCanadian);
    });

    it('stores drm info without license', async () => {
      const drmInfo = makeDrmInfo();
      const session1 = 'session-1';
      const session2 = 'session-2';
      const expiration = 1000;

      // TODO(vaage): Is there a way we can set the session ids without needing
      //               to overload an internal call in storage.
      const drm = new shaka.test.FakeDrmEngine();
      drm.setDrmInfo(drmInfo);
      drm.setSessionIds([session1, session2]);
      drm.getExpiration.and.returnValue(expiration);

      overrideDrmAndManifest(
          storage,
          drm,
          makeManifestWithPerStreamBandwidth());

      const stored = await storage.store(
          manifestWithPerStreamBandwidthUri, noMetadata, fakeMimeType).promise;
      goog.asserts.assert(stored.offlineUri != null, 'URI should not be null!');

      /** @type {shaka.offline.OfflineUri} */
      const uri = shaka.offline.OfflineUri.parse(stored.offlineUri);
      expect(uri).toBeTruthy();

      /** @type {!shaka.offline.StorageMuxer} */
      const muxer = new shaka.offline.StorageMuxer();

      try {
        await muxer.init();
        const cell = await muxer.getCell(uri.mechanism(), uri.cell());
        const manifests = await cell.getManifests([uri.key()]);
        const manifest = manifests[0];
        expect(manifest).toBeTruthy();

        expect(manifest.drmInfo).toEqual(drmInfo);

        expect(manifest.expiration).toBe(expiration);

        expect(manifest.sessionIds).toBeTruthy();
        expect(manifest.sessionIds.length).toBe(2);
        expect(manifest.sessionIds).toContain(session1);
        expect(manifest.sessionIds).toContain(session2);
      } finally {
        await muxer.destroy();
      }
    });

    it('can extract DRM info from segments', async () => {
      const pssh1 =
          '00000028' +                          // atom size
          '70737368' +                          // atom type='pssh'
          '00000000' +                          // v0, flags=0
          'edef8ba979d64acea3c827dcd51d21ed' +  // system id (Widevine)
          '00000008' +                          // data size
          '0102030405060708';                   // data
      const psshData1 = shaka.util.Uint8ArrayUtils.fromHex(pssh1);
      const pssh2 =
          '00000028' +                          // atom size
          '70737368' +                          // atom type='pssh'
          '00000000' +                          // v0, flags=0
          'edef8ba979d64acea3c827dcd51d21ed' +  // system id (Widevine)
          '00000008' +                          // data size
          '1337420123456789';                   // data
      const psshData2 = shaka.util.Uint8ArrayUtils.fromHex(pssh2);
      netEngine.setResponseValue(initSegmentUri,
          shaka.util.BufferUtils.toArrayBuffer(psshData1));
      netEngine.setResponseValue(alternateInitSegmentUri,
          shaka.util.BufferUtils.toArrayBuffer(psshData2));

      const drm = new shaka.test.FakeDrmEngine();
      const drmInfo = makeDrmInfo();
      drmInfo.keySystem = 'com.widevine.alpha';
      drm.setDrmInfo(drmInfo);
      overrideDrmAndManifest(
          storage,
          drm,
          makeManifestWithVideoInitSegments());

      const stored = await storage.store(
          manifestWithVideoInitSegmentsUri, noMetadata, fakeMimeType).promise;
      goog.asserts.assert(stored.offlineUri != null, 'URI should not be null!');

      // The manifest chooses the alternate stream, so expect only the alt init
      // segment.
      expect(drm.newInitData).toHaveBeenCalledWith('cenc', psshData2);
    });

    it('can store multiple assets at once', async () => {
      // Block the network so that we won't finish the first store command.
      /** @type {!shaka.util.PublicPromise} */
      const hangingPromise = netEngine.delayNextRequest();
      /** @type {!shaka.extern.IAbortableOperation} */
      const storeOperation = storage.store(
          manifestWithPerStreamBandwidthUri, noMetadata, fakeMimeType);

      // Critical: This manifest should have different segment URIs than the one
      // above, or else the blocked network request would be shared between the
      // two storage operations.
      const secondStorePromise = storage.store(
          manifestWithAlternateSegmentsUri, noMetadata, fakeMimeType);
      await secondStorePromise.promise;

      // Unblock the original store and wait for it to complete.
      hangingPromise.resolve();
      await storeOperation.promise;
    });

    // Make sure that when we configure storage to NOT store persistent
    // licenses that we don't store the sessions.
    it('stores drm info with no license', async () => {
      const drmInfo = makeDrmInfo();
      const session1 = 'session-1';
      const session2 = 'session-2';

      // TODO(vaage): Is there a way we can set the session ids without
      //              needing to overload an internal call in storage.
      const drm = new shaka.test.FakeDrmEngine();
      drm.setDrmInfo(drmInfo);
      drm.setSessionIds([session1, session2]);

      overrideDrmAndManifest(
          storage,
          drm,
          makeManifestWithPerStreamBandwidth());
      storage.configure('offline.usePersistentLicense', false);

      const stored = await storage.store(
          manifestWithPerStreamBandwidthUri, noMetadata, fakeMimeType).promise;
      goog.asserts.assert(stored.offlineUri != null, 'URI should not be null!');

      /** @type {shaka.offline.OfflineUri} */
      const uri = shaka.offline.OfflineUri.parse(stored.offlineUri);
      expect(uri).toBeTruthy();

      /** @type {!shaka.offline.StorageMuxer} */
      const muxer = new shaka.offline.StorageMuxer();

      try {
        await muxer.init();
        const cell = await muxer.getCell(uri.mechanism(), uri.cell());
        const manifests = await cell.getManifests([uri.key()]);
        const manifest = manifests[0];
        expect(manifest).toBeTruthy();

        expect(manifest.drmInfo).toEqual(drmInfo);

        // When there is no expiration, the expiration is set to Infinity.
        expect(manifest.expiration).toBe(Infinity);

        expect(manifest.sessionIds).toBeTruthy();
        expect(manifest.sessionIds.length).toBe(0);
      } finally {
        await muxer.destroy();
      }
    });

    it('throws an error if the content is a live stream', async () => {
      const expected = Util.jasmineError(new shaka.util.Error(
          shaka.util.Error.Severity.CRITICAL,
          shaka.util.Error.Category.STORAGE,
          shaka.util.Error.Code.CANNOT_STORE_LIVE_OFFLINE,
          manifestWithLiveTimelineUri));
      const storeOperation =
          storage.store(manifestWithLiveTimelineUri, noMetadata, fakeMimeType);
      await expectAsync(storeOperation.promise).toBeRejectedWith(expected);
    });

    it('throws an error if destroyed mid-store', async () => {
      const manifest = makeManifestWithPerStreamBandwidth();

      /**
       * Block storage when it goes to parse the manifest. Since we don't want
       * to change the flow, return a valid manifest once it resolves.
       * @type {shaka.util.PublicPromise}
       */
      const stallStorage = new shaka.util.PublicPromise();
      storage.parseManifest = async () => {
        await stallStorage;
        return manifest;
      };

      // The uri won't matter much, as we have overriden |parseManifest|.
      /** @type {!shaka.extern.IAbortableOperation} */
      const waitOnStore = storage.store('any-uri', noMetadata, fakeMimeType);

      // Request for storage to be destroyed. Before waiting for it to resolve,
      // resolve the promise that we are using to stall the store operation.
      const waitOnDestroy = storage.destroy();
      stallStorage.resolve();
      await waitOnDestroy;

      // The store request should not resolve, but instead be rejected.
      const expected = Util.jasmineError(new shaka.util.Error(
          shaka.util.Error.Severity.CRITICAL,
          shaka.util.Error.Category.STORAGE,
          shaka.util.Error.Code.OPERATION_ABORTED));
      await expectAsync(waitOnStore.promise).toBeRejectedWith(expected);
    });

    it('cancels downloads if destroyed mid-store', async () => {
      await networkCancelTest((abortable) => {
        return storage.destroy();
      });
    });

    it('cancels downloads if canceled mid-store', async () => {
      await networkCancelTest((abortable) => {
        return abortable.abort();
      });
    });

    /**
     * @param {function(shaka.extern.IAbortableOperation):!Promise} interruption
     */
    async function networkCancelTest(interruption) {
      const delays = [];
      /** @type {!shaka.util.PublicPromise} */
      const aRequestIsStarted = new shaka.util.PublicPromise();

      // Set delays for the URIs of the manifest.
      const uris = [segment1Uri, segment2Uri, segment3Uri, segment4Uri];
      for (let i = 0; i < uris.length; i++) {
        const promise = new shaka.util.PublicPromise();
        delays.push(promise);

        // The fake networking engine provides a "abortCheck" callback to the
        // response, so that you can check whether or not the network operation
        // has been aborted.
        netEngine.setResponse(uris[i], async (abortCheck) => {
          aRequestIsStarted.resolve();
          await promise;

          // All downloads for a given stream are in the same "download group",
          // and will be downloaded sequentially. Thus, we expect only the first
          // download to be aborted.
          expect(abortCheck()).toBe(i == 0 ? true : false);

          return new ArrayBuffer(16);
        });
      }

      /** @type {!shaka.extern.IAbortableOperation} */
      const storeOperation = storage.store(
          manifestWithPerStreamBandwidthUri, noMetadata, fakeMimeType);
      await aRequestIsStarted;
      const interruptionPromise = interruption(storeOperation);
      for (const promise of delays) {
        promise.resolve();
      }
      await interruptionPromise;

      const expected = Util.jasmineError(new shaka.util.Error(
          shaka.util.Error.Severity.CRITICAL,
          shaka.util.Error.Category.STORAGE,
          shaka.util.Error.Code.OPERATION_ABORTED));
      await expectAsync(storeOperation.promise).toBeRejectedWith(expected);
    }

    it('stops for networking errors', async () => {
      // Force all network requests to fail.
      const error = new shaka.util.Error(
          shaka.util.Error.Severity.CRITICAL, shaka.util.Error.Category.NETWORK,
          shaka.util.Error.Code.HTTP_ERROR);
      netEngine.request.and.callFake(() => {
        return shaka.util.AbortableOperation.failed(error);
      });

      const storeOperation = storage.store(
          manifestWithPerStreamBandwidthUri, noMetadata, fakeMimeType);
      await expectAsync(storeOperation.promise)
          .toBeRejectedWith(Util.jasmineError(error));
    });

    it('throws an error if removing malformed uri', async () => {
      const badUri = 'this-is-an-invalid-uri';
      const expected = Util.jasmineError(new shaka.util.Error(
          shaka.util.Error.Severity.CRITICAL,
          shaka.util.Error.Category.STORAGE,
          shaka.util.Error.Code.MALFORMED_OFFLINE_URI,
          badUri));
      await expectAsync(storage.remove(badUri)).toBeRejectedWith(expected);
    });

    it('throws an error if removing missing manifest', async () => {
      // Store a piece of content, but then change the uri slightly so that
      // it won't be found when we try to remove it (with the wrong uri).
      const stored = await storage.store(
          manifestWithPerStreamBandwidthUri, noMetadata, fakeMimeType).promise;
      goog.asserts.assert(stored.offlineUri != null, 'URI should not be null!');
      const storedUri = shaka.offline.OfflineUri.parse(stored.offlineUri);
      const missingManifestUri = shaka.offline.OfflineUri.manifest(
          storedUri.mechanism(), storedUri.cell(), storedUri.key() + 1);

      const expected = Util.jasmineError(new shaka.util.Error(
          shaka.util.Error.Severity.CRITICAL,
          shaka.util.Error.Category.STORAGE,
          shaka.util.Error.Code.KEY_NOT_FOUND,
          jasmine.any(String)));
      await expectAsync(storage.remove(missingManifestUri.toString()))
          .toBeRejectedWith(expected);
    });

    it('removes manifest', async () => {
      const stored = await storage.store(
          manifestWithPerStreamBandwidthUri, noMetadata, fakeMimeType).promise;
      goog.asserts.assert(stored.offlineUri != null, 'URI should not be null!');
      await storage.remove(stored.offlineUri);
    });

    it('removes manifest with missing segments', async () => {
      const stored = await storage.store(
          manifestWithPerStreamBandwidthUri, noMetadata, fakeMimeType).promise;
      goog.asserts.assert(stored.offlineUri != null, 'URI should not be null!');

      /** @type {shaka.offline.OfflineUri} */
      const uri = shaka.offline.OfflineUri.parse(stored.offlineUri);
      expect(uri).toBeTruthy();

      /** @type {!shaka.offline.StorageMuxer} */
      const muxer = new shaka.offline.StorageMuxer();

      try {
        await muxer.init();
        const cell = await muxer.getCell(uri.mechanism(), uri.cell());
        const manifests = await cell.getManifests([uri.key()]);
        const manifest = manifests[0];

        // Get the stream from the manifest. The segment count is based on how
        // we created manifest in the "make*Manifest" functions.
        const stream = manifest.streams[0];
        expect(stream).toBeTruthy();
        expect(stream.segments.length).toBe(4);

        // Remove all the segments so that all segments will be missing.
        // There should be way more than one segment.
        const keys = stream.segments.map((segment) => segment.dataKey);
        expect(keys.length).toBeGreaterThan(0);

        const noop = () => {};
        await cell.removeSegments(keys, noop);
      } finally {
        await muxer.destroy();
      }

      await storage.remove(uri.toString());
    });

    it('tracks progress on remove', async () => {
      const selectOneTrack = (tracks) => {
        const allVariants = tracks.filter((t) => {
          return t.type == 'variant';
        });
        expect(allVariants).toBeTruthy();
        expect(allVariants.length).toBeGreaterThan(0);

        const frenchVariants = allVariants.filter((t) => {
          return t.language == frenchCanadian;
        });
        expect(frenchVariants).toBeTruthy();
        expect(frenchVariants.length).toBe(1);

        return frenchVariants;
      };

      // Store a manifest with one track. We are using only one track so that it
      // will be easier to understand the progress values.
      storage.configure({
        offline: {
          trackSelectionCallback: selectOneTrack,
        },
      });
      const content = await storage.store(
          manifestWithPerStreamBandwidthUri, noMetadata, fakeMimeType).promise;
      goog.asserts.assert(
          content.offlineUri != null, 'URI should not be null!');

      // We expect 5 progress events because there are 4 unique segments, plus
      // the manifest.
      /** @type {!Array.<number>}*/
      const progressSteps = [
        0.2, 0.4, 0.6, 0.8, 1,
      ];

      const progressCallback = (content, progress) => {
        expect(progress).toBeCloseTo(progressSteps.shift());
      };

      storage.configure({
        offline: {
          progressCallback: progressCallback,
        },
      });

      await storage.remove(content.offlineUri);
      expect(progressSteps).toBeTruthy();
      expect(progressSteps.length).toBe(0);
    });
  });

  describe('storage without player', () => {
    const testSchemeMimeType = 'application/x-test-manifest';
    const manifestUri = 'test:sintel';

    it('stores content', async () => {
      /** @type {shaka.offline.Storage} */
      const storage = new shaka.offline.Storage();
      try {
        await storage.store(
            manifestUri, noMetadata, testSchemeMimeType).promise;
      } finally {
        await storage.destroy();
      }
    });
  });

  describe('deduplication', () => {
    const testSchemeMimeType = 'application/x-test-manifest';
    const manifestUri = 'test:sintel';

    // Regression test for https://github.com/google/shaka-player/issues/2781
    it('does not cache failures or cancellations', async () => {
      /** @type {shaka.offline.Storage} */
      const storage = new shaka.offline.Storage();

      try {
        storage.getNetworkingEngine().registerRequestFilter(
            (type, request) => {
              if (type == shaka.net.NetworkingEngine.RequestType.SEGMENT) {
                throw new Error('Break download!');
              }
            });

        const firstOperation = storage.store(
            manifestUri, noMetadata, testSchemeMimeType);
        // We killed the operation with a network failure, so this should be
        // rejected.
        await expectAsync(firstOperation.promise).toBeRejected();

        // Clear the filter that caused the error.
        storage.getNetworkingEngine().clearAllRequestFilters();

        // Now we can try again, and it should be able to succeed, even though
        // some downloads for the same URIs failed in the first attempt.  In
        // #2781, this would fail because the network failure was cached.
        const secondOperation = storage.store(
            manifestUri, noMetadata, testSchemeMimeType);
        await expectAsync(secondOperation.promise).toBeResolved();
      } finally {
        await storage.destroy();
      }
    });
  });

  /**
   * @param {number} id
   * @param {number} height
   * @param {string} language
   * @param {number} bandwidth
   * @return {shaka.extern.Track}
   */
  function variantTrack(id, height, language, bandwidth) {
    const videoId = id * 2;
    const audioId = id * 2 + 1;
    return {
      id: id,
      active: false,
      type: 'variant',
      bandwidth: bandwidth,
      language: language,
      label: null,
      kind: null,
      width: height * (16 / 9),
      height: height,
      frameRate: 30,
      pixelAspectRatio: '59:54',
      hdr: null,
      mimeType: 'video/mp4,audio/mp4',
      audioMimeType: 'audio/mp4',
      videoMimeType: 'video/mp4',
      codecs: 'mp4,mp4',
      audioCodec: 'mp4',
      videoCodec: 'mp4',
      primary: false,
      roles: [],
      audioRoles: [],
      forced: false,
      videoId: videoId,
      audioId: audioId,
      channelsCount: 2,
      audioSamplingRate: 48000,
      spatialAudio: false,
      tilesLayout: null,
      audioBandwidth: bandwidth * 0.33,
      videoBandwidth: bandwidth * 0.67,
      originalVideoId: videoId.toString(),
      originalAudioId: audioId.toString(),
      originalTextId: null,
      originalImageId: null,
    };
  }

  /**
   * @param {number} id
   * @param {string} language
   * @return {shaka.extern.Track}
   */
  function textTrack(id, language) {
    return {
      id: id,
      active: false,
      type: 'text',
      bandwidth: 1000,
      language: language,
      label: null,
      kind: null,
      width: null,
      height: null,
      frameRate: null,
      pixelAspectRatio: null,
      hdr: null,
      mimeType: 'text/vtt',
      audioMimeType: null,
      videoMimeType: null,
      codecs: 'vtt',
      audioCodec: null,
      videoCodec: null,
      primary: false,
      roles: [],
      audioRoles: null,
      forced: false,
      videoId: null,
      audioId: null,
      channelsCount: null,
      audioSamplingRate: null,
      spatialAudio: false,
      tilesLayout: null,
      audioBandwidth: null,
      videoBandwidth: null,
      originalVideoId: null,
      originalAudioId: null,
      originalTextId: id.toString(),
      originalImageId: null,
    };
  }

  /** @return {shaka.extern.Manifest} */
  function makeManifestWithVideoInitSegments() {
    const manifest = shaka.test.ManifestGenerator.generate((manifest) => {
      manifest.presentationTimeline.setDuration(20);

      manifest.addVariant(0, (variant) => {
        variant.bandwidth = kbps(13);
        variant.addVideo(1, (stream) => {
          stream.bandwidth = kbps(13);
          stream.size(100, 200);
        });
      });
      manifest.addVariant(2, (variant) => {
        variant.bandwidth = kbps(20);
        variant.addVideo(3, (stream) => {
          stream.bandwidth = kbps(20);
          stream.size(200, 400);
        });
      });
    });

    const stream = manifest.variants[0].video;
    goog.asserts.assert(stream, 'The first stream should exist');
    stream.encrypted = true;
    const init = new shaka.media.InitSegmentReference(
        () => [initSegmentUri], 0, null);
    const refs = [
      makeReference(segment1Uri, 0, 1),
      makeReference(segment2Uri, 1, 2),
      makeReference(segment3Uri, 2, 3),
      makeReference(segment4Uri, 3, 4),
    ];
    for (const ref of refs) {
      ref.initSegmentReference = init;
    }
    overrideSegmentIndex(stream, refs);

    const streamAlt = manifest.variants[1].video;
    goog.asserts.assert(streamAlt, 'The second stream should exist');
    streamAlt.encrypted = true;
    const initAlt = new shaka.media.InitSegmentReference(
        () => [alternateInitSegmentUri], 0, null);
    const refsAlt = [
      makeReference(alternateSegment1Uri, 0, 1),
      makeReference(alternateSegment2Uri, 1, 2),
      makeReference(alternateSegment3Uri, 2, 3),
      makeReference(alternateSegment4Uri, 3, 4),
    ];
    for (const ref of refsAlt) {
      ref.initSegmentReference = initAlt;
    }
    overrideSegmentIndex(streamAlt, refsAlt);

    return manifest;
  }

  /** @return {shaka.extern.Manifest} */
  function makeManifestWithPerStreamBandwidth() {
    const manifest = shaka.test.ManifestGenerator.generate((manifest) => {
      manifest.presentationTimeline.setDuration(20);

      manifest.addVariant(0, (variant) => {
        variant.language = englishUS;
        variant.bandwidth = kbps(13);
        variant.addVideo(1, (stream) => {
          stream.bandwidth = kbps(10);
          stream.size(100, 200);
        });
        variant.addAudio(2, (stream) => {
          stream.language = englishUS;
          stream.bandwidth = kbps(3);
        });
      });
      manifest.addVariant(3, (variant) => {
        variant.language = frenchCanadian;
        variant.bandwidth = kbps(13);
        variant.addVideo(4, (stream) => {
          stream.bandwidth = kbps(10);
          stream.size(100, 200);
        });
        variant.addAudio(5, (stream) => {
          stream.language = frenchCanadian;
          stream.bandwidth = kbps(3);
        });
      });
    });

    for (const stream of getAllStreams(manifest)) {
      // Make a new copy each time, as the segment index can modify each
      // reference.
      const refs = [
        makeReference(segment1Uri, 0, 1),
        makeReference(segment2Uri, 1, 2),
        makeReference(segment3Uri, 2, 3),
        makeReference(segment4Uri, 3, 4),
      ];

      overrideSegmentIndex(stream, refs);
    }

    return manifest;
  }

  /**
   * @return {shaka.extern.Manifest}
   */
  function makeManifestWithoutPerStreamBandwidth() {
    const manifest = makeManifestWithPerStreamBandwidth();

    // Remove the per stream bandwidth.
    for (const stream of getAllStreams(manifest)) {
      stream.bandwidth = undefined;
    }

    return manifest;
  }

  /**
   * @return {shaka.extern.Manifest}
   */
  function makeManifestWithNonZeroStart() {
    const manifest = makeManifestWithPerStreamBandwidth();

    for (const stream of getAllStreams(manifest)) {
      const refs = [
        makeReference(segment1Uri, 10, 11),
        makeReference(segment2Uri, 11, 12),
        makeReference(segment3Uri, 12, 13),
        makeReference(segment4Uri, 13, 14),
      ];

      overrideSegmentIndex(stream, refs);
    }

    return manifest;
  }

  /**
   * @return {shaka.extern.Manifest}
   */
  function makeManifestWithLiveTimeline() {
    const manifest = makeManifestWithPerStreamBandwidth();
    manifest.presentationTimeline.setDuration(Infinity);
    manifest.presentationTimeline.setStatic(false);
    return manifest;
  }

  /**
   * @return {shaka.extern.Manifest}
   */
  function makeManifestWithAlternateSegments() {
    const manifest = makeManifestWithPerStreamBandwidth();

    for (const stream of getAllStreams(manifest)) {
      const refs = [
        makeReference(alternateSegment1Uri, 10, 11),
        makeReference(alternateSegment2Uri, 11, 12),
        makeReference(alternateSegment3Uri, 12, 13),
        makeReference(alternateSegment4Uri, 13, 14),
      ];

      overrideSegmentIndex(stream, refs);
    }

    return manifest;
  }

  /**
   * @param {shaka.extern.Manifest} manifest
   * @return {!Array.<shaka.extern.Stream>}
   */
  function getAllStreams(manifest) {
    const streams = [];

    for (const variant of manifest.variants) {
      if (variant.audio) {
        streams.push(variant.audio);
      }
      if (variant.video) {
        streams.push(variant.video);
      }
    }
    for (const stream of manifest.textStreams) {
      streams.push(stream);
    }

    return streams;
  }

  /**
   * @param {shaka.extern.Stream} stream
   * @param {!Array.<shaka.media.SegmentReference>} segments
   */
  function overrideSegmentIndex(stream, segments) {
    const index = new shaka.media.SegmentIndex(segments);
    stream.createSegmentIndex = () => Promise.resolve();
    stream.segmentIndex = index;
  }

  /** @return {!shaka.test.FakeNetworkingEngine} */
  function makeNetworkEngine() {
    return new shaka.test.FakeNetworkingEngine()
        .setResponseValue(segment1Uri, new ArrayBuffer(16))
        .setResponseValue(segment2Uri, new ArrayBuffer(16))
        .setResponseValue(segment3Uri, new ArrayBuffer(16))
        .setResponseValue(segment4Uri, new ArrayBuffer(16))
        .setResponseValue(alternateSegment1Uri, new ArrayBuffer(16))
        .setResponseValue(alternateSegment2Uri, new ArrayBuffer(16))
        .setResponseValue(alternateSegment3Uri, new ArrayBuffer(16))
        .setResponseValue(alternateSegment4Uri, new ArrayBuffer(16));
  }

  async function eraseStorage() {
    /** @type {!shaka.offline.StorageMuxer} */
    const muxer = new shaka.offline.StorageMuxer();

    try {
      await muxer.erase();
    } finally {
      await muxer.destroy();
    }
  }

  /**
   * @param {!shaka.offline.Storage} storage
   * @param {!shaka.media.DrmEngine} drm
   * @param {shaka.extern.Manifest} manifest
   */
  function overrideDrmAndManifest(storage, drm, manifest) {
    storage.parseManifest = () => Promise.resolve(manifest);
    storage.createDrmEngine = () => Promise.resolve(drm);
  }

  /**
   * @return {shaka.extern.DrmInfo}
   */
  function makeDrmInfo() {
    const drmInfo = {
      keySystem: 'com.example.abc',
      licenseServerUri: 'http://example.com',
      persistentStateRequired: true,
      distinctiveIdentifierRequired: false,
      initData: null,
      keyIds: null,
      sessionType: 'temporary',
      serverCertificate: null,
      serverCertificateUri: '',
      audioRobustness: 'HARDY',
      videoRobustness: 'OTHER',
    };

    return drmInfo;
  }

  // TODO(vaage): Replace this with |shaka.test.FakeManifestParser|
  /** @implements {shaka.extern.ManifestParser} */
  const FakeManifestParser = class {
    constructor() {
      this.map_ = {};
      this.map_[manifestWithPerStreamBandwidthUri] =
          makeManifestWithPerStreamBandwidth();
      this.map_[manifestWithoutPerStreamBandwidthUri] =
          makeManifestWithoutPerStreamBandwidth();
      this.map_[manifestWithNonZeroStartUri] =
          makeManifestWithNonZeroStart();
      this.map_[manifestWithLiveTimelineUri] =
          makeManifestWithLiveTimeline();
      this.map_[manifestWithAlternateSegmentsUri] =
          makeManifestWithAlternateSegments();
      this.map_[manifestWithVideoInitSegmentsUri] =
          makeManifestWithVideoInitSegments();
    }

    /** @override */
    configure(params) {}

    /** @override */
    start(uri, player) {
      return Promise.resolve(this.map_[uri]);
    }

    /** @override */
    stop() {
      return Promise.resolve();
    }

    /** @override */
    update() {}

    /** @override */
    onExpirationUpdated(session, number) {}
  };

  /**
   * @param {!shaka.media.DrmEngine} drmEngine
   * @param {string} sessionName
   * @return {!Promise.<MediaKeySession>}
   *
   * @suppress {accessControls}
   */
  function loadOfflineSession(drmEngine, sessionName) {
    return drmEngine.loadOfflineSession_(sessionName);
  }

  /**
   * @param {!shaka.offline.OfflineUri} uri
   * @return {!Promise.<shaka.extern.Manifest>}
   */
  async function getStoredManifest(uri) {
    /** @type {!shaka.offline.ManifestConverter} */
    const converter = new shaka.offline.ManifestConverter(
        uri.mechanism(), uri.cell());

    /** @type {!shaka.offline.StorageMuxer} */
    const muxer = new shaka.offline.StorageMuxer();

    try {
      await muxer.init();
      const cell = await muxer.getCell(uri.mechanism(), uri.cell());
      const manifests = await cell.getManifests([uri.key()]);
      const manifest = manifests[0];

      goog.asserts.assert(manifest, 'A manifest should have been found');
      return converter.fromManifestDB(manifest);
    } finally {
      await muxer.destroy();
    }
  }

  /**
   * @param {!shaka.Player} player
   * @param {shaka.extern.Manifest} manifest
   * @param {function(!shaka.media.DrmEngine):Promise} action
   * @return {!Promise}
   */
  async function withDrm(player, manifest, action) {
    const net = player.getNetworkingEngine();
    goog.asserts.assert(net, 'Player should have a net engine right now');

    let error = null;

    /** @type {!shaka.media.DrmEngine} */
    const drm = new shaka.media.DrmEngine({
      netEngine: net,
      onError: (e) => { error = error || e; },
      onKeyStatus: () => {},
      onExpirationUpdated: () => {},
      onEvent: () => {},
    });

    try {
      drm.configure(player.getConfiguration().drm);
      const variants = manifest.variants;
      await drm.initForStorage(variants, /* usePersistentLicenses= */ true);
      await action(drm);
    } finally {
      await drm.destroy();
    }

    if (error) {
      throw error;
    }
  }

  /**
   * Creates a real SegmentReference.  This is distinct from the fake ones used
   * in ManifestParser tests because it can be on the left-hand side of an
   * expect().  You can't expect jasmine.any(Number) to equal
   * jasmine.any(Number).  :-(
   *
   * @param {string} uri
   * @param {number} startTime
   * @param {number} endTime
   * @param {shakaNamespaceType=} compiledShaka
   * @return {shaka.media.SegmentReference}
   */
  function makeReference(uri, startTime, endTime, compiledShaka) {
    /** @type {shakaNamespaceType} */
    const shaka = compiledShaka || window['shaka'];

    return new shaka.media.SegmentReference(
        startTime,
        endTime,
        /* getUris= */ () => [uri],
        /* startByte= */ 0,
        /* endByte= */ null,
        /* initSegmentReference= */ null,
        /* timestampOffset= */ 0,
        /* appendWindowStart= */ 0,
        /* appendWindowEnd= */ Infinity);
  }
});