Move passing of WebRTC rendering frames to IO thread

content/renderer/media/webmediaplayer_ms_compositor.cc

Index: content/renderer/media/webmediaplayer_ms_compositor.cc
diff --git a/content/renderer/media/webmediaplayer_ms_compositor.cc b/content/renderer/media/webmediaplayer_ms_compositor.cc
index 4a7dd8ca91b2ee73db1376fffd57362fc716266b..0c1bdf2be19de471ddfc0b00b16a371cc4c79657 100644
--- a/content/renderer/media/webmediaplayer_ms_compositor.cc
+++ b/content/renderer/media/webmediaplayer_ms_compositor.cc
@@ -135,8 +135,9 @@ WebMediaPlayerMSCompositor::WebMediaPlayerMSCompositor(
       total_frame_count_(0),
       dropped_frame_count_(0),
       stopped_(true),
-      weak_ptr_factory_(this) {
+      provider_in_use_(false) {
   main_message_loop_ = base::MessageLoop::current();
+  media_thread_checker_.DetachFromThread();
 
   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
   if (!web_stream.isNull())
@@ -162,9 +163,7 @@ WebMediaPlayerMSCompositor::WebMediaPlayerMSCompositor(
 }
 
 WebMediaPlayerMSCompositor::~WebMediaPlayerMSCompositor() {
-  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
-  if (video_frame_provider_client_)
-    video_frame_provider_client_->StopUsingProvider();
+  DCHECK(!provider_in_use_) << "Must call StopUsingProvider() before dtor!";
 }
 
 gfx::Size WebMediaPlayerMSCompositor::GetCurrentSize() {
@@ -200,11 +199,12 @@ void WebMediaPlayerMSCompositor::SetVideoFrameProviderClient(
   video_frame_provider_client_ = client;
   if (video_frame_provider_client_ && !stopped_)
     video_frame_provider_client_->StartRendering();
+  provider_in_use_ = true;
 }
 
 void WebMediaPlayerMSCompositor::EnqueueFrame(
     scoped_refptr<media::VideoFrame> frame) {
-  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
+  DCHECK(media_thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(current_frame_lock_);
   ++total_frame_count_;
 
@@ -317,41 +317,15 @@ WebMediaPlayerMSCompositor::GetCurrentFrameWithoutUpdatingStatistics() {
 void WebMediaPlayerMSCompositor::StartRendering() {
   DCHECK(thread_checker_.CalledOnValidThread());
   compositor_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&WebMediaPlayerMSCompositor::StartRenderingInternal,
-                            weak_ptr_factory_.GetWeakPtr()));
-}
-
-void WebMediaPlayerMSCompositor::StartRenderingInternal() {
-  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
-  stopped_ = false;
-
-  if (video_frame_provider_client_)
-    video_frame_provider_client_->StartRendering();
+      FROM_HERE,
+      base::Bind(&WebMediaPlayerMSCompositor::StartRenderingInternal, this));
 }
 
 void WebMediaPlayerMSCompositor::StopRendering() {
   DCHECK(thread_checker_.CalledOnValidThread());
   compositor_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&WebMediaPlayerMSCompositor::StopRenderingInternal,
-                            weak_ptr_factory_.GetWeakPtr()));
-}
-
-void WebMediaPlayerMSCompositor::StopRenderingInternal() {
-  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
-  stopped_ = true;
-
-  // It is possible that the video gets paused and then resumed. We need to
-  // reset VideoRendererAlgorithm, otherwise, VideoRendererAlgorithm will think
-  // there is a very long frame in the queue and then make totally wrong
-  // frame selection.
-  {
-    base::AutoLock auto_lock(current_frame_lock_);
-    if (rendering_frame_buffer_)
-      rendering_frame_buffer_->Reset();
-  }
-
-  if (video_frame_provider_client_)
-    video_frame_provider_client_->StopRendering();
+      FROM_HERE,
+      base::Bind(&WebMediaPlayerMSCompositor::StopRenderingInternal, this));
 }
 
 void WebMediaPlayerMSCompositor::ReplaceCurrentFrameWithACopy() {
@@ -368,11 +342,19 @@ void WebMediaPlayerMSCompositor::ReplaceCurrentFrameWithACopy() {
       CopyFrame(current_frame_, player_->GetSkCanvasVideoRenderer());
 }
 
+void WebMediaPlayerMSCompositor::StopUsingProvider() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  compositor_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&WebMediaPlayerMSCompositor::StopUsingProviderInternal, this));
+}
+
 bool WebMediaPlayerMSCompositor::MapTimestampsToRenderTimeTicks(
     const std::vector<base::TimeDelta>& timestamps,
     std::vector<base::TimeTicks>* wall_clock_times) {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread() ||
-         thread_checker_.CalledOnValidThread());
+         thread_checker_.CalledOnValidThread() ||
+         media_thread_checker_.CalledOnValidThread());
   for (const base::TimeDelta& timestamp : timestamps) {
     DCHECK(timestamps_to_clock_times_.count(timestamp));
     wall_clock_times->push_back(timestamps_to_clock_times_[timestamp]);
@@ -430,6 +412,39 @@ void WebMediaPlayerMSCompositor::SetCurrentFrame(
       FROM_HERE, base::Bind(&WebMediaPlayerMS::ResetCanvasCache, player_));
 }
 
+void WebMediaPlayerMSCompositor::StartRenderingInternal() {

[qiangchen, 2016/12/05 18:54:57]

I think it is better to put these two functions where they are, as it would make
code review a little easier.

[qiangchen, 2016/12/06 17:48:17]

Acknowledged.

+  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
+  stopped_ = false;
+
+  if (video_frame_provider_client_)
+    video_frame_provider_client_->StartRendering();
+}
+
+void WebMediaPlayerMSCompositor::StopRenderingInternal() {
+  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
+  stopped_ = true;
+
+  // It is possible that the video gets paused and then resumed. We need to
+  // reset VideoRendererAlgorithm, otherwise, VideoRendererAlgorithm will think
+  // there is a very long frame in the queue and then make totally wrong
+  // frame selection.
+  {
+    base::AutoLock auto_lock(current_frame_lock_);
+    if (rendering_frame_buffer_)
+      rendering_frame_buffer_->Reset();
+  }
+
+  if (video_frame_provider_client_)
+    video_frame_provider_client_->StopRendering();
+}
+
+void WebMediaPlayerMSCompositor::StopUsingProviderInternal() {
+  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
+  provider_in_use_ = false;
+  if (video_frame_provider_client_)
+    video_frame_provider_client_->StopUsingProvider();
+}
+
 void WebMediaPlayerMSCompositor::SetAlgorithmEnabledForTesting(
     bool algorithm_enabled) {
   if (!algorithm_enabled) {