Reland "[PTZ] Add mocking points to VideoCaptureDeviceFactoryWin"

This is a reland of 6536130a
with restored DirectShow device filter creation logic in
VideoCaptureDeviceFactoryWin. The logic was unintentionally changed by
https://chromium-review.googlesource.com/c/chromium/src/+/2247797.

Original change's description:
> [PTZ] Add mocking points to VideoCaptureDeviceFactoryWin
>
> This CL refactors video capture device creation on Windows, removes some
> code duplications related to DirectShow device enumeration and adds
> mocking points for unit testing. This CL has no functional changes.
>
> Bug: 934063
> Change-Id: I2df08b3a361ffd702761bd9d6b400f4418390c99
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2247797
> Commit-Queue: Eero Häkkinen <eero.hakkinen@intel.com>
> Auto-Submit: Eero Häkkinen <eero.hakkinen@intel.com>
> Reviewed-by: Guido Urdaneta <guidou@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#781357}

Bug: 934063, 1098633
Change-Id: I0456912298eb538fbf51ec2fd92b561e71f843e8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2263812Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Commit-Queue: Eero Häkkinen <eero.hakkinen@intel.com>
Cr-Commit-Position: refs/heads/master@{#782880}

media/capture/video/win/video_capture_device_factory_win.h

@@ -7,6 +7,9 @@
 #ifndef MEDIA_CAPTURE_VIDEO_WIN_VIDEO_CAPTURE_DEVICE_FACTORY_WIN_H_
 #define MEDIA_CAPTURE_VIDEO_WIN_VIDEO_CAPTURE_DEVICE_FACTORY_WIN_H_
 
+// Avoid including strsafe.h via dshow as it will cause build warnings.
+#define NO_DSHOW_STRSAFE
+#include <dshow.h>
 #include <mfidl.h>
 #include <windows.devices.enumeration.h>
 
@@ -30,13 +33,6 @@ class CAPTURE_EXPORT VideoCaptureDeviceFactoryWin
   VideoCaptureDeviceFactoryWin();
   ~VideoCaptureDeviceFactoryWin() override;
 
-  using MFEnumDeviceSourcesFunc = decltype(&MFEnumDeviceSources);
-  using DirectShowEnumDevicesFunc =
-      base::RepeatingCallback<HRESULT(IEnumMoniker**)>;
-  using GetSupportedFormatsFunc =
-      base::RepeatingCallback<void(const VideoCaptureDeviceDescriptor&,
-                                   VideoCaptureFormats*)>;
-
   std::unique_ptr<VideoCaptureDevice> CreateDevice(
       const VideoCaptureDeviceDescriptor& device_descriptor) override;
   void GetDeviceDescriptors(
@@ -51,22 +47,31 @@ class CAPTURE_EXPORT VideoCaptureDeviceFactoryWin
   void set_use_media_foundation_for_testing(bool use) {
     use_media_foundation_ = use;
   }
-  void set_mf_enum_device_sources_func_for_testing(
-      MFEnumDeviceSourcesFunc func) {
-    mf_enum_device_sources_func_ = func;
-  }
-  void set_direct_show_enum_devices_func_for_testing(
-      DirectShowEnumDevicesFunc func) {
-    direct_show_enum_devices_func_ = func;
-  }
-  void set_mf_get_supported_formats_func_for_testing(
-      GetSupportedFormatsFunc func) {
-    mf_get_supported_formats_func_ = func;
-  }
-  void set_direct_show_get_supported_formats_func_for_testing(
-      GetSupportedFormatsFunc func) {
-    direct_show_get_supported_formats_func_ = func;
-  }
+
+ protected:
+  // Protected and virtual for testing.
+  virtual bool CreateDeviceEnumMonikerDirectShow(IEnumMoniker** enum_moniker);
+  virtual bool CreateDeviceFilterDirectShow(const std::string& device_id,
+                                            IBaseFilter** capture_filter);
+  virtual bool CreateDeviceFilterDirectShow(
+      Microsoft::WRL::ComPtr<IMoniker> moniker,
+      IBaseFilter** capture_filter);
+  virtual bool CreateDeviceSourceMediaFoundation(const std::string& device_id,
+                                                 VideoCaptureApi capture_api,
+                                                 IMFMediaSource** source);
+  virtual bool CreateDeviceSourceMediaFoundation(
+      Microsoft::WRL::ComPtr<IMFAttributes> attributes,
+      IMFMediaSource** source);
+  virtual bool EnumerateDeviceSourcesMediaFoundation(
+      Microsoft::WRL::ComPtr<IMFAttributes> attributes,
+      IMFActivate*** devices,
+      UINT32* count);
+  virtual void GetSupportedFormatsDirectShow(
+      const VideoCaptureDeviceDescriptor& device_descriptor,
+      VideoCaptureFormats* supported_formats);
+  virtual void GetSupportedFormatsMediaFoundation(
+      const VideoCaptureDeviceDescriptor& device_descriptor,
+      VideoCaptureFormats* supported_formats);
 
  private:
   void EnumerateDevicesUWP(
@@ -83,10 +88,6 @@ class CAPTURE_EXPORT VideoCaptureDeviceFactoryWin
       VideoCaptureDeviceDescriptors* device_descriptors);
   void AugmentDescriptorListWithDirectShowOnlyDevices(
       VideoCaptureDeviceDescriptors* device_descriptors);
-  bool EnumerateVideoDevicesMediaFoundation(
-      const std::vector<std::pair<GUID, GUID>>& attributes_data,
-      IMFActivate*** devices,
-      UINT32* count);
   void GetDeviceDescriptorsDirectShow(
       VideoCaptureDeviceDescriptors* device_descriptors);
   int GetNumberOfSupportedFormats(const VideoCaptureDeviceDescriptor& device);
@@ -96,14 +97,6 @@ class CAPTURE_EXPORT VideoCaptureDeviceFactoryWin
 
   bool use_media_foundation_;
   MFSessionLifetime session_;
-  // In production code, when Media Foundation libraries are available,
-  // |mf_enum_device_sources_func_| points to MFEnumDeviceSources. It enables
-  // mock of Media Foundation API in unit tests.
-  MFEnumDeviceSourcesFunc mf_enum_device_sources_func_ = nullptr;
-  DirectShowEnumDevicesFunc direct_show_enum_devices_func_;
-
-  GetSupportedFormatsFunc mf_get_supported_formats_func_;
-  GetSupportedFormatsFunc direct_show_get_supported_formats_func_;
 
   // For calling WinRT methods on a COM initiated thread.
   base::Thread com_thread_;

media/capture/video/win/video_capture_device_mf_win.cc

@@ -417,7 +417,7 @@ const CapabilityWin& GetBestMatchedPhotoCapability(
 
 HRESULT CreateCaptureEngine(IMFCaptureEngine** engine) {
   ComPtr<IMFCaptureEngineClassFactory> capture_engine_class_factory;
-  HRESULT hr = CoCreateInstance(CLSID_MFCaptureEngineClassFactory, NULL,
+  HRESULT hr = CoCreateInstance(CLSID_MFCaptureEngineClassFactory, nullptr,
                                 CLSCTX_INPROC_SERVER,
                                 IID_PPV_ARGS(&capture_engine_class_factory));
   if (FAILED(hr))
@@ -863,7 +863,7 @@ void VideoCaptureDeviceMFWin::AllocateAndStart(
 
   DWORD dw_sink_stream_index = 0;
   hr = preview_sink->AddStream(best_match_video_capability.stream_index,
-                               sink_video_media_type.Get(), NULL,
+                               sink_video_media_type.Get(), nullptr,
                                &dw_sink_stream_index);
   if (FAILED(hr)) {
     OnError(VideoCaptureError::kWinMediaFoundationSinkAddStreamFailed,
@@ -991,9 +991,9 @@ void VideoCaptureDeviceMFWin::TakePhoto(TakePhotoCallback callback) {
   }
 
   DWORD dw_sink_stream_index = 0;
-  hr =
-      photo_sink->AddStream(selected_photo_capability_->stream_index,
-                            sink_media_type.Get(), NULL, &dw_sink_stream_index);
+  hr = photo_sink->AddStream(selected_photo_capability_->stream_index,
+                             sink_media_type.Get(), nullptr,
+                             &dw_sink_stream_index);
   if (FAILED(hr)) {
     LogError(FROM_HERE, hr);
     return;

media/capture/video/win/video_capture_device_win.cc

@@ -51,7 +51,7 @@ bool PinMatchesCategory(IPin* pin, REFGUID category) {
   if (SUCCEEDED(hr)) {
     GUID pin_category;
     DWORD return_value;
-    hr = ks_property->Get(AMPROPSETID_Pin, AMPROPERTY_PIN_CATEGORY, NULL, 0,
+    hr = ks_property->Get(AMPROPSETID_Pin, AMPROPERTY_PIN_CATEGORY, nullptr, 0,
                           &pin_category, sizeof(pin_category), &return_value);
     if (SUCCEEDED(hr) && (return_value == sizeof(pin_category))) {
       found = (pin_category == category);
@@ -70,18 +70,9 @@ bool PinMatchesMajorType(IPin* pin, REFGUID major_type) {
 
 // static
 void VideoCaptureDeviceWin::GetDeviceCapabilityList(
-    const std::string& device_id,
+    ComPtr<IBaseFilter> capture_filter,
     bool query_detailed_frame_rates,
     CapabilityList* out_capability_list) {
-  ComPtr<IBaseFilter> capture_filter;
-  HRESULT hr =
-      VideoCaptureDeviceWin::GetDeviceFilter(device_id, &capture_filter);
-  if (!capture_filter.Get()) {
-    DLOG(ERROR) << "Failed to create capture filter: "
-                << logging::SystemErrorCodeToString(hr);
-    return;
-  }
-
   ComPtr<IPin> output_capture_pin(VideoCaptureDeviceWin::GetPin(
       capture_filter.Get(), PINDIR_OUTPUT, PIN_CATEGORY_CAPTURE, GUID_NULL));
   if (!output_capture_pin.Get()) {
@@ -184,81 +175,22 @@ void VideoCaptureDeviceWin::GetPinCapabilityList(
   }
 }
 
-// Finds and creates a DirectShow Video Capture filter matching the |device_id|.
-// static
-HRESULT VideoCaptureDeviceWin::GetDeviceFilter(const std::string& device_id,
-                                               IBaseFilter** filter) {
-  DCHECK(filter);
-
-  ComPtr<ICreateDevEnum> dev_enum;
-  HRESULT hr = ::CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
-                                  IID_PPV_ARGS(&dev_enum));
-  if (FAILED(hr))
-    return hr;
-
-  ComPtr<IEnumMoniker> enum_moniker;
-  hr = dev_enum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
-                                       &enum_moniker, 0);
-  // CreateClassEnumerator returns S_FALSE on some Windows OS
-  // when no camera exist. Therefore the FAILED macro can't be used.
-  if (hr != S_OK)
-    return hr;
-
-  ComPtr<IBaseFilter> capture_filter;
-  for (ComPtr<IMoniker> moniker; enum_moniker->Next(1, &moniker, NULL) == S_OK;
-       moniker.Reset()) {
-    ComPtr<IPropertyBag> prop_bag;
-    hr = moniker->BindToStorage(0, 0, IID_PPV_ARGS(&prop_bag));
-    if (FAILED(hr))
-      continue;
-
-    // Find |device_id| via DevicePath, Description or FriendlyName, whichever
-    // is available first and is a VT_BSTR (i.e. String) type.
-    static const wchar_t* kPropertyNames[] = {L"DevicePath", L"Description",
-                                              L"FriendlyName"};
-
-    ScopedVariant name;
-    for (const auto* property_name : kPropertyNames) {
-      prop_bag->Read(property_name, name.Receive(), 0);
-      if (name.type() == VT_BSTR)
-        break;
-    }
-
-    if (name.type() == VT_BSTR) {
-      const std::string device_path(base::SysWideToUTF8(V_BSTR(name.ptr())));
-      if (device_path.compare(device_id) == 0) {
-        // We have found the requested device
-        hr = moniker->BindToObject(0, 0, IID_PPV_ARGS(&capture_filter));
-        DLOG_IF(ERROR, FAILED(hr)) << "Failed to bind camera filter: "
-                                   << logging::SystemErrorCodeToString(hr);
-        break;
-      }
-    }
-  }
-
-  *filter = capture_filter.Detach();
-  if (!*filter && SUCCEEDED(hr))
-    hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
-
-  return hr;
-}
-
 // Finds an IPin on an IBaseFilter given the direction, Category and/or Major
 // Type. If either |category| or |major_type| are GUID_NULL, they are ignored.
 // static
-ComPtr<IPin> VideoCaptureDeviceWin::GetPin(IBaseFilter* filter,
+ComPtr<IPin> VideoCaptureDeviceWin::GetPin(ComPtr<IBaseFilter> capture_filter,
                                            PIN_DIRECTION pin_dir,
                                            REFGUID category,
                                            REFGUID major_type) {
   ComPtr<IPin> pin;
   ComPtr<IEnumPins> pin_enum;
-  HRESULT hr = filter->EnumPins(&pin_enum);
-  if (pin_enum.Get() == NULL)
+  HRESULT hr = capture_filter->EnumPins(&pin_enum);
+  if (pin_enum.Get() == nullptr)
     return pin;
 
   // Get first unconnected pin.
   hr = pin_enum->Reset();  // set to first pin
-  while ((hr = pin_enum->Next(1, &pin, NULL)) == S_OK) {
+  while ((hr = pin_enum->Next(1, &pin, nullptr)) == S_OK) {
     PIN_DIRECTION this_pin_dir = static_cast<PIN_DIRECTION>(-1);
     hr = pin->QueryDirection(&this_pin_dir);
     if (pin_dir == this_pin_dir) {
@@ -309,7 +241,7 @@ void VideoCaptureDeviceWin::ScopedMediaType::Free() {
     return;
 
   DeleteMediaType(media_type_);
-  media_type_ = NULL;
+  media_type_ = nullptr;
 }
 
 AM_MEDIA_TYPE** VideoCaptureDeviceWin::ScopedMediaType::Receive() {
@@ -323,13 +255,13 @@ void VideoCaptureDeviceWin::ScopedMediaType::FreeMediaType(AM_MEDIA_TYPE* mt) {
   if (mt->cbFormat != 0) {
     CoTaskMemFree(mt->pbFormat);
     mt->cbFormat = 0;
-    mt->pbFormat = NULL;
+    mt->pbFormat = nullptr;
   }
-  if (mt->pUnk != NULL) {
+  if (mt->pUnk != nullptr) {
     NOTREACHED();
     // pUnk should not be used.
     mt->pUnk->Release();
-    mt->pUnk = NULL;
+    mt->pUnk = nullptr;
   }
 }
 
@@ -337,16 +269,18 @@ void VideoCaptureDeviceWin::ScopedMediaType::FreeMediaType(AM_MEDIA_TYPE* mt) {
 // http://msdn.microsoft.com/en-us/library/dd375432(VS.85).aspx
 void VideoCaptureDeviceWin::ScopedMediaType::DeleteMediaType(
     AM_MEDIA_TYPE* mt) {
-  if (mt != NULL) {
+  if (mt != nullptr) {
     FreeMediaType(mt);
     CoTaskMemFree(mt);
   }
 }
 
 VideoCaptureDeviceWin::VideoCaptureDeviceWin(
-    const VideoCaptureDeviceDescriptor& device_descriptor)
+    const VideoCaptureDeviceDescriptor& device_descriptor,
+    ComPtr<IBaseFilter> capture_filter)
     : device_descriptor_(device_descriptor),
       state_(kIdle),
+      capture_filter_(std::move(capture_filter)),
       white_balance_mode_manual_(false),
       exposure_mode_manual_(false),
       focus_mode_manual_(false),
@@ -386,11 +320,6 @@ VideoCaptureDeviceWin::~VideoCaptureDeviceWin() {
 
 bool VideoCaptureDeviceWin::Init() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  HRESULT hr = GetDeviceFilter(device_descriptor_.device_id, &capture_filter_);
-  DLOG_IF_FAILED_WITH_HRESULT("Failed to create capture filter", hr);
-  if (!capture_filter_.Get())
-    return false;
-
   output_capture_pin_ = GetPin(capture_filter_.Get(), PINDIR_OUTPUT,
                                PIN_CATEGORY_CAPTURE, GUID_NULL);
   if (!output_capture_pin_.Get()) {
@@ -400,20 +329,21 @@ bool VideoCaptureDeviceWin::Init() {
 
   // Create the sink filter used for receiving Captured frames.
   sink_filter_ = new SinkFilter(this);
-  if (sink_filter_.get() == NULL) {
+  if (sink_filter_.get() == nullptr) {
     DLOG(ERROR) << "Failed to create sink filter";
     return false;
   }
 
   input_sink_pin_ = sink_filter_->GetPin(0);
 
-  hr = ::CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
-                          IID_PPV_ARGS(&graph_builder_));
+  HRESULT hr =
+      ::CoCreateInstance(CLSID_FilterGraph, nullptr, CLSCTX_INPROC_SERVER,
+                         IID_PPV_ARGS(&graph_builder_));
   DLOG_IF_FAILED_WITH_HRESULT("Failed to create capture filter", hr);
   if (FAILED(hr))
     return false;
 
-  hr = ::CoCreateInstance(CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC,
+  hr = ::CoCreateInstance(CLSID_CaptureGraphBuilder2, nullptr, CLSCTX_INPROC,
                           IID_PPV_ARGS(&capture_graph_builder_));
   DLOG_IF_FAILED_WITH_HRESULT("Failed to create the Capture Graph Builder", hr);
   if (FAILED(hr))
@@ -430,13 +360,13 @@ bool VideoCaptureDeviceWin::Init() {
   if (FAILED(hr))
     return false;
 
-  hr = graph_builder_->AddFilter(capture_filter_.Get(), NULL);
+  hr = graph_builder_->AddFilter(capture_filter_.Get(), nullptr);
   DLOG_IF_FAILED_WITH_HRESULT("Failed to add the capture device to the graph",
                               hr);
   if (FAILED(hr))
     return false;
 
-  hr = graph_builder_->AddFilter(sink_filter_.get(), NULL);
+  hr = graph_builder_->AddFilter(sink_filter_.get(), nullptr);
   DLOG_IF_FAILED_WITH_HRESULT("Failed to add the sink filter to the graph", hr);
   if (FAILED(hr))
     return false;
@@ -541,7 +471,7 @@ void VideoCaptureDeviceWin::AllocateAndStart(
                                  input_sink_pin_.Get());
   } else {
     hr = graph_builder_->ConnectDirect(output_capture_pin_.Get(),
-                                       input_sink_pin_.Get(), NULL);
+                                       input_sink_pin_.Get(), nullptr);
   }
 
   if (FAILED(hr)) {

media/capture/video/win/video_capture_device_win.h

@@ -42,7 +42,7 @@ class VideoCaptureDeviceWin : public VideoCaptureDevice,
   // avoid memory leaks.
   class ScopedMediaType {
    public:
-    ScopedMediaType() : media_type_(NULL) {}
+    ScopedMediaType() : media_type_(nullptr) {}
     ~ScopedMediaType() { Free(); }
 
     AM_MEDIA_TYPE* operator->() { return media_type_; }
@@ -57,25 +57,25 @@ class VideoCaptureDeviceWin : public VideoCaptureDevice,
     AM_MEDIA_TYPE* media_type_;
   };
 
-  static void GetDeviceCapabilityList(const std::string& device_id,
-                                      bool query_detailed_frame_rates,
-                                      CapabilityList* out_capability_list);
+  static void GetDeviceCapabilityList(
+      Microsoft::WRL::ComPtr<IBaseFilter> capture_filter,
+      bool query_detailed_frame_rates,
+      CapabilityList* out_capability_list);
   static void GetPinCapabilityList(
       Microsoft::WRL::ComPtr<IBaseFilter> capture_filter,
       Microsoft::WRL::ComPtr<IPin> output_capture_pin,
       bool query_detailed_frame_rates,
       CapabilityList* out_capability_list);
-  static HRESULT GetDeviceFilter(const std::string& device_id,
-                                 IBaseFilter** filter);
-  static Microsoft::WRL::ComPtr<IPin> GetPin(IBaseFilter* filter,
-                                             PIN_DIRECTION pin_dir,
-                                             REFGUID category,
-                                             REFGUID major_type);
+  static Microsoft::WRL::ComPtr<IPin> GetPin(
+      Microsoft::WRL::ComPtr<IBaseFilter> capture_filter,
+      PIN_DIRECTION pin_dir,
+      REFGUID category,
+      REFGUID major_type);
   static VideoPixelFormat TranslateMediaSubtypeToPixelFormat(
       const GUID& sub_type);
 
-  explicit VideoCaptureDeviceWin(
-      const VideoCaptureDeviceDescriptor& device_descriptor);
+  VideoCaptureDeviceWin(const VideoCaptureDeviceDescriptor& device_descriptor,
+                        Microsoft::WRL::ComPtr<IBaseFilter> capture_filter);
   ~VideoCaptureDeviceWin() override;
   // Opens the device driver for this device.
   bool Init();