Win Video Capture: add DirectShow WDM devices capabilities enumeration.

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 <ks.h>
 #include <ksmedia.h>
 
 #include <algorithm>
 #include <list>
 
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_variant.h"
 #include "media/video/capture/win/video_capture_device_mf_win.h"
 
 using base::win::ScopedCoMem;
 using base::win::ScopedComPtr;
 using base::win::ScopedVariant;
 
 namespace media {
 
 // Finds and creates a DirectShow Video Capture filter matching the device_name.
 // static
-HRESULT VideoCaptureDeviceWin::GetDeviceFilter(
-    const VideoCaptureDevice::Name& device_name,
-    IBaseFilter** filter) {
+HRESULT VideoCaptureDeviceWin::GetDeviceFilter(const std::string& device_id,
+                                               IBaseFilter** filter) {
   DCHECK(filter);
 
   ScopedComPtr<ICreateDevEnum> dev_enum;
   HRESULT hr = dev_enum.CreateInstance(CLSID_SystemDeviceEnum, NULL,
                                        CLSCTX_INPROC);
   if (FAILED(hr))
     return hr;
 
   ScopedComPtr<IEnumMoniker> enum_moniker;
   hr = dev_enum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
@@ skipping 19 matching lines @@
     static const wchar_t* kPropertyNames[] = {
       L"DevicePath", L"Description", L"FriendlyName"
     };
     ScopedVariant name;
     for (size_t i = 0;
          i < arraysize(kPropertyNames) && name.type() != VT_BSTR; ++i) {
       prop_bag->Read(kPropertyNames[i], name.Receive(), 0);
     }
     if (name.type() == VT_BSTR) {
       std::string device_path(base::SysWideToUTF8(V_BSTR(&name)));
-      if (device_path.compare(device_name.id()) == 0) {
+      if (device_path.compare(device_id) == 0) {
         // We have found the requested device
         hr = moniker->BindToObject(0, 0, IID_IBaseFilter,
                                    capture_filter.ReceiveVoid());
         DVPLOG_IF(2, FAILED(hr)) << "Failed to bind camera filter.";
         break;
       }
     }
     moniker.Release();
   }
 
@@ skipping 137 matching lines @@
     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());
+  HRESULT hr = GetDeviceFilter(device_name_.id(), capture_filter_.Receive());
   if (!capture_filter_) {
     DVLOG(2) << "Failed to create capture filter.";
     return false;
   }
 
   output_capture_pin_ =
       GetPin(capture_filter_, PINDIR_OUTPUT, PIN_CATEGORY_CAPTURE);
   if (!output_capture_pin_) {
     DVLOG(2) << "Failed to get capture output pin";
     return false;
@@ skipping 315 matching lines @@
   }
 }
 
 void VideoCaptureDeviceWin::SetErrorState(const std::string& reason) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << reason;
   state_ = kError;
   client_->OnError(reason);
 }
 }  // namespace media