shaka-player 3.2.2 → 3.3.2

package/test/media/region_observer_unit.js

@@ -15,6 +15,9 @@ describe('RegionObserver', () => {
   /** @type {!shaka.media.RegionObserver} */
   let observer;
 
+  /** @type {!jasmine.Spy} */
+  let onSeekRange;
+
   /** @type {!jasmine.Spy} */
   let onEnterRegion;
   /** @type {!jasmine.Spy} */
@@ -23,18 +26,26 @@ describe('RegionObserver', () => {
   let onSkipRegion;
 
   beforeEach(() => {
+    onSeekRange = jasmine.createSpy('onSeekRange');
+    onSeekRange.and.returnValue({start: 0, end: 100});
+
     onEnterRegion = jasmine.createSpy('onEnterRegion');
     onExitRegion = jasmine.createSpy('onExitRegion');
     onSkipRegion = jasmine.createSpy('onSkipRegion');
 
     timeline = new shaka.media.RegionTimeline(
-        () => { return {start: 0, end: 100}; });
+        shaka.test.Util.spyFunc(onSeekRange));
 
     observer = new shaka.media.RegionObserver(timeline);
-    observer.setListeners(
-        /* onEnter= */ shaka.test.Util.spyFunc(onEnterRegion),
-        /* onExit= */ shaka.test.Util.spyFunc(onExitRegion),
-        /* onSkip= */ shaka.test.Util.spyFunc(onSkipRegion));
+    observer.addEventListener('enter', (event) => {
+      shaka.test.Util.spyFunc(onEnterRegion)(event['region'], event['seeking']);
+    });
+    observer.addEventListener('exit', (event) => {
+      shaka.test.Util.spyFunc(onExitRegion)(event['region'], event['seeking']);
+    });
+    observer.addEventListener('skip', (event) => {
+      shaka.test.Util.spyFunc(onSkipRegion)(event['region'], event['seeking']);
+    });
   });
 
   it('fires enter event when adding a region the playhead is in', () => {
@@ -313,6 +324,30 @@ describe('RegionObserver', () => {
     expect(onSkipRegion).not.toHaveBeenCalled();
   });
 
+  // See https://github.com/google/shaka-player/issues/3949
+  it('cleans up references to regions', async () => {
+    const region = createRegion('my-region', 0, 10);
+    timeline.addRegion(region);
+
+    // Poll so that RegionObserver will store regions.
+    poll(observer,
+        /* timeInSeconds= */ 5,
+        /* seeking= */ false);
+
+    // Hack to get a private member without the compiler complaining:
+    /** @type {Map} */
+    const regionMap = (/** @type {?} */(observer))['oldPosition_'];
+    expect(regionMap.size).not.toBe(0);
+
+    // Move the seek range so that the region will be removed.
+    onSeekRange.and.returnValue({start: 20, end: 100});
+    // Give the timeline time to filter regions
+    await shaka.test.Util.delay(
+        shaka.media.RegionTimeline.REGION_FILTER_INTERVAL * 2);
+
+    expect(regionMap.size).toBe(0);
+  });
+
   /**
    * @param {string} id
    * @param {number} startTimeSeconds

package/test/media/region_timeline_unit.js

@@ -14,18 +14,27 @@ describe('RegionTimeline', () => {
   /** @type {!jasmine.Spy} */
   let onNewRegion;
 
+  /** @type {!jasmine.Spy} */
+  let onRemoveRegion;
+
   /** @type {!jasmine.Spy} */
   let onSeekRange;
 
   beforeEach(() => {
-    onNewRegion = jasmine.createSpy('onNewRegion');
-
     onSeekRange = jasmine.createSpy('onSeekRange');
     onSeekRange.and.returnValue({start: 0, end: 100});
-
     timeline = new shaka.media.RegionTimeline(
         shaka.test.Util.spyFunc(onSeekRange));
-    timeline.setListeners(shaka.test.Util.spyFunc(onNewRegion));
+
+    onNewRegion = jasmine.createSpy('onNewRegion');
+    timeline.addEventListener('regionadd', (event) => {
+      shaka.test.Util.spyFunc(onNewRegion)(event['region']);
+    });
+
+    onRemoveRegion = jasmine.createSpy('onRemoveRegion');
+    timeline.addEventListener('regionremove', (event) => {
+      shaka.test.Util.spyFunc(onRemoveRegion)(event['region']);
+    });
   });
 
   afterEach(() => {
@@ -85,24 +94,33 @@ describe('RegionTimeline', () => {
     ]);
   });
 
-  it('filters out regions that end before the start of the seek range',
-      async () => {
-        onSeekRange.and.returnValue({start: 5, end: 100});
-        const region1 = createRegion('urn:foo', 'my-region', 0, 3);
-        const region2 = createRegion('urn:foo', 'my-region', 3, 10);
-        const region3 = createRegion('urn:foo', 'my-region', 5, 10);
-        timeline.addRegion(region1);
-        timeline.addRegion(region2);
-        timeline.addRegion(region3);
-        expect(onNewRegion).toHaveBeenCalledTimes(3);
-        let regions = Array.from(timeline.regions());
-        expect(regions.length).toBe(3);
-        // Give the timeline time to filter regions
-        await shaka.test.Util.delay(
-            shaka.media.RegionTimeline.REGION_FILTER_INTERVAL * 2);
-        regions = Array.from(timeline.regions());
-        expect(regions).toEqual([region2, region3]);
-      });
+  it('filters regions that end before the seek range', async () => {
+    onSeekRange.and.returnValue({start: 5, end: 100});
+
+    const region1 = createRegion('urn:foo', 'my-region', 0, 3);
+    const region2 = createRegion('urn:foo', 'my-region', 3, 10);
+    const region3 = createRegion('urn:foo', 'my-region', 5, 10);
+
+    timeline.addRegion(region1);
+    timeline.addRegion(region2);
+    timeline.addRegion(region3);
+    expect(onNewRegion).toHaveBeenCalledTimes(3);
+    expect(onNewRegion).toHaveBeenCalledWith(region1);
+    expect(onNewRegion).toHaveBeenCalledWith(region2);
+    expect(onNewRegion).toHaveBeenCalledWith(region3);
+
+    let regions = Array.from(timeline.regions());
+    expect(regions.length).toBe(3);
+
+    // Give the timeline time to filter regions
+    await shaka.test.Util.delay(
+        shaka.media.RegionTimeline.REGION_FILTER_INTERVAL * 2);
+
+    regions = Array.from(timeline.regions());
+    expect(regions).toEqual([region2, region3]);
+
+    expect(onRemoveRegion).toHaveBeenCalledWith(region1);
+  });
 
   /**
    * @param {string} schemeIdUri

package/test/media/segment_reference_unit.js

@@ -38,14 +38,29 @@ describe('SegmentReference', () => {
 });
 
 describe('InitSegmentReference', () => {
+  const mediaQuality = {
+    bandwidth: 1,
+    audioSamplingRate: 444000,
+    codecs: 'my codec',
+    contentType: 'video',
+    frameRate: 30,
+    height: 720,
+    mimeType: 'mime type',
+    channelsCount: 2,
+    pixelAspectRatio: '1:1',
+    width: 1280,
+  };
+
   it('returns in getters values from constructor parameters', () => {
     const reference = new shaka.media.InitSegmentReference(
         /* getUris= */ () => ['x', 'y'],
         /* startByte= */ 4,
-        /* endByte= */ 5);
+        /* endByte= */ 5,
+        mediaQuality);
 
     expect(reference.getUris()).toEqual(['x', 'y']);
     expect(reference.getStartByte()).toBe(4);
     expect(reference.getEndByte()).toBe(5);
+    expect(reference.getMediaQuality()).toBe(mediaQuality);
   });
 });

package/test/media/streaming_engine_integration.js

@@ -60,7 +60,6 @@ describe('StreamingEngine', () => {
   /** @type {!shaka.media.StreamingEngine} */
   let streamingEngine;
 
-
   /** @type {shaka.extern.Variant} */
   let variant;
 
@@ -262,6 +261,7 @@ describe('StreamingEngine', () => {
 
   function createStreamingEngine() {
     const playerInterface = {
+      modifySegmentRequest: (request, segmentInfo) => {},
       getPresentationTime: () => playhead.getTime(),
       getBandwidthEstimate: () => 1e6,
       mediaSourceEngine: mediaSourceEngine,
@@ -270,6 +270,7 @@ describe('StreamingEngine', () => {
       onEvent: Util.spyFunc(onEvent),
       onManifestUpdate: () => {},
       onSegmentAppended: () => playhead.notifyOfBufferingChange(),
+      onInitSegmentAppended: () => {},
     };
     streamingEngine = new shaka.media.StreamingEngine(
         /** @type {shaka.extern.Manifest} */(manifest), playerInterface);
@@ -419,8 +420,9 @@ describe('StreamingEngine', () => {
       //   3. Playhead seeks to force us back inside the window
       //   4. (maybe) seek if there is a gap at the period boundary
       //   5. (maybe) seek to flush a pipeline stall
+      //   6. (maybe) on slower platforms (e.g. GitHub actions)
       expect(seekCount).toBeGreaterThan(2);
-      expect(seekCount).toBeLessThan(6);
+      expect(seekCount).toBeLessThan(7);
     });
   });
 

package/test/media/streaming_engine_unit.js

@@ -97,6 +97,9 @@ describe('StreamingEngine', () => {
   /** @type {!shaka.media.StreamingEngine} */
   let streamingEngine;
 
+  /** @type {function(function(), number)} */
+  let realSetTimeout;
+
   /**
    * Runs the fake event loop.
    * @param {function()=} callback An optional callback that is executed
@@ -116,6 +119,7 @@ describe('StreamingEngine', () => {
   }
 
   beforeAll(() => {
+    realSetTimeout = window.setTimeout;
     jasmine.clock().install();
     jasmine.clock().mockDate();
   });
@@ -451,6 +455,7 @@ describe('StreamingEngine', () => {
         presentationTimeInSeconds != undefined,
         'All tests should have defined an initial presentation time by now!');
     const playerInterface = {
+      modifySegmentRequest: (request, segmentInfo) => {},
       getPresentationTime: () => presentationTimeInSeconds,
       getBandwidthEstimate: Util.spyFunc(getBandwidthEstimate),
       mediaSourceEngine: mediaSourceEngine,
@@ -459,6 +464,7 @@ describe('StreamingEngine', () => {
       onEvent: Util.spyFunc(onEvent),
       onManifestUpdate: Util.spyFunc(onManifestUpdate),
       onSegmentAppended: Util.spyFunc(onSegmentAppended),
+      onInitSegmentAppended: () => {},
     };
     streamingEngine = new shaka.media.StreamingEngine(
         /** @type {shaka.extern.Manifest} */(manifest), playerInterface);
@@ -822,6 +828,53 @@ describe('StreamingEngine', () => {
         .toHaveBeenCalledWith('video', 0, lt20, gt40);
   });
 
+  // Regression test for https://github.com/google/shaka-player/issues/3717
+  it('applies fudge factors for the duration', async () => {
+    setupVod();
+
+    // In #3717, the duration was just barely large enough to encompass an
+    // additional segment, but that segment didn't exist, so playback never
+    // completed.  Here, we set the duration to just beyond the 3rd segment, and
+    // we make the 4th segment fail when requested.
+    const duration = 30.000000005;
+    timeline.getDuration.and.returnValue(duration);
+
+    const targetUri = '1_video_3';  // The URI of the 4th video segment.
+    failRequestsForTarget(netEngine, targetUri);
+
+    mediaSourceEngine = new shaka.test.FakeMediaSourceEngine(segmentData);
+    createStreamingEngine();
+
+    // Here we go!
+    streamingEngine.switchVariant(variant);
+    streamingEngine.switchTextStream(textStream);
+    await streamingEngine.start();
+    playing = true;
+    await runTest();
+
+    // The end of the stream should have been reached, and the 4th segment from
+    // each type should never have been requested.
+    expect(mediaSourceEngine.endOfStream).toHaveBeenCalled();
+
+    const segmentType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
+
+    netEngine.expectRequest('0_audio_0', segmentType);
+    netEngine.expectRequest('0_video_0', segmentType);
+    netEngine.expectRequest('0_text_0', segmentType);
+
+    netEngine.expectRequest('0_audio_1', segmentType);
+    netEngine.expectRequest('0_video_1', segmentType);
+    netEngine.expectRequest('0_text_1', segmentType);
+
+    netEngine.expectRequest('1_audio_2', segmentType);
+    netEngine.expectRequest('1_video_2', segmentType);
+    netEngine.expectRequest('1_text_2', segmentType);
+
+    netEngine.expectNoRequest('1_audio_3', segmentType);
+    netEngine.expectNoRequest('1_video_3', segmentType);
+    netEngine.expectNoRequest('1_text_3', segmentType);
+  });
+
   it('does not buffer one media type ahead of another', async () => {
     setupVod();
     mediaSourceEngine = new shaka.test.FakeMediaSourceEngine(segmentData);
@@ -1389,6 +1442,66 @@ describe('StreamingEngine', () => {
       });
     });
 
+    it('into unbuffered regions when nothing is buffered ' +
+      'and mediaState is performing an update', async () => {
+      // Here we go!
+      streamingEngine.switchVariant(variant);
+      streamingEngine.switchTextStream(textStream);
+      // ensure init source buffer promise does not resolve before seeked()
+      // so mediaState remains in "performingUpdate" state
+      const initSourceBufferPromise = new shaka.util.PublicPromise();
+      mediaSourceEngine.setStreamProperties.and
+          .returnValue(initSourceBufferPromise);
+      await streamingEngine.start();
+      playing = true;
+
+      // tick to trigger mediaState updates
+      jasmine.clock().tick(1);
+      // give a chance for fetchAndAppend_ to be invoked
+      // by async onUpdate_ callback
+      await Util.shortDelay(realSetTimeout);
+
+      // Nothing is buffered yet.
+      expect(mediaSourceEngine.segments).toEqual({
+        audio: [false, false, false, false],
+        video: [false, false, false, false],
+        text: [false, false, false, false],
+      });
+
+      // Seek forward to an unbuffered region in the first Period.
+      presentationTimeInSeconds = 15;
+      streamingEngine.seeked();
+
+      // resolve initSourceBufferPromise after seeked(), waitingToClearBuffer
+      // should have been set, so this will now trigger the actual flush of
+      // the buffer
+      initSourceBufferPromise.resolve();
+      mediaSourceEngine.setStreamProperties.and
+          .returnValue(Promise.resolve());
+
+      // allow mediaState update to resolve
+      await Util.shortDelay(realSetTimeout);
+
+      onTick.and.callFake(() => {
+        expect(mediaSourceEngine.clear).toHaveBeenCalled();
+        onTick.and.stub();
+      });
+
+      await runTest(Util.spyFunc(onTick));
+
+      // Verify buffers.
+      expect(mediaSourceEngine.initSegments).toEqual({
+        audio: [false, true],
+        video: [false, true],
+        text: [],
+      });
+      expect(mediaSourceEngine.segments).toEqual({
+        audio: [false, true, true, true],
+        video: [false, true, true, true],
+        text: [false, true, true, true],
+      });
+    });
+
     it('into unbuffered regions near segment start', async () => {
       // Here we go!
       streamingEngine.switchVariant(variant);
@@ -3388,6 +3501,40 @@ describe('StreamingEngine', () => {
     segmentAvailability.end++;
   }
 
+  /**
+   * @param {!shaka.test.FakeNetworkingEngine} netEngine A NetworkingEngine
+   *   look-alike.
+   * @param {string} targetUri
+   * @param {shaka.util.Error.Code=} errorCode
+   */
+  function failRequestsForTarget(
+      netEngine, targetUri, errorCode=shaka.util.Error.Code.BAD_HTTP_STATUS) {
+    // eslint-disable-next-line no-restricted-syntax
+    const originalNetEngineRequest = netEngine.request.bind(netEngine);
+
+    netEngine.request = jasmine.createSpy('request').and.callFake(
+        (requestType, request) => {
+          if (request.uris[0] == targetUri) {
+            const data = [targetUri];
+
+            if (errorCode == shaka.util.Error.Code.BAD_HTTP_STATUS) {
+              data.push(404);
+              data.push('');
+            }
+
+            // The compiler still sees the error code parameter as potentially
+            // undefined, even though we gave it a default value.
+            goog.asserts.assert(errorCode != undefined, 'Undefined error code');
+
+            return shaka.util.AbortableOperation.failed(new shaka.util.Error(
+                shaka.util.Error.Severity.CRITICAL,
+                shaka.util.Error.Category.NETWORK,
+                errorCode, data));
+          }
+          return originalNetEngineRequest(requestType, request);
+        });
+  }
+
   /**
    * @param {!shaka.test.FakeNetworkingEngine} netEngine A NetworkingEngine
    *   look-alike.

package/test/net/http_plugin_unit.js

@@ -26,6 +26,9 @@ function httpPluginTests(usingFetch) {
   // A dummy progress callback.
   const progressUpdated = (elapsedMs, bytes, bytesRemaining) => {};
 
+  // A dummy headers callback.
+  const headersReceived = (headers) => {};
+
   /** @type {shaka.extern.RetryParameters} */
   let retryParameters;
 
@@ -168,7 +171,8 @@ function httpPluginTests(usingFetch) {
     request.method = 'POST';
     request.headers['BAZ'] = '123';
 
-    await plugin(request.uris[0], request, requestType, progressUpdated)
+    await plugin(
+        request.uris[0], request, requestType, progressUpdated, headersReceived)
         .promise;
 
     const actual = mostRecentRequest();
@@ -189,8 +193,8 @@ function httpPluginTests(usingFetch) {
       request.body = null;
       request.method = 'GET';
 
-      await plugin(request.uris[0], request, requestType, progressUpdated)
-          .promise;
+      await plugin(request.uris[0], request, requestType, progressUpdated,
+          headersReceived).promise;
 
       const actual = jasmine.Fetch.requests.mostRecent();
       expect(actual).toBeTruthy();
@@ -205,8 +209,8 @@ function httpPluginTests(usingFetch) {
 
       const request = shaka.net.NetworkingEngine.makeRequest(
           [uri], retryParameters, Util.spyFunc(streamDataCallback));
-      const response =
-          await plugin(uri, request, requestType, progressUpdated).promise;
+      const response = await plugin(
+          uri, request, requestType, progressUpdated, headersReceived).promise;
 
       expect(mostRecentRequest().url).toBe(uri);
       expect(response).toBeTruthy();
@@ -297,9 +301,9 @@ function httpPluginTests(usingFetch) {
     const request = shaka.net.NetworkingEngine.makeRequest(
         ['https://foo.bar/cache'], retryParameters);
 
-    const response =
-        await plugin(request.uris[0], request, requestType, progressUpdated)
-            .promise;
+    const response = await plugin(
+        request.uris[0], request, requestType, progressUpdated, headersReceived)
+        .promise;
     expect(response).toBeTruthy();
     expect(response.fromCache).toBe(true);
   });
@@ -312,8 +316,8 @@ function httpPluginTests(usingFetch) {
       uri = 'https://foo.bar/timeout';
       const request = shaka.net.NetworkingEngine.makeRequest(
           [uri], retryParameters);
-      const operation = plugin(
-          request.uris[0], request, requestType, progressUpdated);
+      const operation = plugin(request.uris[0], request, requestType,
+          progressUpdated, headersReceived);
 
       /** @type {jasmine.Fetch.RequestStub} */
       const actual = jasmine.Fetch.requests.mostRecent();
@@ -354,8 +358,8 @@ function httpPluginTests(usingFetch) {
       uri = 'https://foo.bar/';
       const request = shaka.net.NetworkingEngine.makeRequest(
           [uri], retryParameters);
-      operation = plugin(
-          request.uris[0], request, requestType, progressUpdated);
+      operation = plugin(request.uris[0], request, requestType, progressUpdated,
+          headersReceived);
       requestPromise = operation.promise;
     }
 
@@ -388,8 +392,8 @@ function httpPluginTests(usingFetch) {
   async function testSucceeds(uri, overrideUri) {
     const request = shaka.net.NetworkingEngine.makeRequest(
         [uri], retryParameters);
-    const response =
-        await plugin(uri, request, requestType, progressUpdated).promise;
+    const response = await plugin(
+        uri, request, requestType, progressUpdated, headersReceived).promise;
 
     expect(mostRecentRequest().url).toBe(uri);
     expect(response).toBeTruthy();
@@ -410,7 +414,8 @@ function httpPluginTests(usingFetch) {
     const request = shaka.net.NetworkingEngine.makeRequest(
         [uri], retryParameters);
 
-    const p = plugin(uri, request, requestType, progressUpdated).promise;
+    const p = plugin(
+        uri, request, requestType, progressUpdated, headersReceived).promise;
     if (expected.code == shaka.util.Error.Code.TIMEOUT) {
       jasmine.clock().tick(5000);
     }

package/test/offline/storage_integration.js

@@ -22,10 +22,12 @@ 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} */
@@ -58,12 +60,16 @@ filterDescribe('Storage', storageSupport, () => {
   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';
@@ -945,6 +951,46 @@ filterDescribe('Storage', storageSupport, () => {
       }
     });
 
+    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} */
@@ -1234,11 +1280,11 @@ filterDescribe('Storage', storageSupport, () => {
       goog.asserts.assert(
           content.offlineUri != null, 'URI should not be null!');
 
-      /**
-       * @type {!Array.<number>}
-       */
+      // We expect 5 progress events because there are 4 unique segments, plus
+      // the manifest.
+      /** @type {!Array.<number>}*/
       const progressSteps = [
-        0.111, 0.222, 0.333, 0.444, 0.555, 0.666, 0.777, 0.888, 1.0,
+        0.2, 0.4, 0.6, 0.8, 1,
       ];
 
       const progressCallback = (content, progress) => {
@@ -1399,6 +1445,62 @@ filterDescribe('Storage', storageSupport, () => {
     };
   }
 
+  /** @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) => {
@@ -1612,6 +1714,8 @@ filterDescribe('Storage', storageSupport, () => {
           makeManifestWithLiveTimeline();
       this.map_[manifestWithAlternateSegmentsUri] =
           makeManifestWithAlternateSegments();
+      this.map_[manifestWithVideoInitSegmentsUri] =
+          makeManifestWithVideoInitSegments();
     }
 
     /** @override */