shaka-player 3.3.2 → 3.3.5

package/lib/player.js

@@ -440,8 +440,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;
@@ -582,7 +597,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();
     });
 
@@ -770,10 +785,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;
@@ -1316,7 +1339,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 +1366,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 +1427,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
@@ -1902,18 +1921,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) {
@@ -1976,6 +1995,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 +2099,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,17 +2252,26 @@ 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 to check if
+    // this load was canceled before the necessary awaits completed.
+    let unloaded = false;
+    this.cleanupOnUnload_.push(() => {
+      unloaded = true;
+    });
 
     if (has.startTime != null) {
       this.playhead_.setStartTime(has.startTime);
     }
 
     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
@@ -2237,16 +2283,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/google/shaka-player/issues/2483
-    if (this.video_.preload != 'none') {
-      this.eventManager_.listenOnce(this.video_, 'loadedmetadata', () => {
+    // automatically.
+    // See https://github.com/shaka-project/shaka-player/issues/2483
+    if (mediaElement.preload != 'none') {
+      this.loadEventManager_.listenOnce(mediaElement, 'loadedmetadata', () => {
         const now = Date.now() / 1000;
         const delta = now - wants.startTimeOfLoad;
         this.stats_.setLoadLatency(delta);
@@ -2256,38 +2303,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.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;
+              }
+            }
+          });
+
+      this.loadEventManager_.listen(
+          mediaElement.textTracks, 'removetrack',
+          () => this.onTracksChanged_());
+      this.loadEventManager_.listen(
+          mediaElement.textTracks, 'change',
           () => this.onTracksChanged_());
-      this.eventManager_.listen(
-          this.video_.audioTracks, 'change', () => this.onTracksChanged_());
-    }
-    if (this.video_.textTracks) {
-      this.eventManager_.listen(this.video_.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.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_());
     }
 
     const extension = shaka.media.ManifestParser.getExtension(has.uri);
@@ -2296,14 +2352,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
@@ -2319,31 +2375,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();
         });
 
-    // This flag is used below in the language preference setup to check if this
-    // load was canceled before the necessary events fire.
-    let unloaded = false;
-    this.cleanupOnUnload_.push(() => {
-      unloaded = true;
-    });
-
     // 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
@@ -2351,8 +2394,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
@@ -2371,10 +2415,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 ' +
@@ -2385,7 +2429,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_());
     });
 
@@ -2469,7 +2513,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;
       }
@@ -2487,12 +2531,16 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // In Safari the initial assignment does not always work, so we schedule
     // this process to be repeated several times to ensure that it has been put
     // in the correct mode.
-    new shaka.util.Timer(() => {
+    const timer = new shaka.util.Timer(() => {
       const textTracks = this.getMetadataTracks_();
       for (const textTrack of textTracks) {
         textTrack.mode = 'hidden';
       }
-    }).tickNow().tickAfter(/* seconds= */ 0.5);
+    }).tickNow().tickAfter(0.5);
+
+    this.cleanupOnUnload_.push(() => {
+      timer.stop();
+    });
   }
 
 
@@ -2543,12 +2591,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;
     }
@@ -2560,12 +2608,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // In Safari the initial assignment does not always work, so we schedule
     // this process to be repeated several times to ensure that it has been put
     // in the correct mode.
-    new shaka.util.Timer(() => {
-      const chaptersTracks = this.getChaptersTracks_();
-      for (const chaptersTrack of chaptersTracks) {
-        chaptersTrack.mode = 'hidden';
-      }
-    }).tickNow().tickAfter(/* seconds= */ 0.5);
+    const timer = new shaka.util.Timer(() => {
+      track.mode = 'hidden';
+    }).tickNow().tickAfter(0.5);
+
+    this.cleanupOnUnload_.push(() => {
+      timer.stop();
+    });
   }
 
   /**
@@ -3704,7 +3753,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.streamingEngine_.switchTextStream(stream);
       this.onTextChanged_();
 
-      // Workaround for https://github.com/google/shaka-player/issues/1299
+      // Workaround for
+      // https://github.com/shaka-project/shaka-player/issues/1299
       // When track is selected, back-propagate the language to
       // currentTextLanguage_.
       this.currentTextLanguage_ = stream.language;
@@ -3780,7 +3830,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.switchVariant_(variant, /* fromAdaptation= */ false, clearBuffer,
           safeMargin);
 
-      // Workaround for https://github.com/google/shaka-player/issues/1299
+      // Workaround for
+      // https://github.com/shaka-project/shaka-player/issues/1299
       // When track is selected, back-propagate the language to
       // currentAudioLanguage_.
       this.currentAdaptationSetCriteria_ = new shaka.media.ExampleBasedCriteria(
@@ -4703,25 +4754,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=');
@@ -4775,6 +4842,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,
@@ -4790,12 +4858,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
@@ -4805,7 +4875,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (!this.video_.getAttribute('crossorigin')) {
       this.video_.setAttribute('crossorigin', 'anonymous');
     }
+
     this.video_.appendChild(trackElement);
+    return trackElement;
   }
 
   /**
@@ -5175,7 +5247,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;
       }
@@ -5252,7 +5325,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // If the playback rate changes while seeking, Edge will cache the playback
     // rate and use it after seeking.
     //
-    // https://github.com/google/shaka-player/issues/951
+    // https://github.com/shaka-project/shaka-player/issues/951
     if (newRate == 0) {
       return;
     }
@@ -5844,7 +5917,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();
@@ -6558,7 +6634,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.2-uncompiled';  // x-release-please-version
+shaka.Player.version = 'v3.3.5-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/polyfill/all.js

@@ -7,7 +7,6 @@
 goog.provide('shaka.polyfill');
 
 goog.require('shaka.log');
-goog.require('shaka.util.Iterables');
 
 
 /**
@@ -40,8 +39,8 @@ shaka.polyfill = class {
    */
   static register(polyfill, priority) {
     const newItem = {priority: priority || 0, callback: polyfill};
-    const enumerate = (it) => shaka.util.Iterables.enumerate(it);
-    for (const {i, item} of enumerate(shaka.polyfill.polyfills_)) {
+    for (let i = 0; i < shaka.polyfill.polyfills_.length; i++) {
+      const item = shaka.polyfill.polyfills_[i];
       if (item.priority < newItem.priority) {
         shaka.polyfill.polyfills_.splice(i, 0, newItem);
         return;

package/lib/polyfill/encryption_scheme.js

@@ -12,7 +12,7 @@ goog.require('shaka.polyfill');
  * @summary A polyfill to add support for EncryptionScheme queries in EME.
  * @see https://wicg.github.io/encrypted-media-encryption-scheme/
  * @see https://github.com/w3c/encrypted-media/pull/457
- * @see https://github.com/google/eme-encryption-scheme-polyfill
+ * @see https://github.com/shaka-project/eme-encryption-scheme-polyfill
  * @export
  */
 shaka.polyfill.EncryptionScheme = class {

package/lib/polyfill/media_capabilities.js

@@ -29,12 +29,12 @@ shaka.polyfill.MediaCapabilities = class {
     // TODO: re-evaluate MediaCapabilities in the future versions of Chromecast.
     // Since MediaCapabilities implementation is buggy in Apple browsers, we
     // should always install polyfill for Apple browsers.
-    // See: https://github.com/google/shaka-player/issues/3530
+    // See: https://github.com/shaka-project/shaka-player/issues/3530
     // TODO: re-evaluate MediaCapabilities in the future versions of Apple
     // Browsers.
     // Since MediaCapabilities implementation is buggy in PS5 browsers, we
     // should always install polyfill for PS5 browsers.
-    // See: https://github.com/google/shaka-player/issues/3582
+    // See: https://github.com/shaka-project/shaka-player/issues/3582
     // TODO: re-evaluate MediaCapabilities in the future versions of PS5
     // Browsers.
     if (!shaka.util.Platform.isChromecast() &&
@@ -54,7 +54,7 @@ shaka.polyfill.MediaCapabilities = class {
 
     // Keep the patched MediaCapabilities object from being garbage-collected in
     // Safari.
-    // See https://github.com/google/shaka-player/issues/3696#issuecomment-1009472718
+    // See https://github.com/shaka-project/shaka-player/issues/3696#issuecomment-1009472718
     shaka.polyfill.MediaCapabilities.originalMcap =
         navigator.mediaCapabilities;
 

package/lib/polyfill/mediasource.js

@@ -39,7 +39,7 @@ shaka.polyfill.MediaSource = class {
       shaka.polyfill.MediaSource.patchCastIsTypeSupported_();
     } else if (safariVersion) {
       // TS content is broken on Safari in general.
-      // See https://github.com/google/shaka-player/issues/743
+      // See https://github.com/shaka-project/shaka-player/issues/743
       // and https://bugs.webkit.org/show_bug.cgi?id=165342
       shaka.polyfill.MediaSource.rejectTsContent_();