Prime the landing pad for the new video rendering pipeline.

media/blink/webmediaplayer_impl.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/blink/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 116 matching lines @@
       ended_(false),
       pending_seek_(false),
       pending_seek_seconds_(0.0f),
       should_notify_time_changed_(false),
       client_(client),
       delegate_(delegate),
       defer_load_cb_(params.defer_load_cb()),
       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_(
           cdm_factory.Pass(),
           client,
           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));
 
   if (params.initial_cdm()) {
     SetCdm(
         ToWebContentDecryptionModuleImpl(params.initial_cdm())->GetCdmContext(),
         base::Bind(&IgnoreCdmAttached));
   }
 
   // TODO(xhwang): When we use an external Renderer, many methods won't work,
   // e.g. GetCurrentFrameFromCompositor(). See http://crbug.com/434861
 
   // Use the null sink if no sink was provided.
   audio_source_provider_ = new WebAudioSourceProviderImpl(
       params.audio_renderer_sink().get()
           ? params.audio_renderer_sink()
           : new NullAudioSink(media_task_runner_));
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
   client_->setWebLayer(NULL);
 
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::WEBMEDIAPLAYER_DESTROYED));
 
   if (delegate_)
     delegate_->PlayerGone(this);
+  compositor_->StopRendering();
 
   // Abort any pending IO so stopping the pipeline doesn't get blocked.
   if (data_source_)
     data_source_->Abort();
   if (chunk_demuxer_) {
     chunk_demuxer_->Shutdown();
     chunk_demuxer_ = NULL;
   }
 
   renderer_factory_.reset();
@@ skipping 62 matching lines @@
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   paused_ = false;
   pipeline_.SetPlaybackRate(playback_rate_);
   if (data_source_)
     data_source_->MediaIsPlaying();
 
   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() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   const bool was_already_paused = paused_ || playback_rate_ == 0;
   paused_ = true;
   pipeline_.SetPlaybackRate(0.0f);
   if (data_source_)
     data_source_->MediaIsPaused();
   UpdatePausedTime();
 
   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 {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   return supports_save_;
 }
 
 void WebMediaPlayerImpl::seek(double seconds) {
   DVLOG(1) << __FUNCTION__ << "(" << seconds << "s)";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
@@ skipping 51 matching lines @@
   // following checks so rewind uses reasonable values also.
   if (rate < 0.0)
     return;
 
   // Limit rates to reasonable values by clamping.
   if (rate != 0.0) {
     if (rate < kMinRate)
       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;
   if (!paused_) {
     pipeline_.SetPlaybackRate(rate);
     if (data_source_)
       data_source_->MediaPlaybackRateChanged(rate);
   }
 }
 
@@ skipping 532 matching lines @@
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnDemuxerOpened),
         encrypted_media_init_data_cb, mse_log_cb, media_log_, true);
     demuxer_.reset(chunk_demuxer_);
   }
 
   // ... and we're ready to go!
   seeking_ = true;
 
   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));
 }
 
 void WebMediaPlayerImpl::SetNetworkState(WebMediaPlayer::NetworkState state) {
   DVLOG(1) << __FUNCTION__ << "(" << state << ")";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   network_state_ = state;
   // Always notify to ensure client has the latest value.
@@ skipping 50 matching lines @@
 
 void WebMediaPlayerImpl::OnOpacityChanged(bool opaque) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(ready_state_, WebMediaPlayer::ReadyStateHaveNothing);
 
   opaque_ = opaque;
   if (video_weblayer_)
     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() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // pause() may be called after playback has ended and the HTMLMediaElement
   // requires that currentTime() == duration() after ending.  We want to ensure
   // |paused_time_| matches currentTime() in this case or a future seek() may
   // incorrectly discard what it thinks is a seek to the existing time.
   paused_time_ =
       ended_ ? pipeline_.GetMediaDuration() : pipeline_.GetMediaTime();
 }
 
 }  // namespace media