Replace Setup API with PnP Configuration Manager in MidiManagerWinrt

media/midi/midi_manager_winrt.cc

 // Copyright 2016 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/midi/midi_manager_winrt.h"
 
 // TODO(shaochuan): Remove this once clang supports uuid syntax in <robuffer.h>.
 // https://reviews.llvm.org/D23895
 namespace Windows {
 namespace Storage {
 namespace Streams {
 #pragma warning(disable : 4467)
 struct __declspec(uuid("905a0fef-bc53-11df-8c49-001e4fc686da"))
     IBufferByteAccess;
 }
 }
 }
 
+#include <initguid.h>  // Required by <devpkey.h>
+
+#include <cfgmgr32.h>
 #include <comdef.h>
+#include <devpkey.h>
 #include <robuffer.h>
-#include <setupapi.h>
 #include <windows.devices.enumeration.h>
 #include <windows.devices.midi.h>
 #include <wrl/event.h>
 
 #include <iomanip>
 #include <unordered_map>
 #include <unordered_set>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 224 matching lines @@
 bool IsMicrosoftSynthesizer(IDeviceInformation* info) {
   auto midi_synthesizer_statics =
       WrlStaticsFactory<IMidiSynthesizerStatics,
                         RuntimeClass_Windows_Devices_Midi_MidiSynthesizer>();
   boolean result = FALSE;
   HRESULT hr = midi_synthesizer_statics->IsSynthesizer(info, &result);
   VLOG_IF(1, FAILED(hr)) << "IsSynthesizer failed: " << PrintHr(hr);
   return result != FALSE;
 }
 
-class ScopedDeviceInfoListTraits {
- public:
-  static HDEVINFO InvalidValue() { return INVALID_HANDLE_VALUE; }
-
-  static void Free(HDEVINFO devinfo_set) {
-    SetupDiDestroyDeviceInfoList(devinfo_set);
-  }
-};
-
-using ScopedDeviceInfoList =
-    base::ScopedGeneric<HDEVINFO, ScopedDeviceInfoListTraits>;
+// This is the maximum string length in driver INF files.

[Takashi Toyoshima, 2016/09/07 09:22:34]

If you know an official document about this magic number, can you have a link
here as a comment?

[Shao-Chuan Lee, 2016/09/08 06:23:30]

Now retrieving buffer size from CM_Get_DevNode_Property() and dynamically
allocate buffer.

+const size_t kMaxDevicePropertyLength = 4096;
 
 // Retrieves manufacturer (provider) and version information of underlying
-// device driver using Setup API, given device (interface) ID provided by WinRT.
-// |out_manufacturer| and |out_driver_version| won't be modified if retrieval
-// fails. Note that SetupDiBuildDriverInfoList() would block for a few hundred
-// milliseconds so consider calling this function in an asynchronous manner.
+// device driver through PnP Configuration Manager, given device (interface) ID
+// provided by WinRT. |out_manufacturer| and |out_driver_version| won't be
+// modified if retrieval fails.
 //
 // Device instance ID is extracted from device (interface) ID provided by WinRT
 // APIs, for example from the following interface ID:
 // \\?\SWD#MMDEVAPI#MIDII_60F39FCA.P_0002#{504be32c-ccf6-4d2c-b73f-6f8b3747e22b}
 // we extract the device instance ID: SWD\MMDEVAPI\MIDII_60F39FCA.P_0002
+//
+// However the extracted device instance ID represent a "software device"
+// provided by Microsoft, which is an interface on top of the hardware for each
+// input/output port. Therefore we further locate its parent device, which is
+// the actual hardware device, for driver information.
 void GetDriverInfoFromDeviceId(const std::string& dev_id,
                                std::string* out_manufacturer,
                                std::string* out_driver_version) {
   base::string16 dev_instance_id =
       base::UTF8ToWide(dev_id.substr(4, dev_id.size() - 43));
   base::ReplaceChars(dev_instance_id, L"#", L"\\", &dev_instance_id);
 
-  ScopedDeviceInfoList devinfo_list(
-      SetupDiCreateDeviceInfoList(nullptr, nullptr));
-  if (!devinfo_list.is_valid()) {
-    VLOG(1) << "SetupDiCreateDeviceInfoList failed: "
-            << PrintHr(HRESULT_FROM_WIN32(GetLastError()));
+  DEVINST dev_instance_handle;
+  CONFIGRET cr = CM_Locate_DevNode(&dev_instance_handle, &dev_instance_id[0],
+                                   CM_LOCATE_DEVNODE_NORMAL);
+  if (cr != CR_SUCCESS) {
+    VLOG(1) << "CM_Locate_DevNode failed: CONFIGRET 0x" << std::hex << cr;

[Takashi Toyoshima, 2016/09/07 09:22:34]

Hum.... another kind of error code again :/
CM_MapCrToWin32Err() would help to use existing PrintHr infra?

[Shao-Chuan Lee, 2016/09/08 06:23:30]

Tried this and found only a few error codes are mapped to WinAPI errors, should
be better to print the original code for debug purposes.

[Takashi Toyoshima, 2016/09/09 05:17:41]

So could you left what you tried and why you do like this as comments?

[Shao-Chuan Lee, 2016/09/09 05:44:47]

Done.

     return;
   }
 
-  SP_DEVINFO_DATA devinfo_data = {0};
-  devinfo_data.cbSize = sizeof(SP_DEVINFO_DATA);
-  SP_DRVINFO_DATA drvinfo_data = {0};
-  drvinfo_data.cbSize = sizeof(SP_DRVINFO_DATA);
-
-  if (!SetupDiOpenDeviceInfo(devinfo_list.get(), dev_instance_id.c_str(),
-                             nullptr, 0, &devinfo_data)) {
-    VLOG(1) << "SetupDiOpenDeviceInfo failed: "
-            << PrintHr(HRESULT_FROM_WIN32(GetLastError()));
+  DEVINST parent_handle;
+  cr = CM_Get_Parent(&parent_handle, dev_instance_handle, 0);
+  if (cr != CR_SUCCESS) {
+    VLOG(1) << "CM_Get_Parent failed: CONFIGRET 0x" << std::hex << cr;
     return;
   }
 
-  if (!SetupDiBuildDriverInfoList(devinfo_list.get(), &devinfo_data,
-                                  SPDIT_COMPATDRIVER)) {
-    VLOG(1) << "SetupDiBuildDriverInfoList failed: "
-            << PrintHr(HRESULT_FROM_WIN32(GetLastError()));
-    return;
-  }
+  DEVPROPTYPE devprop_type;
+  base::char16 buffer[kMaxDevicePropertyLength];
+  unsigned long buffer_size = sizeof(buffer);
 
-  // Assume only one entry in driver info list.
-  if (SetupDiEnumDriverInfo(devinfo_list.get(), &devinfo_data,
-                            SPDIT_COMPATDRIVER, 0, &drvinfo_data)) {
-    *out_manufacturer = base::WideToUTF8(drvinfo_data.ProviderName);
+  cr = CM_Get_DevNode_Property(parent_handle, &DEVPKEY_Device_DriverProvider,
+                               &devprop_type, reinterpret_cast<BYTE*>(buffer),
+                               &buffer_size, 0);
+  if (cr != CR_SUCCESS)
+    VLOG(1) << "CM_Get_DevNode_Property failed: CONFIGRET 0x" << std::hex << cr;
+  else if (devprop_type != DEVPROP_TYPE_STRING)
+    VLOG(1) << "CM_Get_DevNode_Property returns wrong data type, "
+            << "expected DEVPROP_TYPE_STRING.";
+  else
+    *out_manufacturer = base::WideToUTF8(buffer);
 
-    std::stringstream ss;
-    ss << (drvinfo_data.DriverVersion >> 48) << "."
-       << (drvinfo_data.DriverVersion >> 32 & 0xffff) << "."
-       << (drvinfo_data.DriverVersion >> 16 & 0xffff) << "."
-       << (drvinfo_data.DriverVersion & 0xffff);
-    *out_driver_version = ss.str();
-  } else {
-    VLOG(1) << "SetupDiEnumDriverInfo failed: "
-            << PrintHr(HRESULT_FROM_WIN32(GetLastError()));
-  }
-
-  if (!SetupDiDestroyDriverInfoList(devinfo_list.get(), &devinfo_data,
-                                    SPDIT_COMPATDRIVER))
-    VLOG(1) << "SetupDiDestroyDriverInfoList failed: "
-            << PrintHr(HRESULT_FROM_WIN32(GetLastError()));
+  buffer_size = sizeof(buffer);
+  cr = CM_Get_DevNode_Property(parent_handle, &DEVPKEY_Device_DriverVersion,
+                               &devprop_type, reinterpret_cast<BYTE*>(buffer),
+                               &buffer_size, 0);
+  if (cr != CR_SUCCESS)
+    VLOG(1) << "CM_Get_DevNode_Property failed: CONFIGRET 0x" << std::hex << cr;
+  else if (devprop_type != DEVPROP_TYPE_STRING)
+    VLOG(1) << "CM_Get_DevNode_Property returns wrong data type, "
+            << "expected DEVPROP_TYPE_STRING.";
+  else
+    *out_driver_version = base::WideToUTF8(buffer);
 }
 
 // Tokens with value = 0 are considered invalid (as in <wrl/event.h>).
 const int64_t kInvalidTokenValue = 0;
 
 template <typename InterfaceType>
 struct MidiPort {
   MidiPort() = default;
 
   uint32_t index;
@@ skipping 681 matching lines @@
 void MidiManagerWinrt::OnPortManagerReady() {
   DCHECK(com_thread_checker_->CalledOnValidThread());
   DCHECK(port_manager_ready_count_ < 2);
 
   if (++port_manager_ready_count_ == 2)
     CompleteInitialization(Result::OK);
 }
 
 }  // namespace midi
 }  // namespace media