Replace MessageLoopProxy with SingleThreadTaskRunner for the rest of media/.

media/video/capture/mac/video_capture_device_mac.mm

 // Copyright (c) 2012 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 "media/video/capture/mac/video_capture_device_mac.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/time/time.h"
@@ skipping 94 matching lines @@
     delete capture_device;
     capture_device = NULL;
   }
   return capture_device;
 }
 
 VideoCaptureDeviceMac::VideoCaptureDeviceMac(const Name& device_name)
     : device_name_(device_name),
       sent_frame_info_(false),
       tried_to_square_pixels_(false),
-      loop_proxy_(base::MessageLoopProxy::current()),
+      task_runner_(base::MessageLoopProxy::current()),
       state_(kNotInitialized),
       weak_factory_(this),
       weak_this_(weak_factory_.GetWeakPtr()),
       capture_device_(nil) {
 }
 
 VideoCaptureDeviceMac::~VideoCaptureDeviceMac() {
-  DCHECK_EQ(loop_proxy_, base::MessageLoopProxy::current());
+  DCHECK_EQ(task_runner_->BelongsToCurrentThread());
   [capture_device_ release];
 }
 
 void VideoCaptureDeviceMac::AllocateAndStart(
     const VideoCaptureCapability& capture_format,
     scoped_ptr<VideoCaptureDevice::Client> client) {
-  DCHECK_EQ(loop_proxy_, base::MessageLoopProxy::current());
+  DCHECK_EQ(task_runner_->BelongsToCurrentThread());
   if (state_ != kIdle) {
     return;
   }
   int width = capture_format.width;
   int height = capture_format.height;
   int frame_rate = capture_format.frame_rate;
 
   // The OS API can scale captured frame to any size requested, which would lead
   // to undesired aspect ratio change. Try to open the camera with a natively
   // supported format and let the client crop/pad the captured frames.
@@ skipping 36 matching lines @@
 
   if (![capture_device_ startCapture]) {
     SetErrorState("Could not start capture device.");
     return;
   }
 
   state_ = kCapturing;
 }
 
 void VideoCaptureDeviceMac::StopAndDeAllocate() {
-  DCHECK_EQ(loop_proxy_, base::MessageLoopProxy::current());
+  DCHECK_EQ(task_runner_->BelongsToCurrentThread());
   DCHECK(state_ == kCapturing || state_ == kError) << state_;
   [capture_device_ stopCapture];
 
   [capture_device_ setCaptureDevice:nil];
   [capture_device_ setFrameReceiver:nil];
   client_.reset();
   state_ = kIdle;
   tried_to_square_pixels_ = false;
 }
 
 bool VideoCaptureDeviceMac::Init() {
-  DCHECK_EQ(loop_proxy_, base::MessageLoopProxy::current());
+  DCHECK_EQ(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kNotInitialized);
 
   Names device_names;
   GetDeviceNames(&device_names);
   Name* found = device_names.FindById(device_name_.id());
   if (!found)
     return false;
 
   capture_device_ =
       [[VideoCaptureDeviceQTKit alloc] initWithFrameReceiver:this];
@@ skipping 77 matching lines @@
   }
 
   DCHECK(current_settings_.width == frame_info.width &&
          current_settings_.height == frame_info.height);
 
   client_->OnIncomingCapturedFrame(
       video_frame, video_frame_length, base::Time::Now(), 0, false, false);
 }
 
 void VideoCaptureDeviceMac::ReceiveError(const std::string& reason) {
-  loop_proxy_->PostTask(FROM_HERE,
+  task_runner_->PostTask(FROM_HERE,
       base::Bind(&VideoCaptureDeviceMac::SetErrorState, weak_this_,
           reason));
 }
 
 void VideoCaptureDeviceMac::SetErrorState(const std::string& reason) {
-  DCHECK_EQ(loop_proxy_, base::MessageLoopProxy::current());
+  DCHECK_EQ(task_runner_->BelongsToCurrentThread());
   DLOG(ERROR) << reason;
   state_ = kError;
   client_->OnError();
 }
 
 bool VideoCaptureDeviceMac::UpdateCaptureResolution() {
  if (![capture_device_ setCaptureHeight:current_settings_.height
                                   width:current_settings_.width
                               frameRate:current_settings_.frame_rate]) {
    ReceiveError("Could not configure capture device.");
    return false;
  }
  return true;
 }
 
 } // namespace media