Move passing of WebRTC rendering frames to IO thread

content/renderer/media/webmediaplayer_ms.cc

Index: content/renderer/media/webmediaplayer_ms.cc
diff --git a/content/renderer/media/webmediaplayer_ms.cc b/content/renderer/media/webmediaplayer_ms.cc
index 8be81de1a75bd50917e35a1a4c2e2d218272cad3..b1c5a70eb687ff718f5ec12492f50167e45c90ef 100644
--- a/content/renderer/media/webmediaplayer_ms.cc
+++ b/content/renderer/media/webmediaplayer_ms.cc
@@ -42,30 +42,25 @@ namespace content {
 // compositor thread by calling of EnqueueFrame() method of |compositor_|.
 //
 // It is created on the main thread, but methods should be called and class
-// should be destructed on the compositor thread.
+// should be destructed on the media thread.
 class WebMediaPlayerMS::FrameDeliverer {
  public:
-  typedef base::Callback<void(scoped_refptr<media::VideoFrame>)>
-      EnqueueFrameCallback;
-
   FrameDeliverer(const base::WeakPtr<WebMediaPlayerMS>& player,
-                 const EnqueueFrameCallback& enqueue_frame_cb)
+                 const MediaStreamVideoRenderer::RepaintCB& enqueue_frame_cb)
       : last_frame_opaque_(true),
         last_frame_rotation_(media::VIDEO_ROTATION_0),
         received_first_frame_(false),
         main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
         player_(player),
         enqueue_frame_cb_(enqueue_frame_cb),
-        weak_factory_for_compositor_(this) {
-    compositor_thread_checker_.DetachFromThread();
+        weak_factory_(this) {
+    media_thread_checker_.DetachFromThread();
   }
 
-  ~FrameDeliverer() {
-    DCHECK(compositor_thread_checker_.CalledOnValidThread());
-  }
+  ~FrameDeliverer() { DCHECK(media_thread_checker_.CalledOnValidThread()); }
 
   void OnVideoFrame(scoped_refptr<media::VideoFrame> frame) {
-    DCHECK(compositor_thread_checker_.CalledOnValidThread());
+    DCHECK(media_thread_checker_.CalledOnValidThread());
 
 #if defined(OS_ANDROID)
     if (render_frame_suspended_)
@@ -113,14 +108,14 @@ class WebMediaPlayerMS::FrameDeliverer {
 
 #if defined(OS_ANDROID)
   void SetRenderFrameSuspended(bool render_frame_suspended) {
-    DCHECK(compositor_thread_checker_.CalledOnValidThread());
+    DCHECK(media_thread_checker_.CalledOnValidThread());
     render_frame_suspended_ = render_frame_suspended;
   }
 #endif  // defined(OS_ANDROID)
 
   MediaStreamVideoRenderer::RepaintCB GetRepaintCallback() {
     return base::Bind(&FrameDeliverer::OnVideoFrame,
-                      weak_factory_for_compositor_.GetWeakPtr());
+                      weak_factory_.GetWeakPtr());
   }
 
  private:
@@ -134,13 +129,13 @@ class WebMediaPlayerMS::FrameDeliverer {
 
   const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
   const base::WeakPtr<WebMediaPlayerMS> player_;
-  const EnqueueFrameCallback enqueue_frame_cb_;
+  const MediaStreamVideoRenderer::RepaintCB enqueue_frame_cb_;
 
   // Used for DCHECKs to ensure method calls executed on the correct thread,
-  // i.e. compositor thread.
-  base::ThreadChecker compositor_thread_checker_;
+  // i.e. media thread.
+  base::ThreadChecker media_thread_checker_;
 
-  base::WeakPtrFactory<FrameDeliverer> weak_factory_for_compositor_;
+  base::WeakPtrFactory<FrameDeliverer> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FrameDeliverer);
 };
@@ -198,10 +193,10 @@ WebMediaPlayerMS::~WebMediaPlayerMS() {
     static_cast<cc::VideoLayer*>(video_weblayer_->layer())->StopUsingProvider();
 
   if (frame_deliverer_)
-    compositor_task_runner_->DeleteSoon(FROM_HERE, frame_deliverer_.release());
+    media_task_runner_->DeleteSoon(FROM_HERE, frame_deliverer_.release());
 
   if (compositor_)
-    compositor_task_runner_->DeleteSoon(FROM_HERE, compositor_.release());
+    compositor_->StopUsingProvider();
 
   if (video_frame_provider_)
     video_frame_provider_->Stop();
@@ -230,8 +225,8 @@ void WebMediaPlayerMS::load(LoadType load_type,
   blink::WebMediaStream web_stream =
       GetWebMediaStreamFromWebMediaPlayerSource(source);
 
-  compositor_.reset(new WebMediaPlayerMSCompositor(compositor_task_runner_,
-                                                   web_stream, AsWeakPtr()));
+  compositor_ = new WebMediaPlayerMSCompositor(compositor_task_runner_,
+                                               web_stream, AsWeakPtr());
 
   SetNetworkState(WebMediaPlayer::NetworkStateLoading);
   SetReadyState(WebMediaPlayer::ReadyStateHaveNothing);
@@ -239,16 +234,14 @@ void WebMediaPlayerMS::load(LoadType load_type,
       web_stream.isNull() ? std::string() : web_stream.id().utf8();
   media_log_->AddEvent(media_log_->CreateLoadEvent(stream_id));
 
-  // base::Unretained usage is safe here because |compositor_| is destroyed
-  // after |frame_deliverer_|.
   frame_deliverer_.reset(new WebMediaPlayerMS::FrameDeliverer(
-      AsWeakPtr(), base::Bind(&WebMediaPlayerMSCompositor::EnqueueFrame,
-                              base::Unretained(compositor_.get()))));
+      AsWeakPtr(),
+      base::Bind(&WebMediaPlayerMSCompositor::EnqueueFrame, compositor_)));
   video_frame_provider_ = renderer_factory_->GetVideoRenderer(
       web_stream, media::BindToCurrentLoop(base::Bind(
                       &WebMediaPlayerMS::OnSourceError, AsWeakPtr())),
-      frame_deliverer_->GetRepaintCallback(), compositor_task_runner_,
-      media_task_runner_, worker_task_runner_, gpu_factories_);
+      frame_deliverer_->GetRepaintCallback(), media_task_runner_,
+      worker_task_runner_, gpu_factories_);
 
   RenderFrame* const frame = RenderFrame::FromWebFrame(frame_);
 
@@ -519,7 +512,7 @@ void WebMediaPlayerMS::OnHidden() {
   // During undoable tab closures OnHidden() may be called back to back, so we
   // can't rely on |render_frame_suspended_| being false here.
   if (frame_deliverer_) {
-    compositor_task_runner_->PostTask(
+    media_task_runner_->PostTask(
         FROM_HERE, base::Bind(&FrameDeliverer::SetRenderFrameSuspended,
                               base::Unretained(frame_deliverer_.get()), true));
   }
@@ -534,7 +527,7 @@ void WebMediaPlayerMS::OnShown() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (frame_deliverer_) {
-    compositor_task_runner_->PostTask(
+    media_task_runner_->PostTask(
         FROM_HERE, base::Bind(&FrameDeliverer::SetRenderFrameSuspended,
                               base::Unretained(frame_deliverer_.get()), false));
   }
@@ -559,7 +552,7 @@ bool WebMediaPlayerMS::OnSuspendRequested(bool must_suspend) {
     delegate_->PlayerGone(delegate_id_);
 
   if (frame_deliverer_) {
-    compositor_task_runner_->PostTask(
+    media_task_runner_->PostTask(
         FROM_HERE, base::Bind(&FrameDeliverer::SetRenderFrameSuspended,
                               base::Unretained(frame_deliverer_.get()), true));
   }