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

media/video/capture/win/video_capture_device_win.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 "media/video/capture/win/video_capture_device_win.h"
 
 #include <algorithm>
 #include <list>
 
 #include "base/string_util.h"
@@ skipping 161 matching lines @@
 
 namespace media {
 
 // Name of a fake DirectShow filter that exist on computers with
 // GTalk installed.
 static const char kGoogleCameraAdapter[] = "google camera adapter";
 
 // Gets the names of all video capture devices connected to this computer.
 void VideoCaptureDevice::GetDeviceNames(Names* device_names) {
   DCHECK(device_names);
+  DCHECK(CalledOnValidThread());
 
-  base::win::ScopedCOMInitializer coinit;
   ScopedComPtr<ICreateDevEnum> dev_enum;
   HRESULT hr = dev_enum.CreateInstance(CLSID_SystemDeviceEnum, NULL,
                                        CLSCTX_INPROC);
   if (FAILED(hr))
     return;
 
   ScopedComPtr<IEnumMoniker> enum_moniker;
   hr = dev_enum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
                                        enum_moniker.Receive(), 0);
   // CreateClassEnumerator returns S_FALSE on some Windows OS
@@ skipping 54 matching lines @@
     return self;
 
   delete self;
   return NULL;
 }
 
 VideoCaptureDeviceWin::VideoCaptureDeviceWin(const Name& device_name)
     : device_name_(device_name),
       state_(kIdle),
       observer_(NULL) {
+  DetachFromThread();
 }
 
 VideoCaptureDeviceWin::~VideoCaptureDeviceWin() {
+  DCHECK(CalledOnValidThread());
   if (media_control_)
     media_control_->Stop();
 
   if (graph_builder_) {
     if (sink_filter_) {
       graph_builder_->RemoveFilter(sink_filter_);
       sink_filter_ = NULL;
     }
 
     if (capture_filter_)
       graph_builder_->RemoveFilter(capture_filter_);
 
     if (mjpg_filter_)
       graph_builder_->RemoveFilter(mjpg_filter_);
   }
 }
 
 bool VideoCaptureDeviceWin::Init() {
+  DCHECK(CalledOnValidThread());
   HRESULT hr = GetDeviceFilter(device_name_, capture_filter_.Receive());
   if (!capture_filter_) {
     DVLOG(2) << "Failed to create capture filter.";
     return false;
   }
 
   hr = GetPin(capture_filter_, PINDIR_OUTPUT, PIN_CATEGORY_CAPTURE,
               output_capture_pin_.Receive());
   if (!output_capture_pin_) {
     DVLOG(2) << "Failed to get capture output pin";
@@ skipping 35 matching lines @@
   }
 
   return CreateCapabilityMap();
 }
 
 void VideoCaptureDeviceWin::Allocate(
     int width,
     int height,
     int frame_rate,
     VideoCaptureDevice::EventHandler* observer) {
+  DCHECK(CalledOnValidThread());
   if (state_ != kIdle)
     return;
 
   observer_ = observer;
   // Get the camera capability that best match the requested resolution.
   const int capability_index = GetBestMatchedCapability(width, height,
                                                         frame_rate);
   VideoCaptureCapability capability = capabilities_[capability_index];
 
   // Reduce the frame rate if the requested frame rate is lower
@@ skipping 76 matching lines @@
   // Get the capability back from the sink filter after the filter have been
   // connected.
   const VideoCaptureCapability& used_capability
       = sink_filter_->ResultingCapability();
   observer_->OnFrameInfo(used_capability);
 
   state_ = kAllocated;
 }
 
 void VideoCaptureDeviceWin::Start() {
+  DCHECK(CalledOnValidThread());
   if (state_ != kAllocated)
     return;
 
   HRESULT hr = media_control_->Run();
   if (FAILED(hr)) {
     SetErrorState("Failed to start the Capture device.");
     return;
   }
 
   state_ = kCapturing;
 }
 
 void VideoCaptureDeviceWin::Stop() {
+  DCHECK(CalledOnValidThread());
   if (state_ != kCapturing)
     return;
 
   HRESULT hr = media_control_->Stop();
   if (FAILED(hr)) {
     SetErrorState("Failed to stop the capture graph.");
     return;
   }
 
   state_ = kAllocated;
 }
 
 void VideoCaptureDeviceWin::DeAllocate() {
+  DCHECK(CalledOnValidThread());
   if (state_ == kIdle)
     return;
 
   HRESULT hr = media_control_->Stop();
   graph_builder_->Disconnect(output_capture_pin_);
   graph_builder_->Disconnect(input_sink_pin_);
 
   // If the _mjpg filter exist disconnect it even if it has not been used.
   if (mjpg_filter_) {
     graph_builder_->Disconnect(input_mjpg_pin_);
     graph_builder_->Disconnect(output_mjpg_pin_);
   }
 
   if (FAILED(hr)) {
     SetErrorState("Failed to Stop the Capture device");
     return;
   }
 
   state_ = kIdle;
 }
 
 const VideoCaptureDevice::Name& VideoCaptureDeviceWin::device_name() {
+  DCHECK(CalledOnValidThread());
   return device_name_;
 }
 
 // Implements SinkFilterObserver::SinkFilterObserver.
 void VideoCaptureDeviceWin::FrameReceived(const uint8* buffer,
                                           int length) {
   observer_->OnIncomingCapturedFrame(buffer, length, base::Time::Now());
 }
 
 bool VideoCaptureDeviceWin::CreateCapabilityMap() {
+  DCHECK(CalledOnValidThread());
   ScopedComPtr<IAMStreamConfig> stream_config;
   HRESULT hr = output_capture_pin_.QueryInterface(stream_config.Receive());
   if (FAILED(hr)) {
     DVLOG(2) << "Failed to get IAMStreamConfig interface from "
                 "capture device";
     return false;
   }
 
   // Get interface used for getting the frame rate.
   ScopedComPtr<IAMVideoControl> video_control;
@@ skipping 89 matching lines @@
   return capabilities_.size() > 0;
 }
 
 // Loops through the list of capabilities and returns an index of the best
 // matching capability.
 // The algorithm prioritize height, width, frame rate and color format in that
 // order.
 int VideoCaptureDeviceWin::GetBestMatchedCapability(int requested_width,
                                                     int requested_height,
                                                     int requested_frame_rate) {
+  DCHECK(CalledOnValidThread());
   std::list<ResolutionDiff> diff_list;
 
   // Loop through the candidates to create a list of differentials between the
   // requested resolution and the camera capability.
   for (CapabilityMap::iterator iterator = capabilities_.begin();
        iterator != capabilities_.end();
        ++iterator) {
     VideoCaptureCapability capability = iterator->second;
 
     ResolutionDiff diff;
@@ skipping 39 matching lines @@
       break;
     }
   }
 
   // Decide the best color format.
   diff_list.sort(&CompareColor);
   return diff_list.front().capability_index;
 }
 
 void VideoCaptureDeviceWin::SetErrorState(const char* reason) {
+  DCHECK(CalledOnValidThread());
   DVLOG(1) << reason;
   state_ = kError;
   observer_->OnError();
 }
 
 }  // namespace media