shaka-player 4.0.0 → 4.1.0

package/lib/player.js

@@ -385,6 +385,26 @@ goog.requireType('shaka.routing.Payload');
  */
 
 
+/**
+ * @event shaka.Player.StallDetectedEvent
+ * @description Fired when a stall in playback is detected by the StallDetector.
+ *     Not all stalls are caused by gaps in the buffered ranges.
+ * @property {string} type
+ *   'stalldetected'
+ * @exportDoc
+ */
+
+
+/**
+ * @event shaka.Player.GapJumpedEvent
+ * @description Fired when the GapJumpingController jumps over a gap in the
+ *     buffered ranges.
+ * @property {string} type
+ *   'gapjumped'
+ * @exportDoc
+ */
+
+
 /**
  * @summary The main player object for Shaka Player.
  *
@@ -423,8 +443,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;
@@ -564,7 +599,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     // 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();
     });
 
@@ -637,7 +672,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       },
       enterNode: (node, has, wants) => {
         this.dispatchEvent(this.makeEvent_(
-            /* name= */ shaka.Player.EventName.OnStateChange,
+            /* name= */ shaka.util.FakeEvent.EventName.OnStateChange,
             /* data= */ (new Map()).set('state', node.name)));
 
         const action = actions.get(node);
@@ -668,7 +703,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       },
       onIdle: (node) => {
         this.dispatchEvent(this.makeEvent_(
-            /* name= */ shaka.Player.EventName.OnStateIdle,
+            /* name= */ shaka.util.FakeEvent.EventName.OnStateIdle,
             /* data= */ (new Map()).set('state', node.name)));
       },
     };
@@ -679,6 +714,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         shaka.Player.createEmptyPayload_(),
         walkerImplementation);
 
+    /** @private {shaka.util.Timer} */
+    this.checkVariantsTimer_ =
+        new shaka.util.Timer(() => this.checkVariants_());
+
     // Even though |attach| will start in later interpreter cycles, it should be
     // the LAST thing we do in the constructor because conceptually it relies on
     // player having been initialized.
@@ -688,7 +727,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   }
 
   /**
-   * @param {!shaka.Player.EventName} name
+   * @param {!shaka.util.FakeEvent.EventName} name
    * @param {Map.<string, Object>=} data
    * @return {!shaka.util.FakeEvent}
    * @private
@@ -752,10 +791,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;
@@ -1106,7 +1153,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     // We dispatch the loading event when someone calls |load| because we want
     // to surface the user intent.
-    this.dispatchEvent(this.makeEvent_(shaka.Player.EventName.Loading));
+    this.dispatchEvent(this.makeEvent_(shaka.util.FakeEvent.EventName.Loading));
 
     // Right away we know what the asset uri and start-of-load time are. We will
     // fill-in the rest of the information later.
@@ -1170,7 +1217,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       events.onEnd = () => {
         resolve();
         // We dispatch the loaded event when the load promise is resolved
-        this.dispatchEvent(this.makeEvent_(shaka.Player.EventName.Loaded));
+        this.dispatchEvent(
+            this.makeEvent_(shaka.util.FakeEvent.EventName.Loaded));
       };
       events.onCancel = () => reject(this.createAbortLoadError_());
       events.onError = (e) => reject(e);
@@ -1298,7 +1346,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;
@@ -1325,10 +1373,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;
     }
 
@@ -1375,7 +1423,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     await Promise.all(cleanupTasks);
 
     // Dispatch the unloading event.
-    this.dispatchEvent(this.makeEvent_(shaka.Player.EventName.Unloading));
+    this.dispatchEvent(
+        this.makeEvent_(shaka.util.FakeEvent.EventName.Unloading));
 
     // Remove everything that has to do with loading content from our payload
     // since we are releasing everything that depended on it.
@@ -1386,13 +1435,12 @@ 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();
     }
 
+    // Stop the variant checker timer
+    this.checkVariantsTimer_.stop();
+
     // Some observers use some playback components, shutting down the observers
     // first ensures that they don't try to use the playback components
     // mid-destroy.
@@ -1680,7 +1728,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.regionTimeline_.addEventListener('regionadd', (event) => {
       /** @type {shaka.extern.TimelineRegionInfo} */
       const region = event['region'];
-      this.onRegionEvent_(shaka.Player.EventName.TimelineRegionAdded, region);
+      this.onRegionEvent_(
+          shaka.util.FakeEvent.EventName.TimelineRegionAdded, region);
 
       if (this.adManager_) {
         this.adManager_.onDashTimedMetadata(region);
@@ -1735,7 +1784,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
       // This event is fired after the manifest is parsed, but before any
       // filtering takes place.
-      const event = this.makeEvent_(shaka.Player.EventName.ManifestParsed);
+      const event =
+          this.makeEvent_(shaka.util.FakeEvent.EventName.ManifestParsed);
       this.dispatchEvent(event);
 
       // We require all manifests to have at least one variant.
@@ -1809,7 +1859,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       },
       onEvent: (e) => {
         this.dispatchEvent(e);
-        if (e.type == shaka.Player.EventName.DrmSessionUpdate && firstEvent) {
+        if (e.type == shaka.util.FakeEvent.EventName.DrmSessionUpdate &&
+            firstEvent) {
           firstEvent = false;
           const now = Date.now() / 1000;
           const delta = now - startTime;
@@ -1885,18 +1936,18 @@ 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) {
@@ -1953,10 +2004,29 @@ 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.
-    this.dispatchEvent(this.makeEvent_(shaka.Player.EventName.Streaming));
+    this.dispatchEvent(
+        this.makeEvent_(shaka.util.FakeEvent.EventName.Streaming));
 
     // Pick the initial streams to play.
     // however, we would skip switch to initial variant
@@ -2039,7 +2109,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);
@@ -2084,7 +2154,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       },
       onEvent: (e) => {
         this.dispatchEvent(e);
-        if (e.type == shaka.Player.EventName.DrmSessionUpdate && firstEvent) {
+        if (e.type == shaka.util.FakeEvent.EventName.DrmSessionUpdate &&
+            firstEvent) {
           firstEvent = false;
           const now = Date.now() / 1000;
           const delta = now - startTime;
@@ -2117,6 +2188,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const variant = {
       id: 0,
       language: 'und',
+      disabledUntilTime: 0,
       primary: false,
       audio: null,
       video: {
@@ -2192,11 +2264,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 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.playhead_ = new shaka.media.SrcEqualsPlayhead(mediaElement);
+
+    // 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;
@@ -2207,10 +2280,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
@@ -2222,17 +2295,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);
@@ -2242,44 +2315,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);
@@ -2288,14 +2364,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
@@ -2305,30 +2381,25 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // The event doesn't mean as much for src= playback, since we don't control
     // streaming.  But we should fire it in this path anyway since some
     // applications may be expecting it as a life-cycle event.
-    this.dispatchEvent(this.makeEvent_(shaka.Player.EventName.Streaming));
+    this.dispatchEvent(
+        this.makeEvent_(shaka.util.FakeEvent.EventName.Streaming));
 
     // The "load" Promise is resolved when we have loaded the metadata.  If we
     // 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
@@ -2336,8 +2407,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
@@ -2356,10 +2428,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 ' +
@@ -2370,7 +2442,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_());
     });
 
@@ -2454,7 +2526,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;
       }
@@ -2522,7 +2594,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   dispatchMetadataEvent_(startTime, endTime, metadataType, payload) {
     goog.asserts.assert(!endTime || startTime <= endTime,
         'Metadata start time should be less or equal to the end time!');
-    const eventName = shaka.Player.EventName.Metadata;
+    const eventName = shaka.util.FakeEvent.EventName.Metadata;
     const data = new Map()
         .set('startTime', startTime)
         .set('endTime', endTime)
@@ -2532,12 +2604,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;
     }
@@ -2550,10 +2622,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(() => {
@@ -2622,7 +2691,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @type {shaka.net.NetworkingEngine.OnHeadersReceived} */
     const onHeadersReceived_ = (headers, request, requestType) => {
       // Release a 'downloadheadersreceived' event.
-      const name = shaka.Player.EventName.DownloadHeadersReceived;
+      const name = shaka.util.FakeEvent.EventName.DownloadHeadersReceived;
       const data = new Map()
           .set('headers', headers)
           .set('request', request)
@@ -2632,7 +2701,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @type {shaka.net.NetworkingEngine.OnDownloadFailed} */
     const onDownloadFailed_ = (request, error, httpResponseCode, aborted) => {
       // Release a 'downloadfailed' event.
-      const name = shaka.Player.EventName.DownloadFailed;
+      const name = shaka.util.FakeEvent.EventName.DownloadFailed;
       const data = new Map()
           .set('request', request)
           .set('error', error)
@@ -2660,7 +2729,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.manifest_,
         this.config_.streaming,
         startTime,
-        () => this.onSeek_());
+        () => this.onSeek_(),
+        (event) => this.dispatchEvent(event));
   }
 
   /**
@@ -2682,13 +2752,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     regionObserver.addEventListener('enter', (event) => {
       /** @type {shaka.extern.TimelineRegionInfo} */
       const region = event['region'];
-      this.onRegionEvent_(shaka.Player.EventName.TimelineRegionEnter, region);
+      this.onRegionEvent_(
+          shaka.util.FakeEvent.EventName.TimelineRegionEnter, region);
     });
 
     regionObserver.addEventListener('exit', (event) => {
       /** @type {shaka.extern.TimelineRegionInfo} */
       const region = event['region'];
-      this.onRegionEvent_(shaka.Player.EventName.TimelineRegionExit, region);
+      this.onRegionEvent_(
+          shaka.util.FakeEvent.EventName.TimelineRegionExit, region);
     });
 
     regionObserver.addEventListener('skip', (event) => {
@@ -2699,8 +2771,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       // If we are seeking, we don't want to surface the enter/exit events since
       // they didn't play through them.
       if (!seeking) {
-        this.onRegionEvent_(shaka.Player.EventName.TimelineRegionEnter, region);
-        this.onRegionEvent_(shaka.Player.EventName.TimelineRegionExit, region);
+        this.onRegionEvent_(
+            shaka.util.FakeEvent.EventName.TimelineRegionEnter, region);
+        this.onRegionEvent_(
+            shaka.util.FakeEvent.EventName.TimelineRegionExit, region);
       }
     });
 
@@ -4056,8 +4130,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     for (const chaptersTrack of chaptersTracksWithLanguage) {
       if (chaptersTrack && chaptersTrack.cues) {
         for (const cue of chaptersTrack.cues) {
+          let id = cue.id;
+          if (!id || id == '') {
+            id = cue.startTime + '-' + cue.endTime + '-' + cue.text;
+          }
           /** @type {shaka.extern.Chapter} */
           const chapter = {
+            id: id,
             title: cue.text,
             startTime: cue.startTime,
             endTime: cue.endTime,
@@ -4322,6 +4401,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.stats_.setCompletionPercent(Math.round(100 * completionRatio));
     }
 
+    if (this.playhead_) {
+      this.stats_.setGapsJumped(this.playhead_.getGapsJumped());
+      this.stats_.setStallsDetected(this.playhead_.getStallsDetected());
+    }
+
     if (element.getVideoPlaybackQuality) {
       const info = element.getVideoPlaybackQuality();
 
@@ -4537,25 +4621,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=');
@@ -4609,6 +4709,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,
@@ -4624,12 +4725,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
@@ -4639,7 +4742,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (!this.video_.getAttribute('crossorigin')) {
       this.video_.setAttribute('crossorigin', 'anonymous');
     }
+
     this.video_.appendChild(trackElement);
+    return trackElement;
   }
 
   /**
@@ -5010,7 +5115,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;
       }
@@ -5063,7 +5169,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     // Surface the buffering event so that the app knows if/when we are
     // buffering.
-    const eventName = shaka.Player.EventName.Buffering;
+    const eventName = shaka.util.FakeEvent.EventName.Buffering;
     const data = (new Map()).set('buffering', isBuffering);
     this.dispatchEvent(this.makeEvent_(eventName, data));
   }
@@ -5098,7 +5204,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.playRateController_.set(newRate);
     }
 
-    const event = this.makeEvent_(shaka.Player.EventName.RateChange);
+    const event = this.makeEvent_(shaka.util.FakeEvent.EventName.RateChange);
     this.dispatchEvent(event);
   }
 
@@ -5198,6 +5304,21 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
   }
 
+  /**
+   * Re-apply restrictions to the variants, to re-enable variants that were
+   * temporarily disabled due to network errors.
+   * If any variants are enabled this way, a new variant might be chosen for
+   * playback.
+   * @private
+   */
+  checkVariants_() {
+    const tracksChanged = shaka.util.StreamUtils.applyRestrictions(
+        this.manifest_.variants, this.config_.restrictions, this.maxHwRes_);
+    if (tracksChanged) {
+      this.chooseVariant_();
+    }
+  }
+
   /**
    * Choose a text stream from all possible text streams while taking into
    * account user preference.
@@ -5430,7 +5551,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const data = new Map()
         .set('oldTrack', from)
         .set('newTrack', to);
-    const event = this.makeEvent_(shaka.Player.EventName.Adaptation, data);
+    const event =
+        this.makeEvent_(shaka.util.FakeEvent.EventName.Adaptation, data);
     this.delayDispatchEvent_(event);
   }
 
@@ -5441,7 +5563,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   onTracksChanged_() {
     // Delay the 'trackschanged' event so StreamingEngine has time to absorb the
     // changes before the user tries to query it.
-    const event = this.makeEvent_(shaka.Player.EventName.TracksChanged);
+    const event = this.makeEvent_(shaka.util.FakeEvent.EventName.TracksChanged);
     this.delayDispatchEvent_(event);
   }
 
@@ -5457,7 +5579,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const data = new Map()
         .set('oldTrack', from)
         .set('newTrack', to);
-    const event = this.makeEvent_(shaka.Player.EventName.VariantChanged, data);
+    const event =
+        this.makeEvent_(shaka.util.FakeEvent.EventName.VariantChanged, data);
     this.delayDispatchEvent_(event);
   }
 
@@ -5468,13 +5591,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   onTextChanged_() {
     // Delay the 'textchanged' event so StreamingEngine time to absorb the
     // changes before the user tries to query it.
-    const event = this.makeEvent_(shaka.Player.EventName.TextChanged);
+    const event = this.makeEvent_(shaka.util.FakeEvent.EventName.TextChanged);
     this.delayDispatchEvent_(event);
   }
 
   /** @private */
   onTextTrackVisibility_() {
-    const event = this.makeEvent_(shaka.Player.EventName.TextTrackVisibility);
+    const event =
+        this.makeEvent_(shaka.util.FakeEvent.EventName.TextTrackVisibility);
     this.delayDispatchEvent_(event);
   }
 
@@ -5482,7 +5606,73 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   onAbrStatusChanged_() {
     const data = (new Map()).set('newStatus', this.config_.abr.enabled);
     this.delayDispatchEvent_(this.makeEvent_(
-        shaka.Player.EventName.AbrStatusChanged, data));
+        shaka.util.FakeEvent.EventName.AbrStatusChanged, data));
+  }
+
+  /**
+   * Tries to recover from NETWORK HTTP_ERROR, temporary disabling the current
+   * problematic variant.
+   * @param {!shaka.util.Error} error
+   * @return {boolean}
+   * @private
+   */
+  tryToRecoverFromError_(error) {
+    if ((error.code != shaka.util.Error.Code.HTTP_ERROR &&
+      error.code != shaka.util.Error.Code.SEGMENT_MISSING) ||
+      error.category != shaka.util.Error.Category.NETWORK) {
+      return false;
+    }
+
+    let maxDisabledTime = this.config_.streaming.maxDisabledTime;
+    if (maxDisabledTime == 0) {
+      if (error.code == shaka.util.Error.Code.SEGMENT_MISSING) {
+        // Spec: https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis#section-6.3.3
+        // The client SHOULD NOT attempt to load Media Segments that have been
+        // marked with an EXT-X-GAP tag, or to load Partial Segments with a
+        // GAP=YES attribute. Instead, clients are encouraged to look for
+        // another Variant Stream of the same Rendition which does not have the
+        // same gap, and play that instead.
+        maxDisabledTime = 1;
+      } else {
+        return false;
+      }
+    }
+
+    if (error.code == shaka.util.Error.Code.HTTP_ERROR) {
+      shaka.log.debug('Recoverable NETWORK HTTP_ERROR, trying to recover...');
+    }
+
+    // Obtain the active variant and disable it from manifest variants
+    const activeVariantTrack = this.getVariantTracks().find((t) => t.active);
+    goog.asserts.assert(activeVariantTrack, 'Active variant should be found');
+    const manifest = this.manifest_;
+    for (const variant of manifest.variants) {
+      if (variant.id === activeVariantTrack.id) {
+        variant.disabledUntilTime = (Date.now() / 1000) + maxDisabledTime;
+      }
+    }
+
+    // Apply restrictions in order to disable variants
+    shaka.util.StreamUtils.applyRestrictions(
+        manifest.variants, this.config_.restrictions, this.maxHwRes_);
+
+    // Select for a new variant
+    const chosenVariant = this.chooseVariant_();
+    if (!chosenVariant) {
+      shaka.log.warning('Not enough variants to recover from error');
+      return false;
+    }
+
+    // Get the safeMargin to ensure a seamless playback
+    const {video} = this.getBufferedInfo();
+    const safeMargin =
+        video.reduce((size, {start, end}) => size + end - start, 0);
+
+    this.switchVariant_(chosenVariant, /* fromAdaptation= */ false,
+        /* clearBuffers= */ true, /* safeMargin= */ safeMargin);
+
+    this.checkVariantsTimer_.tickAfter(maxDisabledTime);
+    return true;
   }
 
   /**
@@ -5498,7 +5688,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return;
     }
 
-    const eventName = shaka.Player.EventName.Error;
+
+    if (this.tryToRecoverFromError_(error)) {
+      error.handled = true;
+      return;
+    }
+
+    const eventName = shaka.util.FakeEvent.EventName.Error;
     const event = this.makeEvent_(eventName, (new Map()).set('detail', error));
     this.dispatchEvent(event);
     if (event.defaultPrevented) {
@@ -5512,7 +5708,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * copy here because this is the transition point between the player and the
    * app.
    *
-   * @param {!shaka.Player.EventName} eventName
+   * @param {!shaka.util.FakeEvent.EventName} eventName
    * @param {shaka.extern.TimelineRegionInfo} region
    *
    * @private
@@ -5561,7 +5757,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         .set('position', position);
 
     this.dispatchEvent(this.makeEvent_(
-        shaka.Player.EventName.MediaQualityChanged, data));
+        shaka.util.FakeEvent.EventName.MediaQualityChanged, data));
   }
 
   /**
@@ -5679,7 +5875,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();
@@ -5704,7 +5903,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.parser_.onExpirationUpdated(keyId, expiration);
     }
 
-    const event = this.makeEvent_(shaka.Player.EventName.ExpirationUpdated);
+    const event =
+        this.makeEvent_(shaka.util.FakeEvent.EventName.ExpirationUpdated);
     this.dispatchEvent(event);
   }
 
@@ -6317,42 +6517,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   }
 };
 
-/**
- * An internal enum that contains the string values of all of the player events.
- * This exists primarily to act as an implicit list of events, for tests.
- *
- * @enum {string}
- */
-shaka.Player.EventName = {
-  AbrStatusChanged: 'abrstatuschanged',
-  Adaptation: 'adaptation',
-  Buffering: 'buffering',
-  DownloadFailed: 'downloadfailed',
-  DownloadHeadersReceived: 'downloadheadersreceived',
-  DrmSessionUpdate: 'drmsessionupdate',
-  Emsg: 'emsg',
-  Error: 'error',
-  ExpirationUpdated: 'expirationupdated',
-  Loaded: 'loaded',
-  Loading: 'loading',
-  ManifestParsed: 'manifestparsed',
-  MediaQualityChanged: 'mediaqualitychanged',
-  Metadata: 'metadata',
-  OnStateChange: 'onstatechange',
-  OnStateIdle: 'onstateidle',
-  RateChange: 'ratechange',
-  SessionDataEvent: 'sessiondata',
-  Streaming: 'streaming',
-  TextChanged: 'textchanged',
-  TextTrackVisibility: 'texttrackvisibility',
-  TimelineRegionAdded: 'timelineregionadded',
-  TimelineRegionEnter: 'timelineregionenter',
-  TimelineRegionExit: 'timelineregionexit',
-  TracksChanged: 'trackschanged',
-  Unloading: 'unloading',
-  VariantChanged: 'variantchanged',
-};
-
 
 /**
  * In order to know what method of loading the player used for some content, we
@@ -6392,7 +6556,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v4.0.0-uncompiled';
+shaka.Player.version = 'v4.1.0-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.