Move passing of WebRTC rendering frames to IO thread

content/renderer/media/media_stream_video_renderer_sink.cc

Index: content/renderer/media/media_stream_video_renderer_sink.cc
diff --git a/content/renderer/media/media_stream_video_renderer_sink.cc b/content/renderer/media/media_stream_video_renderer_sink.cc
index c7341aa8442590502307ce2bf7082c7c9a4f8a07..12f43996ee137c98cb5eb61fb11099c2571cab9e 100644
--- a/content/renderer/media/media_stream_video_renderer_sink.cc
+++ b/content/renderer/media/media_stream_video_renderer_sink.cc
@@ -24,10 +24,10 @@ const int kMinFrameSize = 2;
 namespace content {
 
 // FrameDeliverer is responsible for delivering frames received on
-// OnVideoFrame() to |repaint_cb_| on compositor thread.
+// OnVideoFrame() to |repaint_cb_| on |media_task_runner_|.
 //
 // 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 |media_task_runner_|.
 class MediaStreamVideoRendererSink::FrameDeliverer {
  public:
   FrameDeliverer(const RepaintCB& repaint_cb,
@@ -39,7 +39,6 @@ class MediaStreamVideoRendererSink::FrameDeliverer {
         frame_size_(kMinFrameSize, kMinFrameSize),
         media_task_runner_(media_task_runner),
         weak_factory_(this) {
-    compositor_thread_checker_.DetachFromThread();
     weak_this_ = weak_factory_.GetWeakPtr();
     if (gpu_factories &&
         gpu_factories->ShouldUseGpuMemoryBuffersForVideoFrames() &&
@@ -51,18 +50,13 @@ class MediaStreamVideoRendererSink::FrameDeliverer {
   }
 
   ~FrameDeliverer() {
-    DCHECK(compositor_thread_checker_.CalledOnValidThread());
+    DCHECK(media_task_runner_->BelongsToCurrentThread());
     DCHECK(state_ == STARTED || state_ == PAUSED) << state_;
-
-    if (gpu_memory_buffer_pool_) {
-      media_task_runner_->DeleteSoon(FROM_HERE,
-                                     gpu_memory_buffer_pool_.release());
-    }
   }
 
   void OnVideoFrame(const scoped_refptr<media::VideoFrame>& frame,
                     base::TimeTicks /*current_time*/) {
-    DCHECK(compositor_thread_checker_.CalledOnValidThread());
+    DCHECK(media_task_runner_->BelongsToCurrentThread());
     DCHECK(frame);
     TRACE_EVENT_INSTANT1("webrtc",
                          "MediaStreamVideoRendererSink::"
@@ -77,21 +71,13 @@ class MediaStreamVideoRendererSink::FrameDeliverer {
       FrameReady(frame);
       return;
     }
-
-    //  |gpu_memory_buffer_pool_| deletion is going to be posted to
-    //  |media_task_runner_|. base::Unretained() usage is fine since
-    //  |gpu_memory_buffer_pool_| outlives the task.
-    media_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(
-            &media::GpuMemoryBufferVideoFramePool::MaybeCreateHardwareFrame,
-            base::Unretained(gpu_memory_buffer_pool_.get()), frame,
-            media::BindToCurrentLoop(
-                base::Bind(&FrameDeliverer::FrameReady, weak_this_))));
+    gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
+        frame, media::BindToCurrentLoop(
+                   base::Bind(&FrameDeliverer::FrameReady, weak_this_)));
   }
 
   void FrameReady(const scoped_refptr<media::VideoFrame>& frame) {
-    DCHECK(compositor_thread_checker_.CalledOnValidThread());
+    DCHECK(media_task_runner_->BelongsToCurrentThread());
     DCHECK(frame);
     TRACE_EVENT_INSTANT1(
         "webrtc", "MediaStreamVideoRendererSink::FrameDeliverer::FrameReady",
@@ -103,7 +89,7 @@ class MediaStreamVideoRendererSink::FrameDeliverer {
   }
 
   void RenderEndOfStream() {
-    DCHECK(compositor_thread_checker_.CalledOnValidThread());
+    DCHECK(media_task_runner_->BelongsToCurrentThread());
     // This is necessary to make sure audio can play if the video tag src is a
     // MediaStream video track that has been rejected or ended. It also ensure
     // that the renderer doesn't hold a reference to a real video frame if no
@@ -121,19 +107,19 @@ class MediaStreamVideoRendererSink::FrameDeliverer {
   }
 
   void Start() {
-    DCHECK(compositor_thread_checker_.CalledOnValidThread());
+    DCHECK(media_task_runner_->BelongsToCurrentThread());
     DCHECK_EQ(state_, STOPPED);
     state_ = STARTED;
   }
 
   void Resume() {
-    DCHECK(compositor_thread_checker_.CalledOnValidThread());
+    DCHECK(media_task_runner_->BelongsToCurrentThread());
     if (state_ == PAUSED)
       state_ = STARTED;
   }
 
   void Pause() {
-    DCHECK(compositor_thread_checker_.CalledOnValidThread());
+    DCHECK(media_task_runner_->BelongsToCurrentThread());
     if (state_ == STARTED)
       state_ = PAUSED;
   }
@@ -147,7 +133,7 @@ class MediaStreamVideoRendererSink::FrameDeliverer {
 
   void SetGpuMemoryBufferVideoForTesting(
       media::GpuMemoryBufferVideoFramePool* gpu_memory_buffer_pool) {
-    DCHECK(compositor_thread_checker_.CalledOnValidThread());
+    DCHECK(media_task_runner_->BelongsToCurrentThread());
     gpu_memory_buffer_pool_.reset(gpu_memory_buffer_pool);
   }
 
@@ -159,9 +145,6 @@ class MediaStreamVideoRendererSink::FrameDeliverer {
   std::unique_ptr<media::GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_;
   const scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
 
-  // Used for DCHECKs to ensure method calls are executed on the correct thread.
-  base::ThreadChecker compositor_thread_checker_;
-
   base::WeakPtr<FrameDeliverer> weak_this_;
   base::WeakPtrFactory<FrameDeliverer> weak_factory_;
 
@@ -169,16 +152,16 @@ class MediaStreamVideoRendererSink::FrameDeliverer {
 };
 
 // FrameReceiver is responsible for trampolining frames from IO thread to
-// the compositor thread by posting a task on |deliver_frame_cb_|.
+// media thread by posting a task on |deliver_frame_cb_|.
 //
 // It is created on main thread, but methods should be called and class should
 // be destructed on the IO thread.
 class MediaStreamVideoRendererSink::FrameReceiver {
  public:
   FrameReceiver(
-      const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner,
+      const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const VideoCaptureDeliverFrameCB& deliver_frame_cb)
-      : compositor_task_runner_(compositor_task_runner),
+      : media_task_runner_(media_task_runner),
         deliver_frame_cb_(deliver_frame_cb) {
     io_thread_checker_.DetachFromThread();
   }
@@ -188,12 +171,12 @@ class MediaStreamVideoRendererSink::FrameReceiver {
   void OnVideoFrame(const scoped_refptr<media::VideoFrame>& frame,
                     base::TimeTicks current_time) {
     DCHECK(io_thread_checker_.CalledOnValidThread());
-    compositor_task_runner_->PostTask(
+    media_task_runner_->PostTask(
         FROM_HERE, base::Bind(deliver_frame_cb_, frame, current_time));
   }
 
  private:
-  const scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
+  const scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
   const VideoCaptureDeliverFrameCB deliver_frame_cb_;
 
   // Used for DCHECKs to ensure method calls executed in the correct thread.
@@ -206,14 +189,12 @@ MediaStreamVideoRendererSink::MediaStreamVideoRendererSink(
     const blink::WebMediaStreamTrack& video_track,
     const base::Closure& error_cb,
     const RepaintCB& repaint_cb,
-    const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const scoped_refptr<base::TaskRunner>& worker_task_runner,
     media::GpuVideoAcceleratorFactories* gpu_factories)
     : error_cb_(error_cb),
       repaint_cb_(repaint_cb),
       video_track_(video_track),
-      compositor_task_runner_(compositor_task_runner),
       media_task_runner_(media_task_runner),
       worker_task_runner_(worker_task_runner),
       gpu_factories_(gpu_factories) {}
@@ -225,12 +206,12 @@ void MediaStreamVideoRendererSink::Start() {
 
   frame_deliverer_.reset(new MediaStreamVideoRendererSink::FrameDeliverer(
       repaint_cb_, media_task_runner_, worker_task_runner_, gpu_factories_));
-  compositor_task_runner_->PostTask(
+  media_task_runner_->PostTask(
       FROM_HERE, base::Bind(&FrameDeliverer::Start,
                             base::Unretained(frame_deliverer_.get())));
 
   frame_receiver_.reset(new MediaStreamVideoRendererSink::FrameReceiver(
-      compositor_task_runner_, frame_deliverer_->GetDeliverFrameCallback()));
+      media_task_runner_, frame_deliverer_->GetDeliverFrameCallback()));
   MediaStreamVideoSink::ConnectToTrack(
       video_track_,
       // This callback is run on IO thread. It is safe to use base::Unretained
@@ -244,7 +225,7 @@ void MediaStreamVideoRendererSink::Start() {
   if (video_track_.source().getReadyState() ==
           blink::WebMediaStreamSource::ReadyStateEnded ||
       !video_track_.isEnabled()) {
-    compositor_task_runner_->PostTask(
+    media_task_runner_->PostTask(
         FROM_HERE, base::Bind(&FrameDeliverer::RenderEndOfStream,
                               base::Unretained(frame_deliverer_.get())));
   }
@@ -259,7 +240,7 @@ void MediaStreamVideoRendererSink::Stop() {
         FROM_HERE, frame_receiver_.release());
   }
   if (frame_deliverer_)
-    compositor_task_runner_->DeleteSoon(FROM_HERE, frame_deliverer_.release());
+    media_task_runner_->DeleteSoon(FROM_HERE, frame_deliverer_.release());
 }
 
 void MediaStreamVideoRendererSink::Resume() {
@@ -267,7 +248,7 @@ void MediaStreamVideoRendererSink::Resume() {
   if (!frame_deliverer_)
     return;
 
-  compositor_task_runner_->PostTask(
+  media_task_runner_->PostTask(
       FROM_HERE, base::Bind(&FrameDeliverer::Resume,
                             base::Unretained(frame_deliverer_.get())));
 }
@@ -277,7 +258,7 @@ void MediaStreamVideoRendererSink::Pause() {
   if (!frame_deliverer_)
     return;
 
-  compositor_task_runner_->PostTask(
+  media_task_runner_->PostTask(
       FROM_HERE, base::Bind(&FrameDeliverer::Pause,
                             base::Unretained(frame_deliverer_.get())));
 }
@@ -287,7 +268,7 @@ void MediaStreamVideoRendererSink::OnReadyStateChanged(
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (state == blink::WebMediaStreamSource::ReadyStateEnded &&
       frame_deliverer_) {
-    compositor_task_runner_->PostTask(
+    media_task_runner_->PostTask(
         FROM_HERE, base::Bind(&FrameDeliverer::RenderEndOfStream,
                               base::Unretained(frame_deliverer_.get())));
   }
@@ -305,7 +286,7 @@ void MediaStreamVideoRendererSink::SetGpuMemoryBufferVideoForTesting(
     media::GpuMemoryBufferVideoFramePool* gpu_memory_buffer_pool) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   CHECK(frame_deliverer_);
-  compositor_task_runner_->PostTask(
+  media_task_runner_->PostTask(
       FROM_HERE, base::Bind(&FrameDeliverer::SetGpuMemoryBufferVideoForTesting,
                             base::Unretained(frame_deliverer_.get()),
                             gpu_memory_buffer_pool));