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

content/renderer/pepper/pepper_media_stream_video_track_host.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/pepper/pepper_media_stream_video_track_host.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 164 matching lines @@
 
 }  // namespace
 
 namespace content {
 
 // Internal class used for delivering video frames on the IO-thread to
 // the MediaStreamVideoSource implementation.
 class PepperMediaStreamVideoTrackHost::FrameDeliverer
     : public base::RefCountedThreadSafe<FrameDeliverer> {
  public:
-  FrameDeliverer(
-      const scoped_refptr<base::MessageLoopProxy>& io_message_loop_proxy,
-      const VideoCaptureDeliverFrameCB& new_frame_callback);
+  FrameDeliverer(scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
+                 const VideoCaptureDeliverFrameCB& new_frame_callback);
 
   void DeliverVideoFrame(const scoped_refptr<media::VideoFrame>& frame);
 
  private:
   friend class base::RefCountedThreadSafe<FrameDeliverer>;
   virtual ~FrameDeliverer();
 
   void DeliverFrameOnIO(const scoped_refptr<media::VideoFrame>& frame);
 
-  scoped_refptr<base::MessageLoopProxy> io_message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   VideoCaptureDeliverFrameCB new_frame_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(FrameDeliverer);
 };
 
 PepperMediaStreamVideoTrackHost::FrameDeliverer::FrameDeliverer(
-    const scoped_refptr<base::MessageLoopProxy>& io_message_loop_proxy,
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     const VideoCaptureDeliverFrameCB& new_frame_callback)
-    : io_message_loop_(io_message_loop_proxy),
-      new_frame_callback_(new_frame_callback) {
+    : io_task_runner_(io_task_runner), new_frame_callback_(new_frame_callback) {
 }
 
 PepperMediaStreamVideoTrackHost::FrameDeliverer::~FrameDeliverer() {
 }
 
 void PepperMediaStreamVideoTrackHost::FrameDeliverer::DeliverVideoFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
-  io_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&FrameDeliverer::DeliverFrameOnIO, this, frame));
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&FrameDeliverer::DeliverFrameOnIO, this, frame));
 }
 
 void PepperMediaStreamVideoTrackHost::FrameDeliverer::DeliverFrameOnIO(
      const scoped_refptr<media::VideoFrame>& frame) {
-  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
   // The time when this frame is generated is unknown so give a null value to
   // |estimated_capture_time|.
   new_frame_callback_.Run(frame, base::TimeTicks());
 }
 
 PepperMediaStreamVideoTrackHost::PepperMediaStreamVideoTrackHost(
     RendererPpapiHost* host,
     PP_Instance instance,
     PP_Resource resource,
     const blink::WebMediaStreamTrack& track)
@@ skipping 196 matching lines @@
                                 kDefaultOutputFrameRate,
                                 ToPixelFormat(plugin_frame_format_)));
   callback.Run(formats);
 }
 
 void PepperMediaStreamVideoTrackHost::StartSourceImpl(
     const media::VideoCaptureFormat& format,
     const blink::WebMediaConstraints& constraints,
     const VideoCaptureDeliverFrameCB& frame_callback) {
   output_started_ = true;
-  frame_deliverer_ = new FrameDeliverer(io_message_loop(), frame_callback);
+  frame_deliverer_ = new FrameDeliverer(io_task_runner(), frame_callback);

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

Ah I see now why you changed some of these from const-ref to stack-instance.
Because you changed the getter(s) the opposite way :) Fair enough...

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

Yeah, this also fits better but the main motivation was to take advantage of
move semantics.

 }
 
 void PepperMediaStreamVideoTrackHost::StopSourceImpl() {
   output_started_ = false;
   frame_deliverer_ = NULL;
 }
 
 void PepperMediaStreamVideoTrackHost::DidConnectPendingHostToResource() {
   if (!connected_) {
     MediaStreamVideoSink::AddToVideoTrack(
@@ skipping 80 matching lines @@
 }
 
 void PepperMediaStreamVideoTrackHost::OnTrackStarted(
     MediaStreamSource* source,
     MediaStreamRequestResult result,
     const blink::WebString& result_name) {
   DVLOG(3) << "OnTrackStarted result: " << result;
 }
 
 }  // namespace content