content/child: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

content/renderer/media/video_track_adapter.cc

 // Copyright 2014 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/video_track_adapter.h"
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
@@ skipping 340 matching lines @@
   if (keep_frame_counter_ >= 1) {
     keep_frame_counter_ -= 1;
     // Keep the frame.
     return false;
   }
   DVLOG(3) << "Drop frame. Input frame_rate_ " << frame_rate_ << ".";
   return true;
 }
 
 VideoTrackAdapter::VideoTrackAdapter(
-    const scoped_refptr<base::MessageLoopProxy>& io_message_loop)
-    : io_message_loop_(io_message_loop),
-      renderer_task_runner_(base::MessageLoopProxy::current()),
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
+    : io_task_runner_(io_task_runner),
+      renderer_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       monitoring_frame_rate_(false),
       muted_state_(false),
       frame_counter_(0),
       source_frame_rate_(0.0f) {
-  DCHECK(io_message_loop_.get());
+  DCHECK(io_task_runner);
 }
 
 VideoTrackAdapter::~VideoTrackAdapter() {
   DCHECK(adapters_.empty());
 }
 
 void VideoTrackAdapter::AddTrack(const MediaStreamVideoTrack* track,
                                  VideoCaptureDeliverFrameCB frame_callback,
                                  int max_width,
                                  int max_height,
                                  double min_aspect_ratio,
                                  double max_aspect_ratio,
                                  double max_frame_rate) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  io_message_loop_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&VideoTrackAdapter::AddTrackOnIO,
-                 this, track, frame_callback, gfx::Size(max_width, max_height),
-                 min_aspect_ratio, max_aspect_ratio, max_frame_rate));
+      base::Bind(&VideoTrackAdapter::AddTrackOnIO, this, track, frame_callback,
+                 gfx::Size(max_width, max_height), min_aspect_ratio,
+                 max_aspect_ratio, max_frame_rate));
 }
 
 void VideoTrackAdapter::AddTrackOnIO(const MediaStreamVideoTrack* track,
                                      VideoCaptureDeliverFrameCB frame_callback,
                                      const gfx::Size& max_frame_size,
                                      double min_aspect_ratio,
                                      double max_aspect_ratio,
                                      double max_frame_rate) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   scoped_refptr<VideoFrameResolutionAdapter> adapter;
   for (const auto& frame_adapter : adapters_) {
     if (frame_adapter->ConstraintsMatch(max_frame_size, min_aspect_ratio,
                                         max_aspect_ratio, max_frame_rate)) {
       adapter = frame_adapter.get();
       break;
     }
   }
   if (!adapter.get()) {
     adapter = new VideoFrameResolutionAdapter(renderer_task_runner_,
                                               max_frame_size,
                                               min_aspect_ratio,
                                               max_aspect_ratio,
                                               max_frame_rate);
     adapters_.push_back(adapter);
   }
 
   adapter->AddCallback(track, frame_callback);
 }
 
 void VideoTrackAdapter::RemoveTrack(const MediaStreamVideoTrack* track) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  io_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&VideoTrackAdapter::RemoveTrackOnIO, this, track));
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoTrackAdapter::RemoveTrackOnIO, this, track));
 }
 
 void VideoTrackAdapter::StartFrameMonitoring(
     double source_frame_rate,
     const OnMutedCallback& on_muted_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   VideoTrackAdapter::OnMutedCallback bound_on_muted_callback =
       media::BindToCurrentLoop(on_muted_callback);
 
-  io_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&VideoTrackAdapter::StartFrameMonitoringOnIO,
-                 this, bound_on_muted_callback, source_frame_rate));
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoTrackAdapter::StartFrameMonitoringOnIO, this,
+                            bound_on_muted_callback, source_frame_rate));
 }
 
 void VideoTrackAdapter::StopFrameMonitoring() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  io_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&VideoTrackAdapter::StopFrameMonitoringOnIO, this));
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoTrackAdapter::StopFrameMonitoringOnIO, this));
 }
 
 void VideoTrackAdapter::StartFrameMonitoringOnIO(
     const OnMutedCallback& on_muted_callback,
     double source_frame_rate) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   DCHECK(!monitoring_frame_rate_);
 
   monitoring_frame_rate_ = true;
 
   // If the source does not know the frame rate, set one by default.
   if (source_frame_rate == 0.0f)
     source_frame_rate = MediaStreamVideoSource::kDefaultFrameRate;
   source_frame_rate_ = source_frame_rate;
   DVLOG(1) << "Monitoring frame creation, first (large) delay: "
       << (kFirstFrameTimeoutInFrameIntervals / source_frame_rate_) << "s";
-  io_message_loop_->PostDelayedTask(FROM_HERE,
-       base::Bind(&VideoTrackAdapter::CheckFramesReceivedOnIO, this,
-                  on_muted_callback, frame_counter_),
-       base::TimeDelta::FromSecondsD(kFirstFrameTimeoutInFrameIntervals /
-                                     source_frame_rate_));
+  io_task_runner_->PostDelayedTask(
+      FROM_HERE, base::Bind(&VideoTrackAdapter::CheckFramesReceivedOnIO, this,
+                            on_muted_callback, frame_counter_),
+      base::TimeDelta::FromSecondsD(kFirstFrameTimeoutInFrameIntervals /
+                                    source_frame_rate_));
 }
 
 void VideoTrackAdapter::StopFrameMonitoringOnIO() {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   monitoring_frame_rate_ = false;
 }
 
 void VideoTrackAdapter::RemoveTrackOnIO(const MediaStreamVideoTrack* track) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   for (FrameAdapters::iterator it = adapters_.begin();
        it != adapters_.end(); ++it) {
     (*it)->RemoveCallback(track);
     if ((*it)->IsEmpty()) {
       adapters_.erase(it);
       break;
     }
   }
 }
 
 void VideoTrackAdapter::DeliverFrameOnIO(
     const scoped_refptr<media::VideoFrame>& frame,
     const base::TimeTicks& estimated_capture_time) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   TRACE_EVENT0("video", "VideoTrackAdapter::DeliverFrameOnIO");
   ++frame_counter_;
   for (const auto& adapter : adapters_)
     adapter->DeliverFrame(frame, estimated_capture_time);
 }
 
 void VideoTrackAdapter::CheckFramesReceivedOnIO(
     const OnMutedCallback& set_muted_state_callback,
     uint64 old_frame_counter_snapshot) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (!monitoring_frame_rate_)
     return;
 
   DVLOG_IF(1, old_frame_counter_snapshot == frame_counter_)
       << "No frames have passed, setting source as Muted.";
 
   bool muted_state = old_frame_counter_snapshot == frame_counter_;
   if (muted_state_ != muted_state) {
     set_muted_state_callback.Run(muted_state);
     muted_state_ = muted_state;
   }
 
-  io_message_loop_->PostDelayedTask(FROM_HERE,
-      base::Bind(&VideoTrackAdapter::CheckFramesReceivedOnIO, this,
-          set_muted_state_callback, frame_counter_),
+  io_task_runner_->PostDelayedTask(
+      FROM_HERE, base::Bind(&VideoTrackAdapter::CheckFramesReceivedOnIO, this,
+                            set_muted_state_callback, frame_counter_),
       base::TimeDelta::FromSecondsD(kNormalFrameTimeoutInFrameIntervals /
                                     source_frame_rate_));
 }
 
 }  // namespace content