Move the device enumerate/open/close work to device thread from IO thread

content/browser/renderer_host/media/video_capture_manager.cc

 // 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 "content/browser/renderer_host/media/video_capture_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/stl_util.h"
@@ skipping 20 matching lines @@
         ready_to_delete(false) {
     handlers.push_front(handler);
   }
   ~Controller() {}
 
   scoped_refptr<VideoCaptureController> controller;
   bool ready_to_delete;
   Handlers handlers;
 };
 
-VideoCaptureManager::VideoCaptureManager()
-  : vc_device_thread_("VideoCaptureManagerThread"),
+VideoCaptureManager::VideoCaptureManager(
+    scoped_refptr<base::MessageLoopProxy> message_loop)
+    : message_loop_(message_loop),
     listener_(NULL),
     new_capture_session_id_(kFirstSessionId),
     use_fake_device_(false) {
-  vc_device_thread_.Start();
 }
 
 VideoCaptureManager::~VideoCaptureManager() {
-  vc_device_thread_.Stop();
   DCHECK(devices_.empty());
   DCHECK(controllers_.empty());
 }
 
 void VideoCaptureManager::Register(MediaStreamProviderListener* listener) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!listener_);
   listener_ = listener;
 }
 
 void VideoCaptureManager::Unregister() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(listener_);
   listener_ = NULL;
 }
 
 void VideoCaptureManager::EnumerateDevices() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(listener_);
 
-  vc_device_thread_.message_loop()->PostTask(
+  message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&VideoCaptureManager::OnEnumerateDevices, this));
 }
 
 int VideoCaptureManager::Open(const StreamDeviceInfo& device) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(listener_);
 
   // Generate a new id for this device.
   int video_capture_session_id = new_capture_session_id_++;
 
-  vc_device_thread_.message_loop()->PostTask(
+  message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&VideoCaptureManager::OnOpen, this, video_capture_session_id,
                  device));
 
   return video_capture_session_id;
 }
 
 void VideoCaptureManager::Close(int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(listener_);
 
-  vc_device_thread_.message_loop()->PostTask(
+  message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&VideoCaptureManager::OnClose, this, capture_session_id));
 }
 
 void VideoCaptureManager::Start(
     const media::VideoCaptureParams& capture_params,
     media::VideoCaptureDevice::EventHandler* video_capture_receiver) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  vc_device_thread_.message_loop()->PostTask(
+  message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&VideoCaptureManager::OnStart, this, capture_params,
                  video_capture_receiver));
 }
 
 void VideoCaptureManager::Stop(
     const media::VideoCaptureSessionId& capture_session_id,
     base::Closure stopped_cb) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  vc_device_thread_.message_loop()->PostTask(
+  message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&VideoCaptureManager::OnStop, this, capture_session_id,
                  stopped_cb));
 }
 
 void VideoCaptureManager::Error(
     const media::VideoCaptureSessionId& capture_session_id) {
   PostOnError(capture_session_id, kDeviceNotAvailable);
 }
 
 void VideoCaptureManager::UseFakeDevice() {
   use_fake_device_ = true;
 }
 
-MessageLoop* VideoCaptureManager::GetMessageLoop() {
-  return vc_device_thread_.message_loop();
-}
-
 void VideoCaptureManager::OnEnumerateDevices() {
   DCHECK(IsOnCaptureDeviceThread());
 
   media::VideoCaptureDevice::Names device_names;
   GetAvailableDevices(&device_names);
 
   StreamDeviceInfoArray devices;
   for (media::VideoCaptureDevice::Names::iterator it =
            device_names.begin(); it != device_names.end(); ++it) {
     bool opened = DeviceOpened(*it);
@@ skipping 208 matching lines @@
                                       MediaStreamProviderError error) {
   // Don't check thread here, can be called from both IO thread and device
   // thread.
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&VideoCaptureManager::OnError, this,
                                      capture_session_id, error));
 }
 
 bool VideoCaptureManager::IsOnCaptureDeviceThread() const {
-  return MessageLoop::current() == vc_device_thread_.message_loop();
+  return message_loop_->BelongsToCurrentThread();
 }
 
 void VideoCaptureManager::GetAvailableDevices(
     media::VideoCaptureDevice::Names* device_names) {
   DCHECK(IsOnCaptureDeviceThread());
 
   if (!use_fake_device_) {
     media::VideoCaptureDevice::GetDeviceNames(device_names);
   } else {
     media::FakeVideoCaptureDevice::GetDeviceNames(device_names);
@@ skipping 39 matching lines @@
     }
   }
   return false;
 }
 
 void VideoCaptureManager::AddController(
     const media::VideoCaptureParams& capture_params,
     VideoCaptureControllerEventHandler* handler,
     base::Callback<void(VideoCaptureController*)> added_cb) {
   DCHECK(handler);
-  vc_device_thread_.message_loop()->PostTask(
+  message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&VideoCaptureManager::DoAddControllerOnDeviceThread,
                  this, capture_params, handler, added_cb));
 }
 
 void VideoCaptureManager::DoAddControllerOnDeviceThread(
     const media::VideoCaptureParams capture_params,
     VideoCaptureControllerEventHandler* handler,
     base::Callback<void(VideoCaptureController*)> added_cb) {
   DCHECK(IsOnCaptureDeviceThread());
@@ skipping 11 matching lines @@
       controller = controllers_[video_capture_device]->controller;
     }
   }
   added_cb.Run(controller);
 }
 
 void VideoCaptureManager::RemoveController(
     VideoCaptureController* controller,
     VideoCaptureControllerEventHandler* handler) {
   DCHECK(handler);
-  vc_device_thread_.message_loop()->PostTask(
+  message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&VideoCaptureManager::DoRemoveControllerOnDeviceThread, this,
                  make_scoped_refptr(controller), handler));
 }
 
 void VideoCaptureManager::DoRemoveControllerOnDeviceThread(
     VideoCaptureController* controller,
     VideoCaptureControllerEventHandler* handler) {
   DCHECK(IsOnCaptureDeviceThread());
 
@@ skipping 43 matching lines @@
 
     VideoCaptureDevices::iterator dit = devices_.find(capture_session_id);
     if (dit != devices_.end()) {
       return dit->second;
     }
   }
   return NULL;
 }
 
 }  // namespace media_stream