Add setBufferingStrategy() to WebMediaPlayer.

This allows Blink to control when aggressive buffering triggers.

The initial implementation requires a user gesture to trigger aggressive buffering on pause. This is more restricted than the current Chromium behavior to trigger on any pause, in particular for pauses that occur as a result of removing an element from the DOM.

BUG=538523

Review URL: https://codereview.chromium.org/1489233004

Cr-Commit-Position: refs/heads/master@{#364890}

11 files changed, 162 insertions, 52 deletions

diff --git a/media/blink/buffered_data_source.cc b/media/blink/buffered_data_source.cc
index e35a3b1..18f364d9 100644
--- a/media/blink/buffered_data_source.cc
+++ b/media/blink/buffered_data_source.cc
@@ -98,6 +98,7 @@ BufferedDataSource::BufferedDataSource(
       render_task_runner_(task_runner),
       stop_signal_received_(false),
       media_has_played_(false),
+      buffering_strategy_(BUFFERING_STRATEGY_NORMAL),
       preload_(AUTO),
       bitrate_(0),
       playback_rate_(0.0),
@@ -176,6 +177,13 @@ void BufferedDataSource::SetPreload(Preload preload) {
   preload_ = preload;
 }
 
+void BufferedDataSource::SetBufferingStrategy(
+    BufferingStrategy buffering_strategy) {
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
+  buffering_strategy_ = buffering_strategy;
+  UpdateDeferStrategy();
+}
+
 bool BufferedDataSource::HasSingleOrigin() {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   DCHECK(init_cb_.is_null() && loader_.get())
@@ -211,12 +219,7 @@ void BufferedDataSource::MediaPlaybackRateChanged(double playback_rate) {
 void BufferedDataSource::MediaIsPlaying() {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   media_has_played_ = true;
-  UpdateDeferStrategy(false);
-}
-
-void BufferedDataSource::MediaIsPaused() {
-  DCHECK(render_task_runner_->BelongsToCurrentThread());
-  UpdateDeferStrategy(true);
+  UpdateDeferStrategy();
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ -566,7 +569,10 @@ void BufferedDataSource::ProgressCallback(int64 position) {
   host_->AddBufferedByteRange(loader_->first_byte_position(), position);
 }
 
-void BufferedDataSource::UpdateDeferStrategy(bool paused) {
+void BufferedDataSource::UpdateDeferStrategy() {
+  if (!loader_)
+    return;
+
   // No need to aggressively buffer when we are assuming the resource is fully
   // buffered.
   if (assume_fully_buffered()) {
@@ -575,10 +581,11 @@ void BufferedDataSource::UpdateDeferStrategy(bool paused) {
   }
 
   // If the playback has started (at which point the preload value is ignored)
-  // and we're paused, then try to load as much as possible (the loader will
-  // fall back to kCapacityDefer if it knows the current response won't be
-  // useful from the cache in the future).
-  if (media_has_played_ && paused && loader_->range_supported()) {
+  // and the strategy is aggressive, then try to load as much as possible (the
+  // loader will fall back to kCapacityDefer if it knows the current response
+  // won't be useful from the cache in the future).
+  bool aggressive = (buffering_strategy_ == BUFFERING_STRATEGY_AGGRESSIVE);
+  if (media_has_played_ && aggressive && loader_->range_supported()) {
     loader_->UpdateDeferStrategy(BufferedResourceLoader::kNeverDefer);
     return;
   }
diff --git a/media/blink/buffered_data_source.h b/media/blink/buffered_data_source.h
index 4c1de59..127c0ad 100644
--- a/media/blink/buffered_data_source.h
+++ b/media/blink/buffered_data_source.h
@@ -56,6 +56,14 @@ class BufferedDataSourceInterface : public DataSource {
     AUTO,
   };
 
+  // Enum values must match the values in
+  // blink::WebMediaPlayer::BufferingStrategy and there will be assertions at
+  // compile time if they do not match.
+  enum BufferingStrategy {
+    BUFFERING_STRATEGY_NORMAL,
+    BUFFERING_STRATEGY_AGGRESSIVE,
+  };
+
   // Executes |init_cb| with the result of initialization when it has completed.
   //
   // Method called on the render thread.
@@ -65,6 +73,10 @@ class BufferedDataSourceInterface : public DataSource {
   // Adjusts the buffering algorithm based on the given preload value.
   virtual void SetPreload(Preload preload) = 0;
 
+  // Adjusts the buffering algorithm based on the given buffering strategy
+  // value.
+  virtual void SetBufferingStrategy(BufferingStrategy buffering_strategy) = 0;
+
   // Returns true if the media resource has a single origin, false otherwise.
   // Only valid to call after Initialize() has completed.
   //
@@ -85,7 +97,6 @@ class BufferedDataSourceInterface : public DataSource {
   // behavior.
   virtual void MediaPlaybackRateChanged(double playback_rate) = 0;
   virtual void MediaIsPlaying() = 0;
-  virtual void MediaIsPaused() = 0;
   virtual bool media_has_played() const = 0;
 
   // Returns true if the resource is local.
@@ -132,6 +143,10 @@ class MEDIA_BLINK_EXPORT BufferedDataSource
   // Adjusts the buffering algorithm based on the given preload value.
   void SetPreload(Preload preload) override;
 
+  // Adjusts the buffering algorithm based on the given buffering strategy
+  // value.
+  void SetBufferingStrategy(BufferingStrategy buffering_strategy) override;
+
   // Returns true if the media resource has a single origin, false otherwise.
   // Only valid to call after Initialize() has completed.
   //
@@ -152,7 +167,6 @@ class MEDIA_BLINK_EXPORT BufferedDataSource
   // behavior.
   void MediaPlaybackRateChanged(double playback_rate) override;
   void MediaIsPlaying() override;
-  void MediaIsPaused() override;
   bool media_has_played() const override;
 
   // Returns true if the resource is local.
@@ -220,9 +234,8 @@ class MEDIA_BLINK_EXPORT BufferedDataSource
   void LoadingStateChangedCallback(BufferedResourceLoader::LoadingState state);
   void ProgressCallback(int64 position);
 
-  // Update |loader_|'s deferring strategy in response to a play/pause, or
-  // change in playback rate.
-  void UpdateDeferStrategy(bool paused);
+  // Update |loader_|'s deferring strategy.
+  void UpdateDeferStrategy();
 
   // URL of the resource requested.
   GURL url_;
@@ -277,6 +290,9 @@ class MEDIA_BLINK_EXPORT BufferedDataSource
   // least once.
   bool media_has_played_;
 
+  // Buffering strategy as configured by SetBufferingStrategy().
+  BufferingStrategy buffering_strategy_;
+
   // This variable holds the value of the preload attribute for the video
   // element.
   Preload preload_;
diff --git a/media/blink/buffered_data_source_unittest.cc b/media/blink/buffered_data_source_unittest.cc
index 2021c84..4ac4f93 100644
--- a/media/blink/buffered_data_source_unittest.cc
+++ b/media/blink/buffered_data_source_unittest.cc
@@ -861,7 +861,8 @@ TEST_F(BufferedDataSourceTest, LocalResource_DeferStrategy) {
   data_source_->MediaIsPlaying();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
-  data_source_->MediaIsPaused();
+  data_source_->SetBufferingStrategy(
+      BufferedDataSource::BUFFERING_STRATEGY_AGGRESSIVE);
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   Stop();
@@ -878,7 +879,8 @@ TEST_F(BufferedDataSourceTest, LocalResource_PreloadMetadata_DeferStrategy) {
   data_source_->MediaIsPlaying();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
-  data_source_->MediaIsPaused();
+  data_source_->SetBufferingStrategy(
+      BufferedDataSource::BUFFERING_STRATEGY_AGGRESSIVE);
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   Stop();
@@ -895,7 +897,8 @@ TEST_F(BufferedDataSourceTest, ExternalResource_Reponse200_DeferStrategy) {
   data_source_->MediaIsPlaying();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
-  data_source_->MediaIsPaused();
+  data_source_->SetBufferingStrategy(
+      BufferedDataSource::BUFFERING_STRATEGY_AGGRESSIVE);
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   Stop();
@@ -914,7 +917,8 @@ TEST_F(BufferedDataSourceTest,
   data_source_->MediaIsPlaying();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
-  data_source_->MediaIsPaused();
+  data_source_->SetBufferingStrategy(
+      BufferedDataSource::BUFFERING_STRATEGY_AGGRESSIVE);
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   Stop();
@@ -931,13 +935,18 @@ TEST_F(BufferedDataSourceTest, ExternalResource_Reponse206_DeferStrategy) {
   data_source_->MediaIsPlaying();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
   set_might_be_reused_from_cache_in_future(true);
-  data_source_->MediaIsPaused();
+
+  data_source_->SetBufferingStrategy(
+      BufferedDataSource::BUFFERING_STRATEGY_AGGRESSIVE);
   EXPECT_EQ(BufferedResourceLoader::kNeverDefer, defer_strategy());
 
-  data_source_->MediaIsPlaying();
+  data_source_->SetBufferingStrategy(
+      BufferedDataSource::BUFFERING_STRATEGY_NORMAL);
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+
   set_might_be_reused_from_cache_in_future(false);
-  data_source_->MediaIsPaused();
+  data_source_->SetBufferingStrategy(
+      BufferedDataSource::BUFFERING_STRATEGY_AGGRESSIVE);
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   Stop();
@@ -955,14 +964,19 @@ TEST_F(BufferedDataSourceTest,
 
   data_source_->MediaIsPlaying();
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+
   set_might_be_reused_from_cache_in_future(true);
-  data_source_->MediaIsPaused();
+  data_source_->SetBufferingStrategy(
+      BufferedDataSource::BUFFERING_STRATEGY_AGGRESSIVE);
   EXPECT_EQ(BufferedResourceLoader::kNeverDefer, defer_strategy());
 
-  data_source_->MediaIsPlaying();
+  data_source_->SetBufferingStrategy(
+      BufferedDataSource::BUFFERING_STRATEGY_NORMAL);
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+
   set_might_be_reused_from_cache_in_future(false);
-  data_source_->MediaIsPaused();
+  data_source_->SetBufferingStrategy(
+      BufferedDataSource::BUFFERING_STRATEGY_AGGRESSIVE);
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   Stop();
diff --git a/media/blink/multibuffer_data_source.cc b/media/blink/multibuffer_data_source.cc
index 1b01b08..8dc3426 100644
--- a/media/blink/multibuffer_data_source.cc
+++ b/media/blink/multibuffer_data_source.cc
@@ -115,6 +115,7 @@ MultibufferDataSource::MultibufferDataSource(
       frame_(frame),
       stop_signal_received_(false),
       media_has_played_(false),
+      buffering_strategy_(BUFFERING_STRATEGY_NORMAL),
       single_origin_(true),
       cancel_on_defer_(false),
       preload_(AUTO),
@@ -234,6 +235,13 @@ void MultibufferDataSource::SetPreload(Preload preload) {
   UpdateBufferSizes();
 }
 
+void MultibufferDataSource::SetBufferingStrategy(
+    BufferingStrategy buffering_strategy) {
+  DCHECK(render_task_runner_->BelongsToCurrentThread());
+  buffering_strategy_ = buffering_strategy;
+  UpdateBufferSizes();
+}
+
 bool MultibufferDataSource::HasSingleOrigin() {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   DCHECK(init_cb_.is_null() && reader_.get())
@@ -279,18 +287,11 @@ void MultibufferDataSource::MediaIsPlaying() {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   media_has_played_ = true;
   cancel_on_defer_ = false;
-  paused_ = false;
   // Once we start playing, we need preloading.
   preload_ = AUTO;
   UpdateBufferSizes();
 }
 
-void MultibufferDataSource::MediaIsPaused() {
-  DCHECK(render_task_runner_->BelongsToCurrentThread());
-  paused_ = true;
-  UpdateBufferSizes();
-}
-
 /////////////////////////////////////////////////////////////////////////////
 // DataSource implementation.
 void MultibufferDataSource::Stop() {
@@ -518,9 +519,11 @@ void MultibufferDataSource::UpdateBufferSizes() {
     return;
 
   if (!assume_fully_buffered()) {
-    // If the playback has started and we're paused, then try to load as much as
-    // possible, assuming that the file is cacheable. (If not, why bother?)
-    if (media_has_played_ && paused_ && url_data_ &&
+    // If the playback has started and the strategy is aggressive, then try to
+    // load as much as possible, assuming that the file is cacheable. (If not,
+    // why bother?)
+    bool aggressive = (buffering_strategy_ == BUFFERING_STRATEGY_AGGRESSIVE);
+    if (media_has_played_ && aggressive && url_data_ &&
         url_data_->range_supported() && url_data_->cacheable()) {
       reader_->SetPreload(1LL << 40, 1LL << 40);  // 1 Tb
       return;
diff --git a/media/blink/multibuffer_data_source.h b/media/blink/multibuffer_data_source.h
index e5f411d..c47932c 100644
--- a/media/blink/multibuffer_data_source.h
+++ b/media/blink/multibuffer_data_source.h
@@ -61,6 +61,10 @@ class MEDIA_BLINK_EXPORT MultibufferDataSource
   // Adjusts the buffering algorithm based on the given preload value.
   void SetPreload(Preload preload) override;
 
+  // Adjusts the buffering algorithm based on the given buffering strategy
+  // value.
+  void SetBufferingStrategy(BufferingStrategy buffering_strategy) override;
+
   // Returns true if the media resource has a single origin, false otherwise.
   // Only valid to call after Initialize() has completed.
   //
@@ -81,7 +85,6 @@ class MEDIA_BLINK_EXPORT MultibufferDataSource
   // behavior.
   void MediaPlaybackRateChanged(double playback_rate) override;
   void MediaIsPlaying() override;
-  void MediaIsPaused() override;
   bool media_has_played() const override;
 
   // Returns true if the resource is local.
@@ -191,8 +194,8 @@ class MEDIA_BLINK_EXPORT MultibufferDataSource
   // least once.
   bool media_has_played_;
 
-  // Are we currently paused.
-  bool paused_;
+  // Buffering strategy set by SetBufferingStrategy.
+  BufferingStrategy buffering_strategy_;
 
   // As we follow redirects, we set this variable to false if redirects
   // go between different origins.
diff --git a/media/blink/multibuffer_data_source_unittest.cc b/media/blink/multibuffer_data_source_unittest.cc
index 3890af9..ee57919 100644
--- a/media/blink/multibuffer_data_source_unittest.cc
+++ b/media/blink/multibuffer_data_source_unittest.cc
@@ -1053,7 +1053,8 @@ TEST_F(MultibufferDataSourceTest, LocalResource_DeferStrategy) {
   data_source_->MediaIsPlaying();
   CheckCapacityDefer();
 
-  data_source_->MediaIsPaused();
+  data_source_->SetBufferingStrategy(
+      BufferedDataSourceInterface::BUFFERING_STRATEGY_AGGRESSIVE);
   CheckCapacityDefer();
 
   Stop();
@@ -1070,7 +1071,8 @@ TEST_F(MultibufferDataSourceTest, LocalResource_PreloadMetadata_DeferStrategy) {
   data_source_->MediaIsPlaying();
   CheckCapacityDefer();
 
-  data_source_->MediaIsPaused();
+  data_source_->SetBufferingStrategy(
+      BufferedDataSourceInterface::BUFFERING_STRATEGY_AGGRESSIVE);
   CheckCapacityDefer();
 
   Stop();
@@ -1087,7 +1089,8 @@ TEST_F(MultibufferDataSourceTest, ExternalResource_Reponse200_DeferStrategy) {
   data_source_->MediaIsPlaying();
   CheckCapacityDefer();
 
-  data_source_->MediaIsPaused();
+  data_source_->SetBufferingStrategy(
+      BufferedDataSourceInterface::BUFFERING_STRATEGY_AGGRESSIVE);
   CheckCapacityDefer();
 
   Stop();
@@ -1106,7 +1109,8 @@ TEST_F(MultibufferDataSourceTest,
   data_source_->MediaIsPlaying();
   CheckCapacityDefer();
 
-  data_source_->MediaIsPaused();
+  data_source_->SetBufferingStrategy(
+      BufferedDataSourceInterface::BUFFERING_STRATEGY_AGGRESSIVE);
   CheckCapacityDefer();
 
   Stop();
@@ -1123,14 +1127,18 @@ TEST_F(MultibufferDataSourceTest, ExternalResource_Reponse206_DeferStrategy) {
   data_source_->MediaIsPlaying();
   CheckCapacityDefer();
   set_might_be_reused_from_cache_in_future(true);
-  data_source_->MediaIsPaused();
+  data_source_->SetBufferingStrategy(
+      BufferedDataSourceInterface::BUFFERING_STRATEGY_AGGRESSIVE);
   CheckNeverDefer();
 
+  data_source_->SetBufferingStrategy(
+      BufferedDataSourceInterface::BUFFERING_STRATEGY_NORMAL);
   data_source_->MediaIsPlaying();
   CheckCapacityDefer();
 
   set_might_be_reused_from_cache_in_future(false);
-  data_source_->MediaIsPaused();
+  data_source_->SetBufferingStrategy(
+      BufferedDataSourceInterface::BUFFERING_STRATEGY_AGGRESSIVE);
   CheckCapacityDefer();
 
   Stop();
@@ -1150,13 +1158,17 @@ TEST_F(MultibufferDataSourceTest,
   CheckCapacityDefer();
 
   set_might_be_reused_from_cache_in_future(true);
-  data_source_->MediaIsPaused();
+  data_source_->SetBufferingStrategy(
+      BufferedDataSourceInterface::BUFFERING_STRATEGY_AGGRESSIVE);
   CheckNeverDefer();
 
+  data_source_->SetBufferingStrategy(
+      BufferedDataSourceInterface::BUFFERING_STRATEGY_NORMAL);
   data_source_->MediaIsPlaying();
   CheckCapacityDefer();
   set_might_be_reused_from_cache_in_future(false);
-  data_source_->MediaIsPaused();
+  data_source_->SetBufferingStrategy(
+      BufferedDataSourceInterface::BUFFERING_STRATEGY_AGGRESSIVE);
   CheckCapacityDefer();
 
   Stop();
diff --git a/media/blink/webmediaplayer_impl.cc b/media/blink/webmediaplayer_impl.cc
index f8154e1..779e820 100644
--- a/media/blink/webmediaplayer_impl.cc
+++ b/media/blink/webmediaplayer_impl.cc
@@ -133,6 +133,8 @@ WebMediaPlayerImpl::WebMediaPlayerImpl(
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       preload_(BufferedDataSource::AUTO),
+      buffering_strategy_(
+          BufferedDataSourceInterface::BUFFERING_STRATEGY_NORMAL),
       main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       media_task_runner_(params.media_task_runner()),
       worker_task_runner_(params.worker_task_runner()),
@@ -284,6 +286,7 @@ void WebMediaPlayerImpl::DoLoad(LoadType load_type,
       &buffered_data_source_host_,
       base::Bind(&WebMediaPlayerImpl::NotifyDownloading, AsWeakPtr())));
   data_source_->SetPreload(preload_);
+  data_source_->SetBufferingStrategy(buffering_strategy_);
   data_source_->Initialize(
       base::Bind(&WebMediaPlayerImpl::DataSourceInitialized, AsWeakPtr()));
 }
@@ -310,8 +313,6 @@ void WebMediaPlayerImpl::pause() {
   const bool was_already_paused = paused_ || playback_rate_ == 0;
   paused_ = true;
   pipeline_.SetPlaybackRate(0.0);
-  if (data_source_)
-    data_source_->MediaIsPaused();
   UpdatePausedTime();
 
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::PAUSE));
@@ -485,6 +486,27 @@ void WebMediaPlayerImpl::setPreload(WebMediaPlayer::Preload preload) {
     data_source_->SetPreload(preload_);
 }
 
+#define STATIC_ASSERT_MATCHING_ENUM(webkit_name, chromium_name)          \
+  static_assert(static_cast<int>(WebMediaPlayer::webkit_name) ==         \
+                    static_cast<int>(BufferedDataSource::chromium_name), \
+                "mismatching enum values: " #webkit_name)
+STATIC_ASSERT_MATCHING_ENUM(BufferingStrategy::Normal,
+                            BUFFERING_STRATEGY_NORMAL);
+STATIC_ASSERT_MATCHING_ENUM(BufferingStrategy::Aggressive,
+                            BUFFERING_STRATEGY_AGGRESSIVE);
+#undef STATIC_ASSERT_MATCHING_ENUM
+
+void WebMediaPlayerImpl::setBufferingStrategy(
+    WebMediaPlayer::BufferingStrategy buffering_strategy) {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+
+  buffering_strategy_ =
+      static_cast<BufferedDataSource::BufferingStrategy>(buffering_strategy);
+  if (data_source_)
+    data_source_->SetBufferingStrategy(buffering_strategy_);
+}
+
 bool WebMediaPlayerImpl::hasVideo() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
diff --git a/media/blink/webmediaplayer_impl.h b/media/blink/webmediaplayer_impl.h
index 7e06f16..0ec8076 100644
--- a/media/blink/webmediaplayer_impl.h
+++ b/media/blink/webmediaplayer_impl.h
@@ -97,6 +97,8 @@ class MEDIA_BLINK_EXPORT WebMediaPlayerImpl
                  const blink::WebSecurityOrigin& security_origin,
                  blink::WebSetSinkIdCallbacks* web_callback) override;
   void setPreload(blink::WebMediaPlayer::Preload preload) override;
+  void setBufferingStrategy(
+      blink::WebMediaPlayer::BufferingStrategy buffering_strategy) override;
   blink::WebTimeRanges buffered() const override;
   blink::WebTimeRanges seekable() const override;
 
@@ -268,6 +270,10 @@ class MEDIA_BLINK_EXPORT WebMediaPlayerImpl
   // Preload state for when |data_source_| is created after setPreload().
   BufferedDataSource::Preload preload_;
 
+  // Buffering strategy for when |data_source_| is created after
+  // setBufferingStrategy().
+  BufferedDataSource::BufferingStrategy buffering_strategy_;
+
   // Task runner for posting tasks on Chrome's main thread. Also used
   // for DCHECKs so methods calls won't execute in the wrong thread.
   const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
diff --git a/third_party/WebKit/Source/core/html/HTMLMediaElement.cpp b/third_party/WebKit/Source/core/html/HTMLMediaElement.cpp
index 13a1482..77aa5fe 100644
--- a/third_party/WebKit/Source/core/html/HTMLMediaElement.cpp
+++ b/third_party/WebKit/Source/core/html/HTMLMediaElement.cpp
@@ -559,7 +559,7 @@ void HTMLMediaElement::removedFrom(ContainerNode* insertionPoint, Node* next)
     if (insertionPoint->inActiveDocument()) {
         configureMediaControls();
         if (m_networkState > NETWORK_EMPTY)
-            pause();
+            pauseInternal();
     }
 }
 
@@ -1974,6 +1974,12 @@ void HTMLMediaElement::playInternal()
 {
     WTF_LOG(Media, "HTMLMediaElement::playInternal(%p)", this);
 
+    // Always return the buffering strategy to normal when not paused,
+    // regardless of the cause. (In contrast with aggressive buffering which is
+    // only enabled by pause(), not pauseInternal().)
+    if (webMediaPlayer())
+        webMediaPlayer()->setBufferingStrategy(WebMediaPlayer::BufferingStrategy::Normal);
+
     // 4.8.10.9. Playing the media resource
     if (m_networkState == NETWORK_EMPTY)
         scheduleDelayedAction(LoadMediaResource);
@@ -2023,6 +2029,18 @@ void HTMLMediaElement::pause()
 {
     WTF_LOG(Media, "HTMLMediaElement::pause(%p)", this);
 
+    // Only buffer aggressively on a user-initiated pause. Other types of pauses
+    // (which go directly to pauseInternal()) should not cause this behavior.
+    if (webMediaPlayer() && UserGestureIndicator::processingUserGesture())
+        webMediaPlayer()->setBufferingStrategy(WebMediaPlayer::BufferingStrategy::Aggressive);
+
+    pauseInternal();
+}
+
+void HTMLMediaElement::pauseInternal()
+{
+    WTF_LOG(Media, "HTMLMediaElement::pauseInternal(%p)", this);
+
     if (m_networkState == NETWORK_EMPTY)
         scheduleDelayedAction(LoadMediaResource);
 
@@ -2168,7 +2186,7 @@ void HTMLMediaElement::playbackProgressTimerFired(Timer<HTMLMediaElement>*)
         if (!m_paused) {
             UseCounter::count(document(), UseCounter::HTMLMediaElementPauseAtFragmentEnd);
             // changes paused to true and fires a simple event named pause at the media element.
-            pause();
+            pauseInternal();
         }
     }
 
@@ -2780,7 +2798,7 @@ void HTMLMediaElement::playbackStateChanged()
         return;
 
     if (webMediaPlayer()->paused())
-        pause();
+        pauseInternal();
     else
         playInternal();
 }
diff --git a/third_party/WebKit/Source/core/html/HTMLMediaElement.h b/third_party/WebKit/Source/core/html/HTMLMediaElement.h
index 1695af5..3fb86a6 100644
--- a/third_party/WebKit/Source/core/html/HTMLMediaElement.h
+++ b/third_party/WebKit/Source/core/html/HTMLMediaElement.h
@@ -382,6 +382,9 @@ private:
     // This does not check user gesture restrictions.
     void playInternal();
 
+    // This does not change the buffering strategy.
+    void pauseInternal();
+
     // If we are about to enter a paused state, call this to record
     // autoplay metrics.  If we were already in a stopped state, then
     // this does nothing.
diff --git a/third_party/WebKit/public/platform/WebMediaPlayer.h b/third_party/WebKit/public/platform/WebMediaPlayer.h
index 9670be7..2cf108b 100644
--- a/third_party/WebKit/public/platform/WebMediaPlayer.h
+++ b/third_party/WebKit/public/platform/WebMediaPlayer.h
@@ -77,6 +77,11 @@ public:
         PreloadAuto,
     };
 
+    enum class BufferingStrategy {
+        Normal,
+        Aggressive,
+    };
+
     // Represents synchronous exceptions that can be thrown from the Encrypted
     // Media methods. This is different from the asynchronous MediaKeyError.
     enum MediaKeyException {
@@ -117,6 +122,7 @@ public:
     virtual void requestRemotePlayback() { }
     virtual void requestRemotePlaybackControl() { }
     virtual void setPreload(Preload) { }
+    virtual void setBufferingStrategy(BufferingStrategy) {}
     virtual WebTimeRanges buffered() const = 0;
     virtual WebTimeRanges seekable() const = 0;