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

content/renderer/media/media_stream_video_track.cc

 // Copyright 2013 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/media_stream_video_track.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
@@ skipping 16 matching lines @@
 // VideoCaptureDeliverFrameCB on the main render thread to receive video frames
 // on the IO-thread.
 // Frames are only delivered to the sinks if the track is enabled. If the track
 // is disabled, a black frame is instead forwarded to the sinks at the same
 // frame rate.
 class MediaStreamVideoTrack::FrameDeliverer
     : public base::RefCountedThreadSafe<FrameDeliverer> {
  public:
   typedef MediaStreamVideoSink* VideoSinkId;
 
-  FrameDeliverer(
-      const scoped_refptr<base::MessageLoopProxy>& io_message_loop,
-      bool enabled);
+  FrameDeliverer(scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,

[no sievers, 2015/05/20 23:02:38]

..

[Sami, 2015/05/21 11:39:49]

Ditto.

+                 bool enabled);
 
   void SetEnabled(bool enabled);
 
   // Add |callback| to receive video frames on the IO-thread.
   // Must be called on the main render thread.
   void AddCallback(VideoSinkId id, const VideoCaptureDeliverFrameCB& callback);
 
   // Removes |callback| associated with |id| from receiving video frames if |id|
   // has been added. It is ok to call RemoveCallback even if the |id| has not
   // been added. Note that the added callback will be reset on the main thread.
   // Must be called on the main render thread.
   void RemoveCallback(VideoSinkId id);
 
   // Triggers all registered callbacks with |frame|, |format| and
   // |estimated_capture_time| as parameters. Must be called on the IO-thread.
   void DeliverFrameOnIO(const scoped_refptr<media::VideoFrame>& frame,
                         const base::TimeTicks& estimated_capture_time);
 
  private:
   friend class base::RefCountedThreadSafe<FrameDeliverer>;
   virtual ~FrameDeliverer();
   void AddCallbackOnIO(VideoSinkId id,
                        const VideoCaptureDeliverFrameCB& callback);
   void RemoveCallbackOnIO(
       VideoSinkId id,
-      const scoped_refptr<base::MessageLoopProxy>& message_loop);
+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
 
   void SetEnabledOnIO(bool enabled);
   // Returns a black frame where the size and time stamp is set to the same as
   // as in |reference_frame|.
   scoped_refptr<media::VideoFrame> GetBlackFrame(
       const scoped_refptr<media::VideoFrame>& reference_frame);
 
   // Used to DCHECK that AddCallback and RemoveCallback are called on the main
   // Render Thread.
   base::ThreadChecker main_render_thread_checker_;
-  const scoped_refptr<base::MessageLoopProxy> io_message_loop_;
+  const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   bool enabled_;
   scoped_refptr<media::VideoFrame> black_frame_;
 
   typedef std::pair<VideoSinkId, VideoCaptureDeliverFrameCB>
       VideoIdCallbackPair;
   std::vector<VideoIdCallbackPair> callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(FrameDeliverer);
 };
 
 MediaStreamVideoTrack::FrameDeliverer::FrameDeliverer(
-    const scoped_refptr<base::MessageLoopProxy>& io_message_loop, bool enabled)
-    : io_message_loop_(io_message_loop),
-      enabled_(enabled) {
-  DCHECK(io_message_loop_.get());
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
+    bool enabled)
+    : io_task_runner_(io_task_runner), enabled_(enabled) {
+  DCHECK(io_task_runner_.get());
 }
 
 MediaStreamVideoTrack::FrameDeliverer::~FrameDeliverer() {
   DCHECK(callbacks_.empty());
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::AddCallback(
     VideoSinkId id,
     const VideoCaptureDeliverFrameCB& callback) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
-  io_message_loop_->PostTask(
+  io_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&FrameDeliverer::AddCallbackOnIO,
-                 this, id, callback));
+      base::Bind(&FrameDeliverer::AddCallbackOnIO, this, id, callback));
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::AddCallbackOnIO(
     VideoSinkId id,
     const VideoCaptureDeliverFrameCB& callback) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   callbacks_.push_back(std::make_pair(id, callback));
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::RemoveCallback(VideoSinkId id) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
-  io_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&FrameDeliverer::RemoveCallbackOnIO,
-                 this, id, base::MessageLoopProxy::current()));
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&FrameDeliverer::RemoveCallbackOnIO, this, id,
+                            base::MessageLoopProxy::current()));
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::RemoveCallbackOnIO(
     VideoSinkId id,
-    const scoped_refptr<base::MessageLoopProxy>& message_loop) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   std::vector<VideoIdCallbackPair>::iterator it = callbacks_.begin();
   for (; it != callbacks_.end(); ++it) {
     if (it->first == id) {
       // Callback is copied to heap and then deleted on the target thread.
       scoped_ptr<VideoCaptureDeliverFrameCB> callback;
       callback.reset(new VideoCaptureDeliverFrameCB(it->second));
       callbacks_.erase(it);
-      message_loop->PostTask(
+      task_runner->PostTask(
           FROM_HERE, base::Bind(&ResetCallback, base::Passed(&callback)));
       return;
     }
   }
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::SetEnabled(bool enabled) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
-  io_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&FrameDeliverer::SetEnabledOnIO,
-                 this, enabled));
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&FrameDeliverer::SetEnabledOnIO, this, enabled));
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::SetEnabledOnIO(bool enabled) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   enabled_ = enabled;
   if (enabled_)
     black_frame_ = NULL;
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::DeliverFrameOnIO(
     const scoped_refptr<media::VideoFrame>& frame,
     const base::TimeTicks& estimated_capture_time) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   const scoped_refptr<media::VideoFrame>& video_frame =
       enabled_ ? frame : GetBlackFrame(frame);
   for (const auto& entry : callbacks_)
     entry.second.Run(video_frame, estimated_capture_time);
 }
 
 scoped_refptr<media::VideoFrame>
 MediaStreamVideoTrack::FrameDeliverer::GetBlackFrame(
     const scoped_refptr<media::VideoFrame>& reference_frame) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   if (!black_frame_.get() ||
       black_frame_->natural_size() != reference_frame->natural_size())
     black_frame_ =
         media::VideoFrame::CreateBlackFrame(reference_frame->natural_size());
 
   // Wrap |black_frame_| so we get a fresh timestamp we can modify. Frames
   // returned from this function may still be in use.
   scoped_refptr<media::VideoFrame> wrapped_black_frame =
       media::VideoFrame::WrapVideoFrame(
           black_frame_, black_frame_->visible_rect(),
@@ skipping 25 matching lines @@
   return static_cast<MediaStreamVideoTrack*>(track.extraData());
 }
 
 MediaStreamVideoTrack::MediaStreamVideoTrack(
     MediaStreamVideoSource* source,
     const blink::WebMediaConstraints& constraints,
     const MediaStreamVideoSource::ConstraintsCallback& callback,
     bool enabled)
     : MediaStreamTrack(true),
       frame_deliverer_(
-          new MediaStreamVideoTrack::FrameDeliverer(source->io_message_loop(),
+          new MediaStreamVideoTrack::FrameDeliverer(source->io_task_runner(),
                                                     enabled)),
       constraints_(constraints),
       source_(source) {
   DCHECK(!constraints.isNull());
   source->AddTrack(this,
                    base::Bind(
                        &MediaStreamVideoTrack::FrameDeliverer::DeliverFrameOnIO,
                        frame_deliverer_),
                    constraints, callback);
 }
@@ skipping 39 matching lines @@
 }
 
 void MediaStreamVideoTrack::OnReadyStateChanged(
     blink::WebMediaStreamSource::ReadyState state) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   for (auto* sink : sinks_)
     sink->OnReadyStateChanged(state);
 }
 
 }  // namespace content