shaka-player 4.3.9 → 4.4.0

package/test/dash/dash_parser_live_unit.js

@@ -26,8 +26,6 @@ describe('DashParser Live', () => {
     parser.configure(shaka.util.PlayerConfiguration.createDefault().manifest);
     playerInterface = {
       networkingEngine: fakeNetEngine,
-      modifyManifestRequest: (request, manifestInfo) => {},
-      modifySegmentRequest: (request, segmentInfo) => {},
       filter: (manifest) => Promise.resolve(),
       makeTextStreamsForClosedCaptions: (manifest) => {},
       onTimelineRegionAdded: fail,  // Should not have any EventStream elements.
@@ -591,6 +589,8 @@ describe('DashParser Live', () => {
     const onError = jasmine.createSpy('onError');
     playerInterface.onError = Util.spyFunc(onError);
 
+    const updateTick = updateTickSpy();
+
     fakeNetEngine.setResponseText('dummy://foo', manifestText);
     await parser.start('dummy://foo', playerInterface);
 
@@ -605,6 +605,39 @@ describe('DashParser Live', () => {
 
     await updateManifest();
     expect(onError).toHaveBeenCalledTimes(1);
+    expect(updateTick).toHaveBeenCalledTimes(2);
+  });
+
+  it('fatal error on manifest update request failure when ' +
+      'raiseFatalErrorOnManifestUpdateRequestFailure is true', async () => {
+    const manifestConfig =
+      shaka.util.PlayerConfiguration.createDefault().manifest;
+    manifestConfig.raiseFatalErrorOnManifestUpdateRequestFailure = true;
+    parser.configure(manifestConfig);
+
+    const updateTick = updateTickSpy();
+
+    const lines = [
+      '<SegmentTemplate startNumber="1" media="s$Number$.mp4" duration="2"/>',
+    ];
+    const manifestText = makeSimpleLiveManifestText(lines, updateTime);
+    /** @type {!jasmine.Spy} */
+    const onError = jasmine.createSpy('onError');
+    playerInterface.onError = Util.spyFunc(onError);
+
+    fakeNetEngine.setResponseText('dummy://foo', manifestText);
+    await parser.start('dummy://foo', playerInterface);
+
+    const error = new shaka.util.Error(
+        shaka.util.Error.Severity.CRITICAL,
+        shaka.util.Error.Category.NETWORK,
+        shaka.util.Error.Code.BAD_HTTP_STATUS);
+    const operation = shaka.util.AbortableOperation.failed(error);
+    fakeNetEngine.request.and.returnValue(operation);
+
+    await updateManifest();
+    expect(onError).toHaveBeenCalledWith(error);
+    expect(updateTick).toHaveBeenCalledTimes(1);
   });
 
   it('uses @minimumUpdatePeriod', async () => {
@@ -640,10 +673,9 @@ describe('DashParser Live', () => {
     fakeNetEngine.setResponseText('dummy://foo', manifestText);
     await parser.start('dummy://foo', playerInterface);
 
-    const waitTime = shaka.dash.DashParser['MIN_UPDATE_PERIOD_'];
     expect(tickAfter).toHaveBeenCalledTimes(1);
     const delay = tickAfter.calls.mostRecent().args[0];
-    expect(delay).toBe(waitTime);
+    expect(delay).toBe(0);
   });
 
   it('does not update when @minimumUpdatePeriod is missing', async () => {
@@ -668,8 +700,7 @@ describe('DashParser Live', () => {
       '<SegmentTemplate startNumber="1" media="s$Number$.mp4" duration="2" />',
     ];
     const extraWaitTime = 15.0;
-    const idealUpdateTime = shaka.dash.DashParser['MIN_UPDATE_PERIOD_'];
-    const manifestText = makeSimpleLiveManifestText(lines, idealUpdateTime);
+    const manifestText = makeSimpleLiveManifestText(lines, 3);
 
     let now = 0;
     Date.now = () => now;
@@ -709,17 +740,21 @@ describe('DashParser Live', () => {
     fakeNetEngine.setResponseText('dummy://foo', manifestText);
 
     const manifestRequest = shaka.net.NetworkingEngine.RequestType.MANIFEST;
+    const manifestContext = {
+      type: shaka.net.NetworkingEngine.AdvancedRequestType.MPD,
+    };
     await parser.start('dummy://foo', playerInterface);
 
     expect(fakeNetEngine.request).toHaveBeenCalledTimes(1);
-    fakeNetEngine.expectRequest('dummy://foo', manifestRequest);
+    fakeNetEngine.expectRequest('dummy://foo', manifestRequest, manifestContext);
     fakeNetEngine.request.calls.reset();
 
     // Create a mock so we can verify it gives two URIs.
     // The third location is a relative url, and should be resolved as an
     // absolute url.
-    fakeNetEngine.request.and.callFake((type, request) => {
+    fakeNetEngine.request.and.callFake((type, request, context) => {
       expect(type).toBe(manifestRequest);
+      expect(context).toEqual(manifestContext);
       expect(request.uris).toEqual(
           ['http://foobar', 'http://foobar2', 'dummy://foo/foobar3']);
       const data = shaka.util.StringUtils.toUTF8(manifestText);
@@ -952,6 +987,9 @@ describe('DashParser Live', () => {
 
   describe('stop', () => {
     const manifestRequestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
+    const manifestContext = {
+      type: shaka.net.NetworkingEngine.AdvancedRequestType.MPD,
+    };
     const dateRequestType = shaka.net.NetworkingEngine.RequestType.TIMING;
     const manifestUri = 'dummy://foo';
     const dateUri = 'http://foo.bar/date';
@@ -983,7 +1021,8 @@ describe('DashParser Live', () => {
     it('stops updates', async () => {
       await parser.start(manifestUri, playerInterface);
 
-      fakeNetEngine.expectRequest(manifestUri, manifestRequestType);
+      fakeNetEngine.expectRequest(
+          manifestUri, manifestRequestType, manifestContext);
       fakeNetEngine.request.calls.reset();
 
       parser.stop();
@@ -1001,7 +1040,8 @@ describe('DashParser Live', () => {
       parser.stop();
       await expectation;
 
-      fakeNetEngine.expectRequest(manifestUri, manifestRequestType);
+      fakeNetEngine.expectRequest(
+          manifestUri, manifestRequestType, manifestContext);
       fakeNetEngine.request.calls.reset();
       await updateManifest();
       // An update should not occur.
@@ -1012,7 +1052,8 @@ describe('DashParser Live', () => {
       const manifest = await parser.start('dummy://foo', playerInterface);
 
       expect(manifest).toBeTruthy();
-      fakeNetEngine.expectRequest(manifestUri, manifestRequestType);
+      fakeNetEngine.expectRequest(
+          manifestUri, manifestRequestType, manifestContext);
       fakeNetEngine.request.calls.reset();
       /** @type {!shaka.util.PublicPromise} */
       const delay = fakeNetEngine.delayNextRequest();
@@ -1020,7 +1061,8 @@ describe('DashParser Live', () => {
       await updateManifest();
       // The request was made but should not be resolved yet.
       expect(fakeNetEngine.request).toHaveBeenCalledTimes(1);
-      fakeNetEngine.expectRequest(manifestUri, manifestRequestType);
+      fakeNetEngine.expectRequest(
+          manifestUri, manifestRequestType, manifestContext);
       fakeNetEngine.request.calls.reset();
       parser.stop();
       delay.resolve();
@@ -1041,7 +1083,8 @@ describe('DashParser Live', () => {
       await Util.shortDelay();
       // This is the initial manifest request.
       expect(fakeNetEngine.request).toHaveBeenCalledTimes(1);
-      fakeNetEngine.expectRequest(manifestUri, manifestRequestType);
+      fakeNetEngine.expectRequest(
+          manifestUri, manifestRequestType, manifestContext);
       fakeNetEngine.request.calls.reset();
       // Resolve the manifest request and wait on the UTCTiming request.
       delay.resolve();

package/test/dash/dash_parser_manifest_unit.js

@@ -140,7 +140,7 @@ describe('DashParser Manifest', () => {
           '      <Representation bandwidth="50" width="576" height="432" />',
           '    </AdaptationSet>',
           '    <AdaptationSet mimeType="text/vtt"',
-          '        lang="es" label="spanish">',
+          '        lang="spa" label="spanish">',
           '      <Role value="caption" />',
           '      <Role value="main" />',
           '      <Representation bandwidth="100" />',
@@ -155,6 +155,7 @@ describe('DashParser Manifest', () => {
         ],
         shaka.test.ManifestGenerator.generate((manifest) => {
           manifest.sequenceMode = true;
+          manifest.type = shaka.media.ManifestParser.DASH;
           manifest.anyTimeline();
           manifest.minBufferTime = 75;
           manifest.addPartialVariant((variant) => {
@@ -193,6 +194,7 @@ describe('DashParser Manifest', () => {
           });
           manifest.addPartialTextStream((stream) => {
             stream.language = 'es';
+            stream.originalLanguage = 'spa';
             stream.label = 'spanish';
             stream.primary = true;
             stream.mimeType = 'text/vtt';
@@ -239,6 +241,7 @@ describe('DashParser Manifest', () => {
         ],
         shaka.test.ManifestGenerator.generate((manifest) => {
           manifest.sequenceMode = false;
+          manifest.type = shaka.media.ManifestParser.DASH;
           manifest.anyTimeline();
           manifest.minBufferTime = 75;
           manifest.addPartialVariant((variant) => {
@@ -725,7 +728,7 @@ describe('DashParser Manifest', () => {
         '    value="http://foo.bar/date" />',
       ]);
 
-      fakeNetEngine.request.and.callFake((type, request) => {
+      fakeNetEngine.request.and.callFake((type, request, context) => {
         if (request.uris[0] == 'http://foo.bar/manifest') {
           const data = shaka.util.StringUtils.toUTF8(source);
           return shaka.util.AbortableOperation.completed({
@@ -1862,6 +1865,49 @@ describe('DashParser Manifest', () => {
     expect(stream).toBeUndefined();
   });
 
+  it('reads accessibility purpose elements', async () => {
+    const manifestText = [
+      '<MPD minBufferTime="PT75S">',
+      '  <Period id="1" duration="PT30S">',
+      '    <AdaptationSet id="1" contentType="text">',
+      '      <Accessibility ',
+      '          schemeIdUri="urn:tva:metadata:cs:AudioPurposeCS:2007"',
+      '          value="2" />',
+      '      <Representation id="text-en" mimeType="text/webvtt">',
+      '        <BaseURL>t-en.vtt</BaseURL>',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '    <AdaptationSet id="1" mimeType="video/mp4">',
+      '      <Representation id="video-sd" width="640" height="480">',
+      '        <BaseURL>v-sd.mp4</BaseURL>',
+      '        <SegmentBase indexRange="100-200" />',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '    <AdaptationSet id="1" mimeType="audio/mp4">',
+      '      <Accessibility ',
+      '          schemeIdUri="urn:tva:metadata:cs:AudioPurposeCS:2007"',
+      '          value="1" />',
+      '      <Representation id="audio-sd" width="640" height="480">',
+      '        <BaseURL>v-sd.mp4</BaseURL>',
+      '        <SegmentBase indexRange="100-200" />',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '  </Period>',
+      '</MPD>',
+    ].join('\n');
+
+    fakeNetEngine.setResponseText('dummy://foo', manifestText);
+    /** @type {shaka.extern.Manifest} */
+    const manifest = await parser.start('dummy://foo', playerInterface);
+    const textStream = manifest.textStreams[0];
+    expect(textStream.accessibilityPurpose).toBe(
+        shaka.media.ManifestParser.AccessibilityPurpose.HARD_OF_HEARING);
+    const variant = manifest.variants[0];
+    expect(variant.video.accessibilityPurpose).toBeUndefined();
+    expect(variant.audio.accessibilityPurpose).toBe(
+        shaka.media.ManifestParser.AccessibilityPurpose.VISUALLY_IMPAIRED);
+  });
+
   it('converts Accessibility element to "kind"', async () => {
     const manifestText = [
       '<MPD minBufferTime="PT75S">',
@@ -2511,4 +2557,26 @@ describe('DashParser Manifest', () => {
     expect(segments[0][1].startTime).toBe(15);
     expect(segments[1][1].startTime).toBe(15);
   });
+
+  describe('Parses ServiceDescription', () => {
+    it('with PlaybackRate and Latency', async () => {
+      const source = [
+        '<MPD minBufferTime="PT75S" type="dynamic"',
+        '     availabilityStartTime="1970-01-01T00:00:00Z">',
+        '  <ServiceDescription id="0">',
+        '    <Latency max="2000" min="2000" referenceId="0" target="4000" />',
+        '    <PlaybackRate max="1.10" min="0.96" />',
+        '  </ServiceDescription>',
+        '</MPD>',
+      ].join('\n');
+
+      fakeNetEngine.setResponseText('dummy://foo', source);
+
+      /** @type {shaka.extern.Manifest} */
+      const manifest = await parser.start('dummy://foo', playerInterface);
+
+      expect(manifest.serviceDescription.maxLatency).toBe(2);
+      expect(manifest.serviceDescription.maxPlaybackRate).toBe(1.1);
+    });
+  });
 });

package/test/dash/dash_parser_segment_base_unit.js

@@ -87,13 +87,13 @@ describe('DashParser SegmentBase', () => {
 
     // Expect calls to fetch part of the media and init segments of each stream.
     fakeNetEngine.expectRangeRequest(
-        'http://example.com/media-1.webm', 100, 200);
+        'http://example.com/media-1.webm', 100, 200, /* isInit= */ false);
     fakeNetEngine.expectRangeRequest(
-        'http://example.com/init-1.webm', 201, 300);
+        'http://example.com/init-1.webm', 201, 300, /* isInit= */ true);
     fakeNetEngine.expectRangeRequest(
-        'http://example.com/media-2.webm', 1100, 1200);
+        'http://example.com/media-2.webm', 1100, 1200, /* isInit= */ false);
     fakeNetEngine.expectRangeRequest(
-        'http://example.com/init-2.webm', 1201, 1300);
+        'http://example.com/init-2.webm', 1201, 1300, /* isInit= */ true);
   });
 
   it('inherits from Period', async () => {
@@ -125,7 +125,8 @@ describe('DashParser SegmentBase', () => {
     expect(initSegmentReference.getEndByte()).toBe(300);
 
     expect(fakeNetEngine.request).toHaveBeenCalledTimes(2);
-    fakeNetEngine.expectRangeRequest('http://example.com', 100, 200);
+    fakeNetEngine.expectRangeRequest(
+        'http://example.com', 100, 200, /* isInit= */ false);
   });
 
   it('inherits from AdaptationSet', async () => {
@@ -157,7 +158,8 @@ describe('DashParser SegmentBase', () => {
     expect(initSegmentReference.getEndByte()).toBe(300);
 
     expect(fakeNetEngine.request).toHaveBeenCalledTimes(2);
-    fakeNetEngine.expectRangeRequest('http://example.com', 100, 200);
+    fakeNetEngine.expectRangeRequest(
+        'http://example.com', 100, 200, /* isInit= */ false);
   });
 
   it('does not require sourceURL in Initialization', async () => {
@@ -190,7 +192,8 @@ describe('DashParser SegmentBase', () => {
     expect(initSegmentReference.getEndByte()).toBe(300);
 
     expect(fakeNetEngine.request).toHaveBeenCalledTimes(2);
-    fakeNetEngine.expectRangeRequest('http://example.com/stream.mp4', 100, 200);
+    fakeNetEngine.expectRangeRequest(
+        'http://example.com/stream.mp4', 100, 200, /* isInit= */ false);
   });
 
   it('merges across levels', async () => {
@@ -230,7 +233,8 @@ describe('DashParser SegmentBase', () => {
     expect(segmentReference.timestampOffset).toBe(-10);
 
     expect(fakeNetEngine.request).toHaveBeenCalledTimes(2);
-    fakeNetEngine.expectRangeRequest('http://example.com/index.mp4', 5, 2000);
+    fakeNetEngine.expectRangeRequest(
+        'http://example.com/index.mp4', 5, 2000, /* isInit= */ false);
   });
 
   it('merges and overrides across levels', async () => {
@@ -269,7 +273,8 @@ describe('DashParser SegmentBase', () => {
     expect(segmentReference.timestampOffset).toBe(-20);
 
     expect(fakeNetEngine.request).toHaveBeenCalledTimes(2);
-    fakeNetEngine.expectRangeRequest('http://example.com', 30, 900);
+    fakeNetEngine.expectRangeRequest(
+        'http://example.com', 30, 900, /* isInit= */ false);
   });
 
   it('does not assume the same timescale as media', async () => {

package/test/dash/dash_parser_segment_template_unit.js

@@ -198,7 +198,7 @@ describe('DashParser SegmentTemplate', () => {
 
       expect(fakeNetEngine.request).toHaveBeenCalledTimes(2);
       fakeNetEngine.expectRangeRequest(
-          'http://example.com/index-500.mp4', 0, null);
+          'http://example.com/index-500.mp4', 0, null, /* isInit= */ false);
     });
 
     it('defaults to index with multiple segment sources', async () => {
@@ -226,7 +226,7 @@ describe('DashParser SegmentTemplate', () => {
 
       expect(fakeNetEngine.request).toHaveBeenCalledTimes(2);
       fakeNetEngine.expectRangeRequest(
-          'http://example.com/index-500.mp4', 0, null);
+          'http://example.com/index-500.mp4', 0, null, /* isInit= */ false);
     });
 
     it('requests init data for WebM', async () => {
@@ -261,9 +261,9 @@ describe('DashParser SegmentTemplate', () => {
 
       expect(fakeNetEngine.request).toHaveBeenCalledTimes(3);
       fakeNetEngine.expectRangeRequest(
-          'http://example.com/init-500.webm', 0, null);
+          'http://example.com/init-500.webm', 0, null, /* isInit= */ true);
       fakeNetEngine.expectRangeRequest(
-          'http://example.com/index-500.webm', 0, null);
+          'http://example.com/index-500.webm', 0, null, /* isInit= */ false);
     });
 
     it('inherits from Period', async () => {
@@ -295,7 +295,7 @@ describe('DashParser SegmentTemplate', () => {
 
       expect(fakeNetEngine.request).toHaveBeenCalledTimes(2);
       fakeNetEngine.expectRangeRequest(
-          'http://example.com/index-500.mp4', 0, null);
+          'http://example.com/index-500.mp4', 0, null, /* isInit= */ false);
     });
 
     it('inherits from AdaptationSet', async () => {
@@ -327,7 +327,7 @@ describe('DashParser SegmentTemplate', () => {
 
       expect(fakeNetEngine.request).toHaveBeenCalledTimes(2);
       fakeNetEngine.expectRangeRequest(
-          'http://example.com/index-500.mp4', 0, null);
+          'http://example.com/index-500.mp4', 0, null, /* isInit= */ false);
     });
   });
 
@@ -578,4 +578,284 @@ describe('DashParser SegmentTemplate', () => {
       await Dash.testFails(source, error);
     });
   });
+
+  describe('TimelineSegmentIndex', () => {
+    describe('find', () => {
+      it('finds the correct references', async () => {
+        const info = makeTemplateInfo(makeRanges(0, 2.0, 10));
+        const infoClone = shaka.util.ObjectUtils.cloneObject(info);
+        const index = await makeTimelineSegmentIndex(infoClone,
+            /* delayPeriodEnd= */ true,
+            /* shouldFit= */ true);
+
+        const pos1 = index.find(1.0);
+        expect(pos1).toBe(0);
+        const pos2 = index.find(2.0);
+        expect(pos2).toBe(1);
+
+        // After the end of the last reference but before the end of the period
+        // should return index of the last reference
+        const lastRef = info.timeline[info.timeline.length - 1];
+        const pos3 = index.find(lastRef.end + 0.5);
+        expect(pos3).toBe(info.timeline.length - 1);
+
+        const pos4 = index.find(123.45);
+        expect(pos4).toBeNull();
+      });
+
+      it('finds correct position if time is in gap', async () => {
+        const ranges = [
+          {
+            start: 0,
+            end: 2,
+            unscaledStart: 0,
+          },
+          {
+            start: 3,
+            end: 5,
+            unscaledStart: 3 * 90000,
+          },
+        ];
+        const info = makeTemplateInfo(ranges);
+        const index = await makeTimelineSegmentIndex(info);
+        const pos = index.find(2.5);
+        expect(pos).toBe(0);
+      });
+
+      it('finds correct position if time === first start time', async () => {
+        const info = makeTemplateInfo(makeRanges(0, 2.0, 10));
+        const index = await makeTimelineSegmentIndex(info);
+
+        const pos = index.find(0);
+        expect(pos).toBe(0);
+      });
+
+      it('finds correct position if time === first end time', async () => {
+        const ranges = [
+          {
+            start: 0,
+            end: 2,
+            unscaledStart: 0,
+          },
+          {
+            start: 2.1,
+            end: 5,
+            unscaledStart: 3 * 90000,
+          },
+        ];
+        const info = makeTemplateInfo(ranges);
+        const index = await makeTimelineSegmentIndex(info);
+
+        const pos = index.find(2.0);
+        expect(pos).toBe(0);
+      });
+
+      it('finds correct position if time === second start time', async () => {
+        const ranges = [
+          {
+            start: 0,
+            end: 2,
+            unscaledStart: 0,
+          },
+          {
+            start: 2.1,
+            end: 5,
+            unscaledStart: 3 * 90000,
+          },
+        ];
+        const info = makeTemplateInfo(ranges);
+        const index = await makeTimelineSegmentIndex(info);
+
+        const pos = index.find(2.1);
+        expect(pos).toBe(1);
+      });
+
+
+      it('returns null if time === last end time', async () => {
+        const info = makeTemplateInfo(makeRanges(0, 2.0, 2));
+        const index = await makeTimelineSegmentIndex(info, false);
+
+        const pos = index.find(4.0);
+        expect(pos).toBeNull();
+      });
+
+      it('returns null if time > last end time', async () => {
+        const info = makeTemplateInfo(makeRanges(0, 2.0, 2));
+        const index = await makeTimelineSegmentIndex(info, false);
+
+        const pos = index.find(6.0);
+        expect(pos).toBeNull();
+      });
+    });
+    describe('get', () => {
+      it('creates a segment reference for a given position', async () => {
+        const info = makeTemplateInfo(makeRanges(0, 2.0, 10));
+        const index = await makeTimelineSegmentIndex(info);
+        const pos = index.find(2.0);
+        goog.asserts.assert(pos != null, 'Null position!');
+        const ref = index.get(pos);
+        expect(ref).toEqual(jasmine.objectContaining({
+          'startTime': 2,
+          'endTime': 4,
+          'trueEndTime': 4,
+          'startByte': 0,
+          'endByte': null,
+          'timestampOffset': 0,
+          'appendWindowStart': 0,
+          'appendWindowEnd': 21,
+          'partialReferences': [],
+          'tilesLayout': '',
+          'tileDuration': null,
+        }));
+      });
+
+      it('returns null if a position is unknown', async () => {
+        const info = makeTemplateInfo(makeRanges(0, 2.0, 10));
+        const index = await makeTimelineSegmentIndex(info);
+        const ref = index.get(12345);
+        expect(ref).toBeNull();
+      });
+
+      it('returns null if a position < 0', async () => {
+        const info = makeTemplateInfo(makeRanges(0, 2.0, 10));
+        const index = await makeTimelineSegmentIndex(info);
+        const ref = index.get(-12);
+        expect(ref).toBeNull();
+      });
+    });
+
+    describe('appendTemplateInfo', () => {
+      it('appends new timeline to existing', async () => {
+        const initialRanges = makeRanges(0, 2.0, 10);
+        const info = makeTemplateInfo(initialRanges);
+        const index = await makeTimelineSegmentIndex(info, false);
+
+        const newStart = initialRanges[initialRanges.length - 1].end;
+        expect(index.find(newStart)).toBeNull();
+
+        const newRanges = makeRanges(newStart, 2.0, 10);
+        const newTemplateInfo = makeTemplateInfo(newRanges);
+
+        const newEnd = newRanges[newRanges.length - 1].end;
+        index.appendTemplateInfo(newTemplateInfo, newEnd);
+        expect(index.find(newStart)).toBe(10);
+        expect(index.find(newEnd - 1.0)).toBe(19);
+      });
+    });
+
+    describe('evict', () => {
+      it('evicts old entries and maintains position', async () => {
+        const initialRanges = makeRanges(0, 2.0, 10);
+        const info = makeTemplateInfo(initialRanges);
+        const index = await makeTimelineSegmentIndex(info, false);
+
+        index.evict(4.0);
+        expect(index.find(2.0)).toBe(2);
+        expect(index.find(6.0)).toBe(3);
+      });
+    });
+  });
+
+  /**
+   *
+   * @param {shaka.dash.SegmentTemplate.SegmentTemplateInfo} info
+   * @param {boolean} delayPeriodEnd
+   * @param {boolean} shouldFit
+   * @return {?}
+   */
+  async function makeTimelineSegmentIndex(info, delayPeriodEnd = true,
+      shouldFit = false) {
+    // Period end may be a bit after the last timeline entry
+    let periodEnd = info.timeline[info.timeline.length - 1].end;
+    if (delayPeriodEnd) {
+      periodEnd += 1.0;
+    }
+
+    const dummySource = Dash.makeSimpleManifestText([
+      '<SegmentTemplate startNumber="0" duration="10"',
+      '    media="$Number$-$Time$-$Bandwidth$.mp4">',
+      '  <SegmentTimeline>',
+      '    <S t="0" d="15" r="2" />',
+      '  </SegmentTimeline>',
+      '</SegmentTemplate>',
+    ], /* duration= */ 45);
+
+    fakeNetEngine.setResponseText('dummy://foo', dummySource);
+    const manifest = await parser.start('dummy://foo', playerInterface);
+
+    expect(manifest.variants.length).toBe(1);
+
+    const stream = manifest.variants[0].video;
+    expect(stream).toBeTruthy();
+    await stream.createSegmentIndex();
+
+    /** @type {?} */
+    const index = stream.segmentIndex;
+    index.release();
+    index.appendTemplateInfo(info, info.timeline[0].start,
+        periodEnd, shouldFit);
+
+    return index;
+  }
 });
+
+/**
+ * Creates a URI string.
+ *
+ * @param {number} x
+ * @return {string}
+ */
+function uri(x) {
+  return 'http://example.com/video_' + x + '.m4s';
+}
+
+/**
+ *
+ * @return {shaka.media.InitSegmentReference}
+ */
+function makeInitSegmentReference() {
+  return new shaka.media.InitSegmentReference(() => [], 0, null);
+}
+
+/**
+ * Create a list of continuous time ranges
+ * @param {number} start
+ * @param {number} duration
+ * @param {number} num
+ * @return {Array<shaka.media.PresentationTimeline.TimeRange>}
+ */
+function makeRanges(start, duration, num) {
+  const ranges = [];
+  let currentPos = start;
+  for (let i = 0; i < num; i += 1) {
+    ranges.push({
+      start: currentPos,
+      end: currentPos + duration,
+      unscaledStart: currentPos * 90000,
+    });
+    currentPos += duration;
+  }
+  return ranges;
+}
+
+/**
+ * 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 {Array<shaka.media.PresentationTimeline.TimeRange>} timeline
+ * @return {shaka.dash.SegmentTemplate.SegmentTemplateInfo}
+ */
+function makeTemplateInfo(timeline) {
+  return {
+    'segmentDuration': null,
+    'timescale': 90000,
+    'startNumber': 1,
+    'scaledPresentationTimeOffset': 0,
+    'unscaledPresentationTimeOffset': 0,
+    'timeline': timeline,
+    'mediaTemplate': 'master_540_2997_$Number%09d$.cmfv',
+    'indexTemplate': null,
+  };
+}

package/test/demo/demo_unit.js

@@ -95,8 +95,12 @@ describe('Demo', () => {
           .add('playRangeEnd')
           .add('manifest.dash.keySystemsByURI')
           .add('manifest.hls.mediaPlaylistFullMimeType')
+          .add('manifest.mss.keySystemsBySystemId')
           .add('drm.keySystemsMapping')
-          .add('streaming.parsePrftBox');
+          .add('streaming.parsePrftBox')
+          .add('manifest.raiseFatalErrorOnManifestUpdateRequestFailure')
+          .add('drm.persistentSessionOnlinePlayback')
+          .add('drm.persistentSessionsMetadata');
 
       /**
        * @param {!Object} section