shaka-player 3.2.2 → 3.3.0

package/lib/util/error.js

@@ -986,6 +986,12 @@ shaka.util.Error.Code = {
    */
   'DOWNLOAD_SIZE_CALLBACK_ERROR': 9015,
 
+  /**
+   * The storage cell does not allow new operations that significantly change
+   * existing data.
+   */
+  'MODIFY_OPERATION_NOT_SUPPORTED': 9016,
+
   /**
    * CS IMA SDK, required for ad insertion, has not been included on the page.
    */

package/lib/util/language_utils.js

@@ -13,6 +13,7 @@ goog.require('shaka.util.ManifestParserUtils');
 /**
  * @summary A set of language utility functions.
  * @final
+ * @export
  */
 shaka.util.LanguageUtils = class {
   /**
@@ -32,6 +33,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} locale1
    * @param {string} locale2
    * @return {boolean}
+   * @export
    */
   static areLocaleCompatible(locale1, locale2) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -62,6 +64,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} locale1
    * @param {string} locale2
    * @return {boolean}
+   * @export
    */
   static areLanguageCompatible(locale1, locale2) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -102,6 +105,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} possibleParent
    * @param {string} possibleChild
    * @return {boolean}
+   * @export
    */
   static isParentOf(possibleParent, possibleChild) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -146,6 +150,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} localeA
    * @param {string} localeB
    * @return {boolean}
+   * @export
    */
   static isSiblingOf(localeA, localeB) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -181,6 +186,7 @@ shaka.util.LanguageUtils = class {
    *
    * @param {string} locale
    * @return {string}
+   * @export
    */
   static normalize(locale) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -217,6 +223,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} a
    * @param {string} b
    * @return {boolean}
+   * @export
    */
   static areSiblings(a, b) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -235,6 +242,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} target
    * @param {string} candidate
    * @return {number}
+   * @export
    */
   static relatedness(target, candidate) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -271,6 +279,7 @@ shaka.util.LanguageUtils = class {
    *
    * @param {string} lang
    * @return {string}
+   * @export
    */
   static getBase(lang) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -300,6 +309,7 @@ shaka.util.LanguageUtils = class {
    *
    * @param {shaka.extern.Stream} stream
    * @return {string}
+   * @export
    */
   static getLocaleForText(stream) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -322,6 +332,7 @@ shaka.util.LanguageUtils = class {
    *
    * @param {shaka.extern.Variant} variant
    * @return {string}
+   * @export
    */
   static getLocaleForVariant(variant) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -356,6 +367,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} target
    * @param {!Iterable.<string>} searchSpace
    * @return {?string}
+   * @export
    */
   static findClosestLocale(target, searchSpace) {
     const LanguageUtils = shaka.util.LanguageUtils;

package/lib/util/mutex.js

@@ -0,0 +1,52 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.util.Mutex');
+
+
+/**
+ * @summary A simple mutex.
+ */
+shaka.util.Mutex = class {
+  /** Creates the mutex. */
+  constructor() {
+    /** @private {!Array.<function()>} */
+    this.waiting_ = [];
+
+    /** @private {number} */
+    this.nextMutexId_ = 0;
+
+    /** @private {number} */
+    this.acquiredMutexId_ = 0;
+  }
+
+  /** @return {!Promise.<number>} mutexId */
+  async acquire() {
+    const mutexId = ++this.nextMutexId_;
+    if (!this.acquiredMutexId_) {
+      this.acquiredMutexId_ = mutexId;
+    } else {
+      await (new Promise((resolve, reject) => {
+        this.waiting_.push(() => {
+          this.acquiredMutexId_ = mutexId;
+          resolve();
+        });
+      }));
+    }
+    return mutexId;
+  }
+
+  /** @param {number} mutexId */
+  release(mutexId) {
+    if (mutexId == this.acquiredMutexId_) {
+      this.acquiredMutexId_ = 0;
+      if (this.waiting_.length > 0) {
+        const callback = this.waiting_.shift();
+        callback();
+      }
+    }
+  }
+};

package/lib/util/periods.js

@@ -547,8 +547,7 @@ shaka.util.PeriodCombiner = class {
       for (const stream of unusedStreams) {
         // Create a new output stream which includes this input stream.
         const outputStream =
-            // eslint-disable-next-line no-await-in-loop
-            await shaka.util.PeriodCombiner.createNewOutputStream_(
+            shaka.util.PeriodCombiner.createNewOutputStream_(
                 stream, streamsPerPeriod, clone, concat,
                 unusedStreamsPerPeriod);
         if (outputStream) {
@@ -619,52 +618,69 @@ shaka.util.PeriodCombiner = class {
   static async extendExistingOutputStream_(
       outputStream, streamsPerPeriod, firstNewPeriodIndex, concat,
       unusedStreamsPerPeriod) {
-    const matches = shaka.util.PeriodCombiner.findMatchesInAllPeriods_(
-        streamsPerPeriod, outputStream);
-
-    if (!matches) {
-      // We were unable to extend this output stream.
-      shaka.log.error('No matches extending output stream!',
-          outputStream, streamsPerPeriod);
-      return false;
-    }
+    shaka.util.PeriodCombiner.findMatchesInAllPeriods_(streamsPerPeriod,
+        outputStream);
 
     // This only exists where T == Stream, and this should only ever be called
     // on Stream types.  StreamDB should not have pre-existing output streams.
     goog.asserts.assert(outputStream.createSegmentIndex,
         'outputStream should be a Stream type!');
 
+    if (!outputStream.matchedStreams) {
+      // We were unable to extend this output stream.
+      shaka.log.error('No matches extending output stream!',
+          outputStream, streamsPerPeriod);
+      return false;
+    }
     // We need to create all the per-period segment indexes and append them to
     // the output's MetaSegmentIndex.
-    await shaka.util.PeriodCombiner.createSegmentIndexes_(matches);
-
-    // Assure the compiler that matches didn't become null during the async
-    // operation above.
-    goog.asserts.assert(matches, 'Matches should be non-null');
+    if (outputStream.segmentIndex) {
+      await shaka.util.PeriodCombiner.extendOutputSegmentIndex_(outputStream,
+          firstNewPeriodIndex);
+    }
 
-    shaka.util.PeriodCombiner.extendOutputStream_(
-        outputStream, matches, firstNewPeriodIndex, concat,
-        unusedStreamsPerPeriod);
+    shaka.util.PeriodCombiner.extendOutputStream_(outputStream,
+        firstNewPeriodIndex, concat, unusedStreamsPerPeriod);
     return true;
   }
 
   /**
-   * Creates all segment indexes for an array of streams.  Returns once every
-   * segment index is created.
+   * Creates the segment indexes for an array of input streams, and append them
+   * to the output stream's segment index.
    *
-   * @param {!Array.<!shaka.extern.Stream>} streams
-   * @return {!Promise}
+   * @param {shaka.extern.Stream} outputStream
+   * @param {number} firstNewPeriodIndex An index into streamsPerPeriod which
+   *   represents the first new period that hasn't been processed yet.
    * @private
    */
-  static createSegmentIndexes_(streams) {
+  static async extendOutputSegmentIndex_(outputStream, firstNewPeriodIndex) {
     const operations = [];
+    const streams = outputStream.matchedStreams;
+    goog.asserts.assert(streams, 'matched streams should be valid');
+
     for (const stream of streams) {
       operations.push(stream.createSegmentIndex());
       if (stream.trickModeVideo && !stream.trickModeVideo.segmentIndex) {
         operations.push(stream.trickModeVideo.createSegmentIndex());
       }
     }
-    return Promise.all(operations);
+    await Promise.all(operations);
+
+    // Concatenate the new matches onto the stream, starting at the first new
+    // period.
+    const Iterables = shaka.util.Iterables;
+    // Satisfy the compiler about the type.
+    // Also checks if the segmentIndex is still valid after the async
+    // operations, to make sure we stop if the active stream has changed.
+    if (outputStream.segmentIndex instanceof shaka.media.MetaSegmentIndex) {
+      for (const {i, item: match} of Iterables.enumerate(streams)) {
+        if (match.segmentIndex && i >= firstNewPeriodIndex) {
+          goog.asserts.assert(match.segmentIndex,
+              'stream should have a segmentIndex.');
+          outputStream.segmentIndex.appendSegmentIndex(match.segmentIndex);
+        }
+      }
+    }
   }
 
   /**
@@ -682,7 +698,7 @@ shaka.util.PeriodCombiner = class {
    * @param {!Array.<!Set.<T>>} unusedStreamsPerPeriod An array of sets of
    *   unused streams from each period.
    *
-   * @return {!Promise.<?T>} A newly-created output Stream, or null if matches
+   * @return {?T} A newly-created output Stream, or null if matches
    *   could not be found.`
    *
    * @template T
@@ -690,35 +706,36 @@ shaka.util.PeriodCombiner = class {
    *
    * @private
    */
-  static async createNewOutputStream_(
+  static createNewOutputStream_(
       stream, streamsPerPeriod, clone, concat, unusedStreamsPerPeriod) {
     // Start by cloning the stream without segments, key IDs, etc.
     const outputStream = clone(stream);
 
     // Find best-matching streams in all periods.
-    const matches = shaka.util.PeriodCombiner.findMatchesInAllPeriods_(
-        streamsPerPeriod, outputStream);
-
-    if (!matches) {
-      // This is not a stream we can build output from, but it may become part
-      // of another output based on another period's stream.
-      return null;
-    }
+    shaka.util.PeriodCombiner.findMatchesInAllPeriods_(streamsPerPeriod,
+        outputStream);
 
     // This only exists where T == Stream.
     if (outputStream.createSegmentIndex) {
+      // Override the createSegmentIndex function of the outputStream.
+      outputStream.createSegmentIndex = async () => {
+        if (!outputStream.segmentIndex) {
+          outputStream.segmentIndex = new shaka.media.MetaSegmentIndex();
+          await shaka.util.PeriodCombiner.extendOutputSegmentIndex_(
+              outputStream, /* firstNewPeriodIndex= */ 0);
+        }
+      };
       // For T == Stream, we need to create all the per-period segment indexes
       // in advance.  concat() will add them to the output's MetaSegmentIndex.
-      await shaka.util.PeriodCombiner.createSegmentIndexes_(matches);
     }
 
-    // Assure the compiler that matches didn't become null during the async
-    // operation above.
-    goog.asserts.assert(matches, 'Matches should be non-null');
-
-    shaka.util.PeriodCombiner.extendOutputStream_(
-        outputStream, matches, /* firstNewPeriodIndex= */ 0, concat,
-        unusedStreamsPerPeriod);
+    if (!outputStream.matchedStreams) {
+      // This is not a stream we can build output from, but it may become part
+      // of another output based on another period's stream.
+      return null;
+    }
+    shaka.util.PeriodCombiner.extendOutputStream_(outputStream,
+        /* firstNewPeriodIndex= */ 0, concat, unusedStreamsPerPeriod);
 
     return outputStream;
   }
@@ -726,7 +743,6 @@ shaka.util.PeriodCombiner = class {
   /**
    * @param {T} outputStream An existing output stream which needs to be
    *   extended into new periods.
-   * @param {!Array.<T>} matches A list of matching Streams from each period.
    * @param {number} firstNewPeriodIndex An index into streamsPerPeriod which
    *   represents the first new period that hasn't been processed yet.
    * @param {function(T, T)} concat Concatenate the second stream onto the end
@@ -740,10 +756,15 @@ shaka.util.PeriodCombiner = class {
    * @private
    */
   static extendOutputStream_(
-      outputStream, matches, firstNewPeriodIndex, concat,
-      unusedStreamsPerPeriod) {
+      outputStream, firstNewPeriodIndex, concat, unusedStreamsPerPeriod) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const LanguageUtils = shaka.util.LanguageUtils;
+    const matches = outputStream.matchedStreams;
+
+    // Assure the compiler that matches didn't become null during the async
+    // operation before.
+    goog.asserts.assert(outputStream.matchedStreams,
+        'matchedStreams should be non-null');
 
     // Concatenate the new matches onto the stream, starting at the first new
     // period.
@@ -787,7 +808,23 @@ shaka.util.PeriodCombiner = class {
     // streams that match this output.
     clone.originalId = null;
     clone.createSegmentIndex = () => Promise.resolve();
-    clone.segmentIndex = new shaka.media.MetaSegmentIndex();
+    clone.closeSegmentIndex = () => {
+      if (clone.segmentIndex) {
+        clone.segmentIndex.release();
+        clone.segmentIndex = null;
+      }
+      // Close the segment index of the matched streams.
+      if (clone.matchedStreams) {
+        for (const match of clone.matchedStreams) {
+          if (match.segmentIndex) {
+            match.segmentIndex.release();
+            match.segmentIndex = null;
+          }
+        }
+      }
+    };
+
+    clone.segmentIndex = null;
     clone.emsgSchemeIdUris = [];
     clone.keyIds = new Set();
     clone.closedCaptions = null;
@@ -873,26 +910,24 @@ shaka.util.PeriodCombiner = class {
       }
     }
 
-    // Satisfy the compiler about the type.
-    goog.asserts.assert(
-        output.segmentIndex instanceof shaka.media.MetaSegmentIndex,
-        'Output streams should have a MetaSegmentIndex!');
-    // Satisfy the compiler that the input index has been created.
-    goog.asserts.assert(
-        input.segmentIndex,
-        'Input segment index should have been created by now!');
-
-    output.segmentIndex.appendSegmentIndex(input.segmentIndex);
-
     // Combine trick-play video streams, if present.
     if (input.trickModeVideo) {
       if (!output.trickModeVideo) {
         // Create a fresh output stream for trick-mode playback.
         output.trickModeVideo = shaka.util.PeriodCombiner.cloneStream_(
             input.trickModeVideo);
-        // Start it with whatever non-trick-mode Streams are in the output so
-        // far.
-        output.trickModeVideo.segmentIndex = output.segmentIndex.clone();
+        // TODO: fix the createSegmentIndex function for trickModeVideo.
+        // The trick-mode tracks in multi-period content should have trick-mode
+        // segment indexes whenever available, rather than only regular-mode
+        // segment indexes.
+        output.trickModeVideo.createSegmentIndex = () => {
+          // Satisfy the compiler about the type.
+          goog.asserts.assert(
+              output.segmentIndex instanceof shaka.media.MetaSegmentIndex,
+              'The stream should have a MetaSegmentIndex.');
+          output.trickModeVideo.segmentIndex = output.segmentIndex.clone();
+          return Promise.resolve();
+        };
       }
 
       // Concatenate the trick mode input onto the trick mode output.
@@ -943,7 +978,6 @@ shaka.util.PeriodCombiner = class {
    *
    * @param {!Array.<!Array.<T>>} streamsPerPeriod
    * @param {T} outputStream
-   * @return {Array.<T>}
    *
    * @template T
    * Accepts either a StreamDB or Stream type.
@@ -956,11 +990,11 @@ shaka.util.PeriodCombiner = class {
       const match = shaka.util.PeriodCombiner.findBestMatchInPeriod_(
           streams, outputStream);
       if (!match) {
-        return null;
+        return;
       }
       matches.push(match);
     }
-    return matches;
+    outputStream.matchedStreams = matches;
   }
 
   /**

package/lib/util/player_configuration.js

@@ -120,6 +120,8 @@ shaka.util.PlayerConfiguration = class {
         ignoreTextStreamFailures: false,
         ignoreImageStreamFailures: false,
         useFullSegmentsForStartTime: false,
+        defaultAudioCodec: 'mp4a.40.2',
+        defaultVideoCodec: 'avc1.42E01E',
       },
     };
 
@@ -163,6 +165,8 @@ shaka.util.PlayerConfiguration = class {
       forceHTTPS: false,
       preferNativeHls: false,
       updateIntervalSeconds: 1,
+      dispatchAllEmsgBoxes: false,
+      observeQualityChanges: false,
     };
 
     // Some browsers will stop earlier than others before a gap (e.g., Edge
@@ -235,6 +239,19 @@ shaka.util.PlayerConfiguration = class {
         minBandwidth: 0,
         maxBandwidth: Infinity,
       },
+      advanced: {
+        minTotalBytes: 128e3,
+        minBytes: 16e3,
+        fastHalfLife: 2,
+        slowHalfLife: 5,
+      },
+    };
+
+    const cmcd = {
+      enabled: false,
+      sessionId: '',
+      contentId: '',
+      useHeaders: false,
     };
 
     /** @type {shaka.extern.PlayerConfiguration} */
@@ -269,6 +286,7 @@ shaka.util.PlayerConfiguration = class {
       playRangeStart: 0,
       playRangeEnd: Infinity,
       textDisplayFactory: () => null,
+      cmcd: cmcd,
     };
 
     // Add this callback so that we can reference the preferred audio language

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "3.2.2",
+  "version": "3.3.0",
   "homepage": "https://github.com/google/shaka-player",
   "author": "Google",
   "maintainers": [

package/shaka-player.uncompiled.js

@@ -44,6 +44,7 @@ goog.require('shaka.polyfill.PatchedMediaKeysMs');
 goog.require('shaka.polyfill.PatchedMediaKeysNop');
 goog.require('shaka.polyfill.PatchedMediaKeysWebkit');
 goog.require('shaka.polyfill.PiPWebkit');
+goog.require('shaka.polyfill.RandomUUID');
 goog.require('shaka.polyfill.VTTCue');
 goog.require('shaka.polyfill.VideoPlayPromise');
 goog.require('shaka.polyfill.VideoPlaybackQuality');
@@ -70,6 +71,7 @@ goog.require('shaka.ui.AdPosition');
 goog.require('shaka.ui.AirPlayButton');
 goog.require('shaka.ui.BigPlayButton');
 goog.require('shaka.ui.CastButton');
+goog.require('shaka.ui.ContextMenu');
 goog.require('shaka.ui.Element');
 goog.require('shaka.ui.FastForwardButton');
 goog.require('shaka.ui.FullscreenButton');
@@ -85,6 +87,7 @@ goog.require('shaka.ui.RewindButton');
 goog.require('shaka.ui.SkipAdButton');
 goog.require('shaka.ui.SmallPlayButton');
 goog.require('shaka.ui.Spacer');
+goog.require('shaka.ui.StatisticsButton');
 goog.require('shaka.ui.TextSelection');
 goog.require('shaka.ui.VolumeBar');
 goog.require('shaka.util.Dom');

package/test/dash/dash_parser_content_protection_unit.js

@@ -42,6 +42,8 @@ describe('DashParser ContentProtection', () => {
 
     const playerInterface = {
       networkingEngine: netEngine,
+      modifyManifestRequest: (request, manifestInfo) => {},
+      modifySegmentRequest: (request, segmentInfo) => {},
       filter: (manifest) => Promise.resolve(),
       makeTextStreamsForClosedCaptions: (manifest) => {},
       onTimelineRegionAdded: fail,  // Should not have any EventStream elements.

package/test/dash/dash_parser_live_unit.js

@@ -39,6 +39,8 @@ 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.
@@ -364,7 +366,7 @@ describe('DashParser Live', () => {
     });
   }
 
-  it('can add Periods', async () => {
+  it('can add Periods with SegmentTemplate', async () => {
     const template1 = [
       '<MPD type="dynamic" availabilityStartTime="1970-01-01T00:00:00Z"',
       '    suggestedPresentationDelay="PT5S"',
@@ -440,6 +442,104 @@ describe('DashParser Live', () => {
     // two segments (10-14s).
     expect(stream.segmentIndex.find(9)).not.toBe(null);
     expect(stream.segmentIndex.find(13)).not.toBe(null);
+
+    stream.closeSegmentIndex();
+    await stream.createSegmentIndex();
+
+    expect(stream.segmentIndex.find(9)).not.toBe(null);
+    expect(stream.segmentIndex.find(13)).not.toBe(null);
+  });
+
+  it('can add Periods with SegmentList', async () => {
+    const list1 = [
+      '<MPD type="dynamic" availabilityStartTime="1970-01-01T00:00:00Z"',
+      '    suggestedPresentationDelay="PT5S"',
+      '    minimumUpdatePeriod="PT%(updateTime)dS">',
+      '  <Period id="1">',
+      '    <AdaptationSet mimeType="video/mp4">',
+      '      <Representation id="1" bandwidth="500">',
+      '        <BaseURL>http://example.com</BaseURL>',
+      '        <SegmentList>',
+      '          <SegmentURL media="s1.mp4" />',
+      '          <SegmentURL media="s2.mp4" />',
+      '          <SegmentURL media="s3.mp4" />',
+      '          <SegmentTimeline>',
+      '            <S d="10" t="0" r="2"/>',
+      '          </SegmentTimeline>',
+      '        </SegmentList>',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '  </Period>',
+      '</MPD>',
+    ].join('\n');
+    const list2 = [
+      '<MPD type="dynamic" availabilityStartTime="1970-01-01T00:00:00Z"',
+      '    suggestedPresentationDelay="PT5S"',
+      '    minimumUpdatePeriod="PT%(updateTime)dS">',
+      '  <Period id="1" duration="PT40S">',
+      '    <AdaptationSet mimeType="video/mp4">',
+      '      <Representation id="1" bandwidth="500">',
+      '        <BaseURL>http://example.com</BaseURL>',
+      '        <SegmentList>',
+      '          <SegmentURL media="s1.mp4" />',
+      '          <SegmentURL media="s2.mp4" />',
+      '          <SegmentURL media="s3.mp4" />',
+      '          <SegmentURL media="s4.mp4" />',
+      '          <SegmentTimeline>',
+      '            <S d="10" t="0" r="3"/>',
+      '          </SegmentTimeline>',
+      '        </SegmentList>',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '  </Period>',
+      '  <Period id="2">',
+      '    <AdaptationSet mimeType="video/mp4">',
+      '      <Representation id="2" bandwidth="500">',
+      '        <BaseURL>http://example.com</BaseURL>',
+      '        <SegmentList>',
+      '          <SegmentURL media="s1.mp4" />',
+      '          <SegmentURL media="s2.mp4" />',
+      '          <SegmentTimeline>',
+      '            <S d="10" t="0" r="1"/>',
+      '          </SegmentTimeline>',
+      '        </SegmentList>',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '  </Period>',
+      '</MPD>',
+    ].join('\n');
+    const firstManifest = sprintf(list1, {updateTime: updateTime});
+    const secondManifest = sprintf(list2, {updateTime: updateTime});
+
+    fakeNetEngine.setResponseText('dummy://foo', firstManifest);
+    // First three segments should exist.
+    Date.now = () => 5;
+
+    const manifest = await parser.start('dummy://foo', playerInterface);
+    const variant = manifest.variants[0];
+    const stream = variant.video;
+    await stream.createSegmentIndex();
+
+    // First three segments exist, but not the fourth.
+    expect(stream.segmentIndex.find(25)).not.toBe(null);
+    expect(stream.segmentIndex.find(45)).toBe(null);
+
+    fakeNetEngine.setResponseText('dummy://foo', secondManifest);
+    Date.now = () => 25;
+
+    await updateManifest();
+
+    // The update should have affected the same variant object we captured
+    // before.  Now the entire first period should exist (0-40s), plus the next
+    // two segments of the second period(40-60s).
+    expect(stream.segmentIndex.find(25)).not.toBe(null);
+    expect(stream.segmentIndex.find(45)).not.toBe(null);
+
+    stream.closeSegmentIndex();
+    await stream.createSegmentIndex();
+
+    expect(stream.segmentIndex.find(25)).not.toBe(null);
+    expect(stream.segmentIndex.find(45)).not.toBe(null);
   });
 
   it('uses redirect URL for manifest BaseURL and updates', async () => {