chore: Move isBufferedToEnd to Playhead (#8603)

Author: tykus160

lib/media/playhead.js

@@ -75,6 +75,13 @@ shaka.media.Playhead = class {
    * Notify the playhead that the buffered ranges have changed.
    */
   notifyOfBufferingChange() {}
+
+  /**
+   * Check if the player has buffered enough content to make it to the end of
+   * the presentation.
+   * @return {boolean}
+   */
+  isBufferedToEnd() {}
 };
 
 
@@ -205,6 +212,25 @@ shaka.media.SrcEqualsPlayhead = class {
   /** @override */
   notifyOfBufferingChange() {}
 
+  /** @override */
+  isBufferedToEnd() {
+    goog.asserts.assert(
+        this.mediaElement_,
+        'We need a video element to get buffering information');
+
+    // If we have buffered to the duration of the content, it means we will have
+    // enough content to buffer to the end of the presentation.
+    const bufferEnd =
+        shaka.media.TimeRangesUtils.bufferEnd(this.mediaElement_.buffered);
+
+    // Because Safari's native HLS reports slightly inaccurate values for
+    // bufferEnd here, we use a fudge factor.  Without this, we can end up in a
+    // buffering state at the end of the stream.  See issue #2117.
+    const fudge = 1;  // 1000 ms
+    return bufferEnd != null &&
+        bufferEnd >= this.mediaElement_.duration - fudge;
+  }
+
   /**
    * @return {?number} program start time in seconds.
    * @private
@@ -416,6 +442,30 @@ shaka.media.MediaSourcePlayhead = class {
     this.gapController_.onSegmentAppended();
   }
 
+  /** @override */
+  isBufferedToEnd() {
+    goog.asserts.assert(
+        this.mediaElement_,
+        'We need a video element to get buffering information');
+    goog.asserts.assert(
+        this.timeline_,
+        'We need a timeline to get buffering information');
+
+    // Live streams are "buffered to the end" when they have buffered to the
+    // live edge or beyond (into the region covered by the presentation delay).
+    if (this.timeline_.isLive()) {
+      const liveEdge = this.timeline_.getSegmentAvailabilityEnd();
+      const bufferEnd =
+          shaka.media.TimeRangesUtils.bufferEnd(this.mediaElement_.buffered);
+
+      if (bufferEnd != null && bufferEnd >= liveEdge) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
   /**
    * Called on a recurring timer to keep the playhead from falling outside the
    * availability window.

lib/player.js

@@ -4036,19 +4036,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.bufferObserver_,
         'Need a buffering observer to update');
 
-    let bufferedToEnd;
-    switch (this.loadMode_) {
-      case shaka.Player.LoadMode.SRC_EQUALS:
-        bufferedToEnd = this.isBufferedToEndSrc_();
-        break;
-      case shaka.Player.LoadMode.MEDIA_SOURCE:
-        bufferedToEnd = this.isBufferedToEndMS_();
-        break;
-      default:
-        bufferedToEnd = false;
-        break;
-    }
-
+    const bufferedToEnd = this.isEnded() || this.playhead_.isBufferedToEnd();
     const bufferLead = shaka.media.TimeRangesUtils.bufferedAheadOf(
         this.video_.buffered,
         this.video_.currentTime);
@@ -9119,83 +9107,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     return pairings;
   }
 
-  /**
-   * Assuming the player is playing content with media source, check if the
-   * player has buffered enough content to make it to the end of the
-   * presentation.
-   *
-   * @return {boolean}
-   * @private
-   */
-  isBufferedToEndMS_() {
-    goog.asserts.assert(
-        this.video_,
-        'We need a video element to get buffering information');
-    goog.asserts.assert(
-        this.mediaSourceEngine_,
-        'We need a media source engine to get buffering information');
-    goog.asserts.assert(
-        this.manifest_,
-        'We need a manifest to get buffering information');
-
-    // This is a strong guarantee that we are buffered to the end, because it
-    // means the playhead is already at that end.
-    if (this.isEnded()) {
-      return true;
-    }
-
-    // This means that MediaSource has buffered the final segment in all
-    // SourceBuffers and is no longer accepting additional segments.
-    if (this.mediaSourceEngine_.ended()) {
-      return true;
-    }
-
-    // Live streams are "buffered to the end" when they have buffered to the
-    // live edge or beyond (into the region covered by the presentation delay).
-    if (this.manifest_.presentationTimeline.isLive()) {
-      const liveEdge =
-          this.manifest_.presentationTimeline.getSegmentAvailabilityEnd();
-      const bufferEnd =
-          shaka.media.TimeRangesUtils.bufferEnd(this.video_.buffered);
-
-      if (bufferEnd != null && bufferEnd >= liveEdge) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Assuming the player is playing content with src=, check if the player has
-   * buffered enough content to make it to the end of the presentation.
-   *
-   * @return {boolean}
-   * @private
-   */
-  isBufferedToEndSrc_() {
-    goog.asserts.assert(
-        this.video_,
-        'We need a video element to get buffering information');
-
-    // This is a strong guarantee that we are buffered to the end, because it
-    // means the playhead is already at that end.
-    if (this.isEnded()) {
-      return true;
-    }
-
-    // If we have buffered to the duration of the content, it means we will have
-    // enough content to buffer to the end of the presentation.
-    const bufferEnd =
-        shaka.media.TimeRangesUtils.bufferEnd(this.video_.buffered);
-
-    // Because Safari's native HLS reports slightly inaccurate values for
-    // bufferEnd here, we use a fudge factor.  Without this, we can end up in a
-    // buffering state at the end of the stream.  See issue #2117.
-    const fudge = 1;  // 1000 ms
-    return bufferEnd != null && bufferEnd >= this.video_.duration - fudge;
-  }
-
   /**
    * Create an error for when we purposely interrupt a load operation.
    *