Move passing of WebRTC rendering frames to IO thread

content/renderer/media/webmediaplayer_ms_compositor.cc

 // Copyright 2015 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 "content/renderer/media/webmediaplayer_ms_compositor.h"
 
 #include <stdint.h>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 116 matching lines @@
     const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner,
     const blink::WebMediaStream& web_stream,
     const base::WeakPtr<WebMediaPlayerMS>& player)
     : compositor_task_runner_(compositor_task_runner),
       player_(player),
       video_frame_provider_client_(nullptr),
       current_frame_used_by_compositor_(false),
       last_render_length_(base::TimeDelta::FromSecondsD(1.0 / 60.0)),
       total_frame_count_(0),
       dropped_frame_count_(0),
-      stopped_(true),
-      weak_ptr_factory_(this) {
+      stopped_(true) {
   main_message_loop_ = base::MessageLoop::current();
+  io_thread_checker_.DetachFromThread();
 
   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
   if (!web_stream.isNull())
     web_stream.videoTracks(video_tracks);
 
   const bool remote_video =
       video_tracks.size() && video_tracks[0].source().remote();
 
   if (remote_video &&
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableRTCSmoothnessAlgorithm)) {
     base::AutoLock auto_lock(current_frame_lock_);
     rendering_frame_buffer_.reset(new media::VideoRendererAlgorithm(
         base::Bind(&WebMediaPlayerMSCompositor::MapTimestampsToRenderTimeTicks,
                    base::Unretained(this))));
   }
 
   // Just for logging purpose.
   std::string stream_id =
       web_stream.isNull() ? std::string() : web_stream.id().utf8();
   const uint32_t hash_value = base::Hash(stream_id);
   serial_ = (hash_value << 1) | (remote_video ? 1 : 0);
 }
 
 WebMediaPlayerMSCompositor::~WebMediaPlayerMSCompositor() {
-  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
-  if (video_frame_provider_client_)
-    video_frame_provider_client_->StopUsingProvider();
+  DCHECK(!video_frame_provider_client_)
+      << "Must call StopUsingProvider() before dtor!";
 }
 
 gfx::Size WebMediaPlayerMSCompositor::GetCurrentSize() {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(current_frame_lock_);
   return current_frame_ ? current_frame_->natural_size() : gfx::Size();
 }
 
 base::TimeDelta WebMediaPlayerMSCompositor::GetCurrentTime() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 19 matching lines @@
   if (video_frame_provider_client_)
     video_frame_provider_client_->StopUsingProvider();
 
   video_frame_provider_client_ = client;
   if (video_frame_provider_client_ && !stopped_)
     video_frame_provider_client_->StartRendering();
 }
 
 void WebMediaPlayerMSCompositor::EnqueueFrame(
     scoped_refptr<media::VideoFrame> frame) {
-  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
+  DCHECK(io_thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(current_frame_lock_);
   ++total_frame_count_;
 
   // With algorithm off, just let |current_frame_| hold the incoming |frame|.
   if (!rendering_frame_buffer_) {
     SetCurrentFrame(frame);
     return;
   }
 
   // This is a signal frame saying that the stream is stopped.
@@ skipping 92 matching lines @@
 scoped_refptr<media::VideoFrame>
 WebMediaPlayerMSCompositor::GetCurrentFrameWithoutUpdatingStatistics() {
   DVLOG(3) << __func__;
   base::AutoLock auto_lock(current_frame_lock_);
   return current_frame_;
 }
 
 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() {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(current_frame_lock_);
   if (!current_frame_.get() || !player_)
     return;
 
   // Copy the frame so that rendering can show the last received frame.
   // The original frame must not be referenced when the player is paused since
   // there might be a finite number of available buffers. E.g, video that
   // originates from a video camera.
   current_frame_ =
       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() ||
+         io_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]);
   }
   return true;
 }
 
 void WebMediaPlayerMSCompositor::Render(base::TimeTicks deadline_min,
                                         base::TimeTicks deadline_max) {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread() ||
@@ skipping 37 matching lines @@
       current_frame_->natural_size() != frame->natural_size();
   current_frame_ = frame;
   if (size_changed) {
     main_message_loop_->task_runner()->PostTask(
         FROM_HERE, base::Bind(&WebMediaPlayerMS::TriggerResize, player_));
   }
   main_message_loop_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&WebMediaPlayerMS::ResetCanvasCache, player_));
 }
 
+void WebMediaPlayerMSCompositor::StartRenderingInternal() {
+  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());
+  if (video_frame_provider_client_)
+    video_frame_provider_client_->StopUsingProvider();
+  video_frame_provider_client_ = nullptr;
+}
+
 void WebMediaPlayerMSCompositor::SetAlgorithmEnabledForTesting(
     bool algorithm_enabled) {
   if (!algorithm_enabled) {
     rendering_frame_buffer_.reset();
     return;
   }
 
   if (!rendering_frame_buffer_) {
     rendering_frame_buffer_.reset(new media::VideoRendererAlgorithm(
         base::Bind(&WebMediaPlayerMSCompositor::MapTimestampsToRenderTimeTicks,
                    base::Unretained(this))));
   }
 }
 
 }  // namespace content