shaka-player 3.3.4 → 4.0.1

package/lib/player.js

@@ -43,7 +43,6 @@ goog.require('shaka.util.Error');
 goog.require('shaka.util.EventManager');
 goog.require('shaka.util.FakeEvent');
 goog.require('shaka.util.FakeEventTarget');
-goog.require('shaka.util.Functional');
 goog.require('shaka.util.IDestroyable');
 goog.require('shaka.util.LanguageUtils');
 goog.require('shaka.util.ManifestParserUtils');
@@ -301,22 +300,6 @@ goog.requireType('shaka.routing.Payload');
  */
 
 
-/**
- * @event shaka.Player.LargeGapEvent
- * @description Fired when the playhead enters a large gap.  If the
- *   <code>streaming.jumpLargeGaps</code> configuration is set, the default
- *   action of this event is to jump the gap; this can be prevented by calling
- *   <code>preventDefault()</code> on the event object.
- * @property {string} type
- *   'largegap'
- * @property {number} currentTime
- *   The current time of the playhead.
- * @property {number} gapSize
- *   The size of the gap, in seconds.
- * @exportDoc
- */
-
-
 /**
  * @event shaka.Player.ManifestParsedEvent
  * @description Fired after the manifest has been parsed, but before anything
@@ -440,8 +423,23 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
      */
     this.isTextVisible_ = false;
 
-    /** @private {shaka.util.EventManager} */
-    this.eventManager_ = new shaka.util.EventManager();
+    /**
+     * For listeners scoped to the lifetime of the Player instance.
+     * @private {shaka.util.EventManager}
+     */
+    this.globalEventManager_ = new shaka.util.EventManager();
+
+    /**
+     * For listeners scoped to the lifetime of the media element attachment.
+     * @private {shaka.util.EventManager}
+     */
+    this.attachEventManager_ = new shaka.util.EventManager();
+
+    /**
+     * For listeners scoped to the lifetime of the loaded content.
+     * @private {shaka.util.EventManager}
+     */
+    this.loadEventManager_ = new shaka.util.EventManager();
 
     /** @private {shaka.net.NetworkingEngine} */
     this.networkingEngine_ = null;
@@ -576,13 +574,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.adManager_ = null;
 
     if (shaka.Player.adManagerFactory_) {
-      this.adManager_ =
-          shaka.util.Functional.callFactory(shaka.Player.adManagerFactory_);
+      this.adManager_ = shaka.Player.adManagerFactory_();
     }
 
     // If the browser comes back online after being offline, then try to play
     // again.
-    this.eventManager_.listen(window, 'online', () => {
+    this.globalEventManager_.listen(window, 'online', () => {
       this.retryStreaming();
     });
 
@@ -770,10 +767,18 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     });
     await this.walker_.destroy();
 
-    // Tear-down the event manager to ensure messages stop moving around.
-    if (this.eventManager_) {
-      this.eventManager_.release();
-      this.eventManager_ = null;
+    // Tear-down the event managers to ensure handlers stop firing.
+    if (this.globalEventManager_) {
+      this.globalEventManager_.release();
+      this.globalEventManager_ = null;
+    }
+    if (this.attachEventManager_) {
+      this.attachEventManager_.release();
+      this.attachEventManager_ = null;
+    }
+    if (this.loadEventManager_) {
+      this.loadEventManager_.release();
+      this.loadEventManager_ = null;
     }
 
     this.abrManagerFactory_ = null;
@@ -847,10 +852,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return false;
     }
 
-    // We do not support iOS 9, 10, or 11, nor those same versions of desktop
-    // Safari.
+    // We do not support iOS 9, 10, 11 or 12, nor those same versions of
+    // desktop Safari.
     const safariVersion = shaka.util.Platform.safariVersion();
-    if (safariVersion && safariVersion < 12) {
+    if (safariVersion && safariVersion < 13) {
       return false;
     }
 
@@ -1316,7 +1321,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       has.mediaElement = wants.mediaElement;
 
       const onError = (error) => this.onVideoError_(error);
-      this.eventManager_.listen(has.mediaElement, 'error', onError);
+      this.attachEventManager_.listen(has.mediaElement, 'error', onError);
     }
 
     this.video_ = has.mediaElement;
@@ -1343,10 +1348,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @private
    */
   onDetach_(has, wants) {
-    // If we are going from "detached" to "detached" we wouldn't have
+    // If we were going from "detached" to "detached" we wouldn't have
     // a media element to detach from.
     if (has.mediaElement) {
-      this.eventManager_.unlisten(has.mediaElement, 'error');
+      this.attachEventManager_.removeAll();
       has.mediaElement = null;
     }
 
@@ -1404,11 +1409,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // In most cases we should have a media element. The one exception would
     // be if there was an error and we, by chance, did not have a media element.
     if (has.mediaElement) {
-      this.eventManager_.unlisten(has.mediaElement, 'loadedmetadata');
-      this.eventManager_.unlisten(has.mediaElement, 'playing');
-      this.eventManager_.unlisten(has.mediaElement, 'pause');
-      this.eventManager_.unlisten(has.mediaElement, 'ended');
-      this.eventManager_.unlisten(has.mediaElement, 'ratechange');
+      this.loadEventManager_.removeAll();
     }
 
     // Some observers use some playback components, shutting down the observers
@@ -1560,8 +1561,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // text displayer and streaming engine are always in sync, wait until they
     // are both initialized before setting the initial value.
     const textDisplayerFactory = this.config_.textDisplayFactory;
-    const textDisplayer =
-        shaka.util.Functional.callFactory(textDisplayerFactory);
+    const textDisplayer = textDisplayerFactory();
     this.lastTextFactory_ = textDisplayerFactory;
 
     const mediaSourceEngine = this.createMediaSourceEngine(
@@ -1571,6 +1571,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         (metadata, offset, endTime) => {
           this.processTimedMetadataMediaSrc_(metadata, offset, endTime);
         });
+    const {segmentRelativeVttTiming} = this.config_.manifest;
+    mediaSourceEngine.setSegmentRelativeVttTiming(segmentRelativeVttTiming);
 
     // Wait for media source engine to finish opening. This promise should
     // NEVER be rejected as per the media source engine implementation.
@@ -1632,7 +1634,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.config_.manifest.retryParameters,
         has.mimeType);
     goog.asserts.assert(this.parserFactory_, 'Must have manifest parser');
-    this.parser_ = shaka.util.Functional.callFactory(this.parserFactory_);
+    this.parser_ = this.parserFactory_();
 
     const manifestConfig =
         shaka.util.ObjectUtils.cloneObject(this.config_.manifest);
@@ -1902,29 +1904,23 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.assetUri_ = assetUri;
 
     this.playRateController_ = new shaka.media.PlayRateController({
-      getRate: () => has.mediaElement.playbackRate,
-      getDefaultRate: () => has.mediaElement.defaultPlaybackRate,
-      setRate: (rate) => { has.mediaElement.playbackRate = rate; },
-      movePlayhead: (delta) => { has.mediaElement.currentTime += delta; },
+      getRate: () => mediaElement.playbackRate,
+      getDefaultRate: () => mediaElement.defaultPlaybackRate,
+      setRate: (rate) => { mediaElement.playbackRate = rate; },
+      movePlayhead: (delta) => { mediaElement.currentTime += delta; },
     });
 
     const updateStateHistory = () => this.updateStateHistory_();
     const onRateChange = () => this.onRateChange_();
-    this.eventManager_.listen(mediaElement, 'playing', updateStateHistory);
-    this.eventManager_.listen(mediaElement, 'pause', updateStateHistory);
-    this.eventManager_.listen(mediaElement, 'ended', updateStateHistory);
-    this.eventManager_.listen(mediaElement, 'ratechange', onRateChange);
+    this.loadEventManager_.listen(mediaElement, 'playing', updateStateHistory);
+    this.loadEventManager_.listen(mediaElement, 'pause', updateStateHistory);
+    this.loadEventManager_.listen(mediaElement, 'ended', updateStateHistory);
+    this.loadEventManager_.listen(mediaElement, 'ratechange', onRateChange);
 
     const abrFactory = this.config_.abrFactory;
     if (!this.abrManager_ || this.abrManagerFactory_ != abrFactory) {
       this.abrManagerFactory_ = abrFactory;
-      this.abrManager_ = shaka.util.Functional.callFactory(abrFactory);
-      if (typeof this.abrManager_.playbackRateChanged != 'function') {
-        shaka.Deprecate.deprecateFeature(4,
-            'AbrManager',
-            'Please use an AbrManager with playbackRateChanged function.');
-        this.abrManager_.playbackRateChanged = (rate) => {};
-      }
+      this.abrManager_ = abrFactory();
       this.abrManager_.configure(this.config_.abr);
     }
 
@@ -1976,6 +1972,24 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // "streaming" so that they can access internal information.
     this.loadMode_ = shaka.Player.LoadMode.MEDIA_SOURCE;
 
+    if (mediaElement.textTracks) {
+      this.loadEventManager_.listen(
+          mediaElement.textTracks, 'addtrack', (e) => {
+            const trackEvent = /** @type {!TrackEvent} */(e);
+            if (trackEvent.track) {
+              const track = trackEvent.track;
+              goog.asserts.assert(
+                  track instanceof TextTrack, 'Wrong track type!');
+
+              switch (track.kind) {
+                case 'chapters':
+                  this.activateChaptersTrack_(track);
+                  break;
+              }
+            }
+          });
+    }
+
     // The event must be fired after we filter by restrictions but before the
     // active stream is picked to allow those listening for the "streaming"
     // event to make changes before streaming starts.
@@ -2062,7 +2076,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     // Wait for the 'loadedmetadata' event to measure load() latency.
-    this.eventManager_.listenOnce(mediaElement, 'loadedmetadata', () => {
+    this.loadEventManager_.listenOnce(mediaElement, 'loadedmetadata', () => {
       const now = Date.now() / 1000;
       const delta = now - wants.startTimeOfLoad;
       this.stats_.setLoadLatency(delta);
@@ -2215,11 +2229,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // Save the uri so that it can be used outside of the load-graph.
     this.assetUri_ = has.uri;
 
-    this.playhead_ = new shaka.media.SrcEqualsPlayhead(has.mediaElement);
+    const mediaElement = has.mediaElement;
+
+    this.playhead_ = new shaka.media.SrcEqualsPlayhead(mediaElement);
 
-    // This flag is used below in the language preference setup and
-    // track-management to check if this load was canceled before the necessary
-    // events fired.
+    // This flag is used below in the language preference setup to check if
+    // this load was canceled before the necessary awaits completed.
     let unloaded = false;
     this.cleanupOnUnload_.push(() => {
       unloaded = true;
@@ -2230,10 +2245,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     this.playRateController_ = new shaka.media.PlayRateController({
-      getRate: () => has.mediaElement.playbackRate,
-      getDefaultRate: () => has.mediaElement.defaultPlaybackRate,
-      setRate: (rate) => { has.mediaElement.playbackRate = rate; },
-      movePlayhead: (delta) => { has.mediaElement.currentTime += delta; },
+      getRate: () => mediaElement.playbackRate,
+      getDefaultRate: () => mediaElement.defaultPlaybackRate,
+      setRate: (rate) => { mediaElement.playbackRate = rate; },
+      movePlayhead: (delta) => { mediaElement.currentTime += delta; },
     });
 
     // We need to start the buffer management code near the end because it will
@@ -2245,17 +2260,17 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // Add all media element listeners.
     const updateStateHistory = () => this.updateStateHistory_();
     const onRateChange = () => this.onRateChange_();
-    this.eventManager_.listen(has.mediaElement, 'playing', updateStateHistory);
-    this.eventManager_.listen(has.mediaElement, 'pause', updateStateHistory);
-    this.eventManager_.listen(has.mediaElement, 'ended', updateStateHistory);
-    this.eventManager_.listen(has.mediaElement, 'ratechange', onRateChange);
+    this.loadEventManager_.listen(mediaElement, 'playing', updateStateHistory);
+    this.loadEventManager_.listen(mediaElement, 'pause', updateStateHistory);
+    this.loadEventManager_.listen(mediaElement, 'ended', updateStateHistory);
+    this.loadEventManager_.listen(mediaElement, 'ratechange', onRateChange);
 
     // Wait for the 'loadedmetadata' event to measure load() latency, but only
     // if preload is set in a way that would result in this event firing
     // automatically.
     // See https://github.com/shaka-project/shaka-player/issues/2483
-    if (this.video_.preload != 'none') {
-      this.eventManager_.listenOnce(this.video_, 'loadedmetadata', () => {
+    if (mediaElement.preload != 'none') {
+      this.loadEventManager_.listenOnce(mediaElement, 'loadedmetadata', () => {
         const now = Date.now() / 1000;
         const delta = now - wants.startTimeOfLoad;
         this.stats_.setLoadLatency(delta);
@@ -2265,44 +2280,47 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // The audio tracks are only available on Safari at the moment, but this
     // drives the tracks API for Safari's native HLS. So when they change,
     // fire the corresponding Shaka Player event.
-    if (this.video_.audioTracks) {
-      this.eventManager_.listen(
-          this.video_.audioTracks, 'addtrack', () => this.onTracksChanged_());
-      this.eventManager_.listen(
-          this.video_.audioTracks, 'removetrack',
+    if (mediaElement.audioTracks) {
+      this.loadEventManager_.listen(
+          mediaElement.audioTracks, 'addtrack', () => this.onTracksChanged_());
+      this.loadEventManager_.listen(
+          mediaElement.audioTracks, 'removetrack',
           () => this.onTracksChanged_());
-      this.eventManager_.listen(
-          this.video_.audioTracks, 'change', () => this.onTracksChanged_());
-    }
-    if (this.video_.textTracks) {
-      this.eventManager_.listen(this.video_.textTracks, 'addtrack', (e) => {
-        // If we have moved on to another piece of content while waiting for
-        // the above event, we should not process tracks here.
-        if (unloaded) {
-          return;
-        }
+      this.loadEventManager_.listen(
+          mediaElement.audioTracks, 'change', () => this.onTracksChanged_());
+    }
+
+    if (mediaElement.textTracks) {
+      this.loadEventManager_.listen(
+          mediaElement.textTracks, 'addtrack', (e) => {
+            const trackEvent = /** @type {!TrackEvent} */(e);
+            if (trackEvent.track) {
+              const track = trackEvent.track;
+              goog.asserts.assert(
+                  track instanceof TextTrack, 'Wrong track type!');
+
+              switch (track.kind) {
+                case 'metadata':
+                  this.processTimedMetadataSrcEqls_(track);
+                  break;
+
+                case 'chapters':
+                  this.activateChaptersTrack_(track);
+                  break;
+
+                default:
+                  this.onTracksChanged_();
+                  break;
+              }
+            }
+          });
 
-        const trackEvent = /** @type {!TrackEvent} */(e);
-        if (trackEvent.track) {
-          const track = trackEvent.track;
-          goog.asserts.assert(track instanceof TextTrack, 'Wrong track type!');
-          switch (track.kind) {
-            case 'metadata':
-              this.processTimedMetadataSrcEqls_(track);
-              break;
-            case 'chapters':
-              this.processChaptersTrack_(track);
-              break;
-            default:
-              this.onTracksChanged_();
-              break;
-          }
-        }
-      });
-      this.eventManager_.listen(
-          this.video_.textTracks, 'removetrack', () => this.onTracksChanged_());
-      this.eventManager_.listen(
-          this.video_.textTracks, 'change', () => this.onTracksChanged_());
+      this.loadEventManager_.listen(
+          mediaElement.textTracks, 'removetrack',
+          () => this.onTracksChanged_());
+      this.loadEventManager_.listen(
+          mediaElement.textTracks, 'change',
+          () => this.onTracksChanged_());
     }
 
     const extension = shaka.media.ManifestParser.getExtension(has.uri);
@@ -2311,14 +2329,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     // By setting |src| we are done "loading" with src=. We don't need to set
     // the current time because |playhead| will do that for us.
-    has.mediaElement.src = this.cmcdManager_.appendSrcData(has.uri, mimeType);
+    mediaElement.src = this.cmcdManager_.appendSrcData(has.uri, mimeType);
 
     // Tizen 3 / WebOS won't load anything unless you call load() explicitly,
     // no matter the value of the preload attribute.  This is harmful on some
     // other platforms by triggering unbounded loading of media data, but is
     // necessary here.
     if (shaka.util.Platform.isTizen() || shaka.util.Platform.isWebOS()) {
-      has.mediaElement.load();
+      mediaElement.load();
     }
 
     // Set the load mode last so that we know that all our components are
@@ -2334,24 +2352,18 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // wait for the full data, that won't happen on Safari until the play button
     // is hit.
     const fullyLoaded = new shaka.util.PublicPromise();
-    shaka.util.MediaReadyState.waitForReadyState(this.video_,
+    shaka.util.MediaReadyState.waitForReadyState(mediaElement,
         HTMLMediaElement.HAVE_METADATA,
-        this.eventManager_,
+        this.loadEventManager_,
         () => {
           fullyLoaded.resolve();
         });
 
     // We can't switch to preferred languages, though, until the data is loaded.
-    shaka.util.MediaReadyState.waitForReadyState(this.video_,
+    shaka.util.MediaReadyState.waitForReadyState(mediaElement,
         HTMLMediaElement.HAVE_CURRENT_DATA,
-        this.eventManager_,
+        this.loadEventManager_,
         async () => {
-          // If we have moved on to another piece of content while waiting for
-          // the above event, we should not change tracks here.
-          if (unloaded) {
-            return;
-          }
-
           this.setupPreferredAudioOnSrc_();
 
           // Applying the text preference too soon can result in it being
@@ -2359,8 +2371,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           const textTracks = this.getFilteredTextTracks_();
           if (!textTracks.find((t) => t.mode != 'disabled')) {
             await new Promise((resolve) => {
-              this.eventManager_.listenOnce(
-                  this.video_.textTracks, 'change', resolve);
+              this.loadEventManager_.listenOnce(
+                  mediaElement.textTracks, 'change', resolve);
+
               // We expect the event to fire because it does on Safari.
               // But in case it doesn't on some other platform or future
               // version, move on in 1 second no matter what.  This keeps the
@@ -2379,10 +2392,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           this.setupPreferredTextOnSrc_();
         });
 
-    if (this.video_.error) {
+    if (mediaElement.error) {
       // Already failed!
       fullyLoaded.reject(this.videoErrorToShakaError_());
-    } else if (this.video_.preload == 'none') {
+    } else if (mediaElement.preload == 'none') {
       shaka.log.alwaysWarn(
           'With <video preload="none">, the browser will not load anything ' +
           'until play() is called. We are unable to measure load latency in ' +
@@ -2393,7 +2406,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       fullyLoaded.resolve();
     }
 
-    this.eventManager_.listenOnce(this.video_, 'error', () => {
+    this.loadEventManager_.listenOnce(mediaElement, 'error', () => {
       fullyLoaded.reject(this.videoErrorToShakaError_());
     });
 
@@ -2477,7 +2490,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     // Hidden mode is required for the cuechange event to launch correctly
     track.mode = 'hidden';
-    this.eventManager_.listen(track, 'cuechange', () => {
+    this.loadEventManager_.listen(track, 'cuechange', () => {
       if (!track.activeCues) {
         return;
       }
@@ -2555,12 +2568,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   }
 
   /**
-   * We're looking for chapters tracks to process the chapters.
+   * Set the mode on a chapters track so that it loads.
    *
    * @param {?TextTrack} track
    * @private
    */
-  processChaptersTrack_(track) {
+  activateChaptersTrack_(track) {
     if (!track || track.kind != 'chapters') {
       return;
     }
@@ -2573,10 +2586,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // this process to be repeated several times to ensure that it has been put
     // in the correct mode.
     const timer = new shaka.util.Timer(() => {
-      const chaptersTracks = this.getChaptersTracks_();
-      for (const chaptersTrack of chaptersTracks) {
-        chaptersTrack.mode = 'hidden';
-      }
+      track.mode = 'hidden';
     }).tickNow().tickAfter(0.5);
 
     this.cleanupOnUnload_.push(() => {
@@ -2683,8 +2693,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.manifest_,
         this.config_.streaming,
         startTime,
-        () => this.onSeek_(),
-        (event) => this.dispatchEvent(event));
+        () => this.onSeek_());
   }
 
   /**
@@ -2943,17 +2952,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     goog.asserts.assert(typeof(config) == 'object', 'Should be an object!');
 
-    // Deprecate 'manifest.dash.defaultPresentationDelay' configuration.
-    if (config['manifest'] && config['manifest']['dash'] &&
-          'defaultPresentationDelay' in config['manifest']['dash']) {
-      shaka.Deprecate.deprecateFeature(4,
-          'manifest.dash.defaultPresentationDelay configuration',
-          'Please Use manifest.defaultPresentationDelay instead.');
-      config['manifest']['defaultPresentationDelay'] =
-          config['manifest']['dash']['defaultPresentationDelay'];
-      delete config['manifest']['dash']['defaultPresentationDelay'];
-    }
-
     // If lowLatencyMode is enabled, and inaccurateManifestTolerance and
     // rebufferingGoal are not specified, set inaccurateManifestTolerance to 0
     // and rebufferingGoal to 0.01 by default for low latency streaming.
@@ -3020,10 +3018,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     if (this.mediaSourceEngine_) {
+      const {segmentRelativeVttTiming} = this.config_.manifest;
+      this.mediaSourceEngine_.setSegmentRelativeVttTiming(
+          segmentRelativeVttTiming);
+
       const textDisplayerFactory = this.config_.textDisplayFactory;
       if (this.lastTextFactory_ != textDisplayerFactory) {
-        const displayer =
-            shaka.util.Functional.callFactory(textDisplayerFactory);
+        const displayer = textDisplayerFactory();
         this.mediaSourceEngine_.setTextDisplayer(displayer);
         this.lastTextFactory_ = textDisplayerFactory;
 
@@ -4408,158 +4409,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     return this.stats_.getBlob();
   }
 
-  /**
-   * Adds the given text track to the loaded manifest.  <code>load()</code> must
-   * resolve before calling.  The presentation must have a duration.
-   *
-   * This returns the created track, which can immediately be selected by the
-   * application.  The track will not be automatically selected.
-   *
-   * @param {string} uri
-   * @param {string} language
-   * @param {string} kind
-   * @param {string=} mimeType
-   * @param {string=} codec
-   * @param {string=} label
-   * @param {boolean=} forced
-   * @return {shaka.extern.Track}
-   * @export
-   */
-  addTextTrack(uri, language, kind, mimeType, codec, label, forced = false) {
-    shaka.Deprecate.deprecateFeature(4,
-        'addTextTrack',
-        'Please use an addTextTrackAsync.');
-    if (this.loadMode_ != shaka.Player.LoadMode.MEDIA_SOURCE &&
-        this.loadMode_ != shaka.Player.LoadMode.SRC_EQUALS) {
-      shaka.log.error(
-          'Must call load() and wait for it to resolve before adding text ' +
-          'tracks.');
-      throw new shaka.util.Error(
-          shaka.util.Error.Severity.RECOVERABLE,
-          shaka.util.Error.Category.PLAYER,
-          shaka.util.Error.Code.CONTENT_NOT_LOADED);
-    }
-
-    if (!mimeType) {
-      // Try using the uri extension.
-      const extension = shaka.media.ManifestParser.getExtension(uri);
-      mimeType = shaka.Player.TEXT_EXTENSIONS_TO_MIME_TYPES_[extension];
-
-      if (!mimeType) {
-        shaka.log.error(
-            'The mimeType has not been provided and it could not be deduced ' +
-            'from its extension.');
-        throw new shaka.util.Error(
-            shaka.util.Error.Severity.RECOVERABLE,
-            shaka.util.Error.Category.TEXT,
-            shaka.util.Error.Code.TEXT_COULD_NOT_GUESS_MIME_TYPE,
-            extension);
-      }
-    }
-
-    if (this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS) {
-      if (mimeType != 'text/vtt') {
-        shaka.log.error('Only WebVTT is supported when using src=');
-        throw new shaka.util.Error(
-            shaka.util.Error.Severity.RECOVERABLE,
-            shaka.util.Error.Category.TEXT,
-            shaka.util.Error.Code.TEXT_ONLY_WEBVTT_SRC_EQUALS,
-            mimeType);
-      }
-      if (forced) {
-        // See: https://github.com/whatwg/html/issues/4472
-        kind = 'forced';
-      }
-      const trackElement =
-        /** @type {!HTMLTrackElement} */(document.createElement('track'));
-      trackElement.src = this.cmcdManager_.appendTextTrackData(uri);
-      trackElement.label = label || '';
-      trackElement.kind = kind;
-      trackElement.srclang = language;
-      // Because we're pulling in the text track file via Javascript, the
-      // same-origin policy applies. If you'd like to have a player served
-      // from one domain, but the text track served from another, you'll
-      // need to enable CORS in order to do so. In addition to enabling CORS
-      // on the server serving the text tracks, you will need to add the
-      // crossorigin attribute to the video element itself.
-      if (!this.video_.getAttribute('crossorigin')) {
-        this.video_.setAttribute('crossorigin', 'anonymous');
-      }
-      this.video_.appendChild(trackElement);
-      const textTracks = this.getTextTracks();
-      const srcTrack = textTracks.find((t) => {
-        return t.language == language &&
-            t.label == (label || '') &&
-            t.kind == kind;
-      });
-      if (srcTrack) {
-        this.onTracksChanged_();
-        return srcTrack;
-      }
-      // This should not happen, but there are browser implementations that may
-      // not support the Track element.
-      shaka.log.error('Cannot add this text when loaded with src=');
-      throw new shaka.util.Error(
-          shaka.util.Error.Severity.RECOVERABLE,
-          shaka.util.Error.Category.TEXT,
-          shaka.util.Error.Code.CANNOT_ADD_EXTERNAL_TEXT_TO_SRC_EQUALS);
-    }
-
-    const ContentType = shaka.util.ManifestParserUtils.ContentType;
-
-    const duration = this.manifest_.presentationTimeline.getDuration();
-    if (duration == Infinity) {
-      throw new shaka.util.Error(
-          shaka.util.Error.Severity.RECOVERABLE,
-          shaka.util.Error.Category.MANIFEST,
-          shaka.util.Error.Code.CANNOT_ADD_EXTERNAL_TEXT_TO_LIVE_STREAM);
-    }
-
-    /** @type {shaka.extern.Stream} */
-    const stream = {
-      id: this.nextExternalStreamId_++,
-      originalId: null,
-      createSegmentIndex: () => Promise.resolve(),
-      segmentIndex: shaka.media.SegmentIndex.forSingleSegment(
-          /* startTime= */ 0,
-          /* duration= */ duration,
-          /* uris= */ [uri]),
-      mimeType: mimeType || '',
-      codecs: codec || '',
-      kind: kind,
-      encrypted: false,
-      drmInfos: [],
-      keyIds: new Set(),
-      language: language,
-      label: label || null,
-      type: ContentType.TEXT,
-      primary: false,
-      trickModeVideo: null,
-      emsgSchemeIdUris: null,
-      roles: [],
-      forced: !!forced,
-      channelsCount: null,
-      audioSamplingRate: null,
-      spatialAudio: false,
-      closedCaptions: null,
-    };
-
-    const fullMimeType = shaka.util.MimeUtils.getFullType(
-        stream.mimeType, stream.codecs);
-    const supported = shaka.text.TextEngine.isTypeSupported(fullMimeType);
-    if (!supported) {
-      throw new shaka.util.Error(
-          shaka.util.Error.Severity.CRITICAL,
-          shaka.util.Error.Category.TEXT,
-          shaka.util.Error.Code.MISSING_TEXT_PLUGIN,
-          mimeType);
-    }
-
-    this.manifest_.textStreams.push(stream);
-    this.onTracksChanged_();
-    return shaka.util.StreamUtils.textStreamToTrack(stream);
-  }
-
   /**
    * Adds the given text track to the loaded manifest.  <code>load()</code> must
    * resolve before calling.  The presentation must have a duration.
@@ -4721,25 +4570,41 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (!mimeType) {
       mimeType = await this.getTextMimetype_(uri);
     }
+
     let adCuePoints = [];
     if (this.adManager_) {
       try {
         adCuePoints = this.adManager_.getServerSideCuePoints();
       } catch (error) {}
     }
-    await this.addSrcTrackElement_(uri, language, /* kind= */ 'chapters',
-        mimeType, /* label= */ '', adCuePoints);
+
+    /** @type {!HTMLTrackElement} */
+    const trackElement = await this.addSrcTrackElement_(
+        uri, language, /* kind= */ 'chapters', mimeType, /* label= */ '',
+        adCuePoints);
+
     const chaptersTracks = this.getChaptersTracks();
     const chaptersTrack = chaptersTracks.find((t) => {
       return t.language == language;
     });
+
     if (chaptersTrack) {
-      const html5ChaptersTracks = this.getChaptersTracks_();
-      for (const html5ChaptersTrack of html5ChaptersTracks) {
-        this.processChaptersTrack_(html5ChaptersTrack);
-      }
+      await new Promise((resolve, reject) => {
+        // The chapter data isn't available until the 'load' event fires, and
+        // that won't happen until the chapters track is activated by the
+        // activateChaptersTrack_ method.
+        this.loadEventManager_.listenOnce(trackElement, 'load', resolve);
+        this.loadEventManager_.listenOnce(trackElement, 'error', (event) => {
+          reject(new shaka.util.Error(
+              shaka.util.Error.Severity.RECOVERABLE,
+              shaka.util.Error.Category.TEXT,
+              shaka.util.Error.Code.CHAPTERS_TRACK_FAILED));
+        });
+      });
+
       return chaptersTrack;
     }
+
     // This should not happen, but there are browser implementations that may
     // not support the Track element.
     shaka.log.error('Cannot add this text when loaded with src=');
@@ -4793,6 +4658,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @param {string} mimeType
    * @param {string} label
    * @param {!Array.<!shaka.extern.AdCuePoint>} adCuePoints
+   * @return {!Promise.<!HTMLTrackElement>}
    * @private
    */
   async addSrcTrackElement_(uri, language, kind, mimeType, label,
@@ -4808,12 +4674,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       uri = shaka.media.MediaSourceEngine.createObjectURL(blob);
       mimeType = 'text/vtt';
     }
+
     const trackElement =
       /** @type {!HTMLTrackElement} */(document.createElement('track'));
     trackElement.src = this.cmcdManager_.appendTextTrackData(uri);
     trackElement.label = label;
     trackElement.kind = kind;
     trackElement.srclang = language;
+
     // Because we're pulling in the text track file via Javascript, the
     // same-origin policy applies. If you'd like to have a player served
     // from one domain, but the text track served from another, you'll
@@ -4823,7 +4691,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (!this.video_.getAttribute('crossorigin')) {
       this.video_.setAttribute('crossorigin', 'anonymous');
     }
+
     this.video_.appendChild(trackElement);
+    return trackElement;
   }
 
   /**
@@ -4864,6 +4734,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         periodStart: 0,
         segmentStart: 0,
         segmentEnd: this.video_.duration,
+        vttOffset: 0,
       };
       const data = shaka.util.BufferUtils.toUint8(buffer);
       const cues = obj.parseMedia(data, time);
@@ -5193,7 +5064,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       }
 
       await stream.createSegmentIndex();
-      const ref = stream.segmentIndex[Symbol.iterator]().seek(time);
+      const iter = stream.segmentIndex.getIteratorForTime(time);
+      const ref = iter ? iter.next().value : null;
       if (!ref) {
         return null;
       }
@@ -5862,7 +5734,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }  // if (keyIds.size)
 
     if (tracksChanged) {
-      this.updateAbrManagerVariants_();
+      const variantsUpdated = this.updateAbrManagerVariants_();
+      if (!variantsUpdated) {
+        return;
+      }
     }
 
     const currentVariant = this.streamingEngine_.getCurrentVariant();
@@ -6516,7 +6391,6 @@ shaka.Player.EventName = {
   Emsg: 'emsg',
   Error: 'error',
   ExpirationUpdated: 'expirationupdated',
-  LargeGap: 'largegap',
   Loaded: 'loaded',
   Loading: 'loading',
   ManifestParsed: 'manifestparsed',
@@ -6576,7 +6450,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v3.3.4-uncompiled';
+shaka.Player.version = 'v4.0.1-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.