Fake FlingingRenderer's buffering state changes

When we seek a video being casted with the FlingingRenderer, time never
gets updated on the phone after the seek completes. This is because
Blink doesn't get the appropriate seek completion signals, since WMPI's
buffering state never goes back to BUFFERING_HAVE_ENOUGH.

This CL fixes issue by always returning BUFFERING_HAVE_ENOUGH in
FlingingRenderer::StartPlayingFrom(). Because there is no need to buffer
when using the FR, we can always consider the media pipeline to be fully
buffered. Sending a buffering state change in StartPlayingFrom() might
be suprising, but we do the same with the MediaPlayerRenderer, and it
has not caused any (known) problems so far.

Bug: 875517
Change-Id: If6069d501af12ec20f844d0adc1ea980935fb99f
Reviewed-on: https://chromium-review.googlesource.com/1184060
Commit-Queue: Thomas Guilbert <tguilbert@chromium.org>
Reviewed-by: Dale Curtis <dalecurtis@chromium.org>
Cr-Commit-Position: refs/heads/master@{#586086}

content/browser/media/flinging_renderer.cc

@@ -63,6 +63,7 @@ void FlingingRenderer::Initialize(media::MediaResource* media_resource,
                                   media::RendererClient* client,
                                   const media::PipelineStatusCB& init_cb) {
   DVLOG(2) << __func__;
+  client_ = client;
   init_cb.Run(media::PIPELINE_OK);
 }
 
@@ -81,6 +82,18 @@ void FlingingRenderer::Flush(const base::Closure& flush_cb) {
 void FlingingRenderer::StartPlayingFrom(base::TimeDelta time) {
   DVLOG(2) << __func__;
   controller_->GetMediaController()->Seek(time);
+
+  // After a seek when using the FlingingRenderer, WMPI will never get back to
+  // BUFFERING_HAVE_ENOUGH. This prevents Blink from getting the appropriate
+  // seek completion signals, and time updates are never re-scheduled.
+  //
+  // The FlingingRenderer doesn't need to buffer, since playback happens on a
+  // different device. This means it's ok to always send BUFFERING_HAVE_ENOUGH
+  // when sending buffering state changes. That being said, sending state
+  // changes here might be surprising, but the same signals are sent from
+  // MediaPlayerRenderer::StartPlayingFrom(), and it has been working mostly
+  // smoothly for all HLS playback.
+  client_->OnBufferingStateChange(media::BUFFERING_HAVE_ENOUGH);
 }
 
 void FlingingRenderer::SetPlaybackRate(double playback_rate) {

content/browser/media/flinging_renderer.h

@@ -58,6 +58,8 @@ class CONTENT_EXPORT FlingingRenderer : public media::Renderer,
   explicit FlingingRenderer(
       std::unique_ptr<media::FlingingController> controller);
 
+  media::RendererClient* client_;
+
   std::unique_ptr<media::FlingingController> controller_;
 
   DISALLOW_COPY_AND_ASSIGN(FlingingRenderer);

content/browser/media/flinging_renderer_unittest.cc

@@ -4,6 +4,7 @@
 
 #include "content/browser/media/flinging_renderer.h"
 
+#include "base/bind_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "base/version.h"
@@ -13,6 +14,7 @@
 
 using ::testing::_;
 using ::testing::StrictMock;
+using ::testing::NiceMock;
 
 namespace content {
 
@@ -25,6 +27,20 @@ class MockMediaController : public media::MediaController {
   MOCK_METHOD1(Seek, void(base::TimeDelta));
 };
 
+class MockRendererClient : public media::RendererClient {
+ public:
+  MOCK_METHOD1(OnError, void(media::PipelineStatus));
+  MOCK_METHOD0(OnEnded, void());
+  MOCK_METHOD1(OnStatisticsUpdate, void(const media::PipelineStatistics&));
+  MOCK_METHOD1(OnBufferingStateChange, void(media::BufferingState));
+  MOCK_METHOD0(OnWaitingForDecryptionKey, void());
+  MOCK_METHOD1(OnAudioConfigChange, void(const media::AudioDecoderConfig&));
+  MOCK_METHOD1(OnVideoConfigChange, void(const media::VideoDecoderConfig&));
+  MOCK_METHOD1(OnVideoNaturalSizeChange, void(const gfx::Size&));
+  MOCK_METHOD1(OnVideoOpacityChange, void(bool));
+  MOCK_METHOD1(OnDurationChange, void(base::TimeDelta));
+};
+
 class MockFlingingController : public media::FlingingController {
  public:
   explicit MockFlingingController(media::MediaController* media_controller)
@@ -51,9 +67,12 @@ class FlingingRendererTest : public testing::Test {
 
     renderer_ = base::WrapUnique(new FlingingRenderer(
         std::unique_ptr<media::FlingingController>(flinging_controller_)));
+
+    renderer_->Initialize(nullptr, &renderer_client_, base::DoNothing());
   }
 
  protected:
+  NiceMock<MockRendererClient> renderer_client_;
   std::unique_ptr<MockMediaController> media_controller_;
   StrictMock<MockFlingingController>* flinging_controller_;
   std::unique_ptr<FlingingRenderer> renderer_;