Prime the landing pad for the new video rendering pipeline.

media/blink/webmediaplayer_impl.cc

Index: media/blink/webmediaplayer_impl.cc
diff --git a/media/blink/webmediaplayer_impl.cc b/media/blink/webmediaplayer_impl.cc
index 360b94f8ac6911587cfa875138c142d469ce3af5..8a47b9fec8dfb2a9dc6787b357fab8a6fd3f4573 100644
--- a/media/blink/webmediaplayer_impl.cc
+++ b/media/blink/webmediaplayer_impl.cc
@@ -134,8 +134,13 @@ WebMediaPlayerImpl::WebMediaPlayerImpl(
       context_3d_cb_(params.context_3d_cb()),
       supports_save_(true),
       chunk_demuxer_(NULL),
-      compositor_task_runner_(params.compositor_task_runner()),
+      // Threaded compositing isn't enabled universally yet.
+      compositor_task_runner_(
+          params.compositor_task_runner()
+              ? params.compositor_task_runner()
+              : base::MessageLoop::current()->task_runner()),
       compositor_(new VideoFrameCompositor(
+          compositor_task_runner_,
           BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnNaturalSizeChanged),
           BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnOpacityChanged))),
       encrypted_media_support_(
@@ -144,10 +149,6 @@ WebMediaPlayerImpl::WebMediaPlayerImpl(
           params.media_permission(),
           base::Bind(&WebMediaPlayerImpl::SetCdm, AsWeakPtr())),
       renderer_factory_(renderer_factory.Pass()) {
-  // Threaded compositing isn't enabled universally yet.
-  if (!compositor_task_runner_.get())
-    compositor_task_runner_ = base::MessageLoopProxy::current();
-
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 
@@ -176,6 +177,7 @@ WebMediaPlayerImpl::~WebMediaPlayerImpl() {
 
   if (delegate_)
     delegate_->PlayerGone(this);
+  compositor_->StopRendering();
 
   // Abort any pending IO so stopping the pipeline doesn't get blocked.
   if (data_source_)
@@ -258,8 +260,11 @@ void WebMediaPlayerImpl::play() {
 
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::PLAY));
 
-  if (delegate_ && playback_rate_ > 0)
-    delegate_->DidPlay(this);
+  if (playback_rate_ > 0) {
+    compositor_->StartRendering();
+    if (delegate_)
+      delegate_->DidPlay(this);
+  }
 }
 
 void WebMediaPlayerImpl::pause() {
@@ -275,8 +280,11 @@ void WebMediaPlayerImpl::pause() {
 
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::PAUSE));
 
-  if (!was_already_paused && delegate_)
-    delegate_->DidPause(this);
+  if (!was_already_paused) {
+    compositor_->StopRendering();
+    if (delegate_)
+      delegate_->DidPause(this);
+  }
 }
 
 bool WebMediaPlayerImpl::supportsSave() const {
@@ -348,10 +356,15 @@ void WebMediaPlayerImpl::setRate(double rate) {
       rate = kMinRate;
     else if (rate > kMaxRate)
       rate = kMaxRate;
-    if (playback_rate_ == 0 && !paused_ && delegate_)
-      delegate_->DidPlay(this);
-  } else if (playback_rate_ != 0 && !paused_ && delegate_) {
-    delegate_->DidPause(this);
+    if (playback_rate_ == 0 && !paused_) {
+      compositor_->StartRendering();
+      if (delegate_)
+        delegate_->DidPlay(this);
+    }
+  } else if (playback_rate_ != 0 && !paused_) {
+    compositor_->StopRendering();
+    if (delegate_)
+      delegate_->DidPause(this);
   }
 
   playback_rate_ = rate;
@@ -904,14 +917,13 @@ void WebMediaPlayerImpl::StartPipeline() {
 
   pipeline_.Start(
       demuxer_.get(),
-      renderer_factory_->CreateRenderer(media_task_runner_,
-                                        audio_source_provider_.get()),
+      renderer_factory_->CreateRenderer(
+          media_task_runner_, audio_source_provider_.get(), compositor_),
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineEnded),
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineError),
       BIND_TO_RENDER_LOOP1(&WebMediaPlayerImpl::OnPipelineSeeked, false),
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineMetadata),
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineBufferingStateChanged),
-      base::Bind(&WebMediaPlayerImpl::FrameReady, base::Unretained(this)),
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnDurationChanged),
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnAddTextTrack),
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnWaitingForDecryptionKey));
@@ -982,41 +994,12 @@ void WebMediaPlayerImpl::OnOpacityChanged(bool opaque) {
     video_weblayer_->setOpaque(opaque_);
 }
 
-void WebMediaPlayerImpl::FrameReady(
-    const scoped_refptr<VideoFrame>& frame) {
-  compositor_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&VideoFrameCompositor::UpdateCurrentFrame,
-                 base::Unretained(compositor_),
-                 frame));
-}
-
-static void GetCurrentFrameAndSignal(
-    VideoFrameCompositor* compositor,
-    scoped_refptr<VideoFrame>* video_frame_out,
-    base::WaitableEvent* event) {
-  TRACE_EVENT0("media", "GetCurrentFrameAndSignal");
-  *video_frame_out = compositor->GetCurrentFrame();
-  event->Signal();
-}
-
 scoped_refptr<VideoFrame>
 WebMediaPlayerImpl::GetCurrentFrameFromCompositor() {
   TRACE_EVENT0("media", "WebMediaPlayerImpl::GetCurrentFrameFromCompositor");
-  if (compositor_task_runner_->BelongsToCurrentThread())
-    return compositor_->GetCurrentFrame();
-
-  // Use a posted task and waitable event instead of a lock otherwise
-  // WebGL/Canvas can see different content than what the compositor is seeing.
-  scoped_refptr<VideoFrame> video_frame;
-  base::WaitableEvent event(false, false);
-  compositor_task_runner_->PostTask(FROM_HERE,
-                                    base::Bind(&GetCurrentFrameAndSignal,
-                                               base::Unretained(compositor_),
-                                               &video_frame,
-                                               &event));
-  event.Wait();
-  return video_frame;
+  // Since the compositor is driving frame collection, this should be at most
+  // one frame off; which is as good as we can get without a push based model.
+  return compositor_->GetCurrentFrame();
 }
 
 void WebMediaPlayerImpl::UpdatePausedTime() {