Retrieve driver information in WinRT WebMIDI backend

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 <comdef.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"
 #include "base/scoped_generic.h"
+#include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "base/win/scoped_comptr.h"
 #include "media/midi/midi_scheduler.h"
 
 namespace media {
 namespace midi {
 namespace {
@@ skipping 212 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>;
+
+// 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 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
+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()));
+    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()));
+    return;
+  }
+
+  if (!SetupDiBuildDriverInfoList(devinfo_list.get(), &devinfo_data,
+                                  SPDIT_COMPATDRIVER)) {
+    VLOG(1) << "SetupDiBuildDriverInfoList failed: "
+            << PrintHr(HRESULT_FROM_WIN32(GetLastError()));
+    return;
+  }
+
+  // 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);
+
+    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()));
+}
+
 // 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;
   ScopedComPtr<InterfaceType> handle;
   EventRegistrationToken token_MessageReceived;
@@ skipping 313 matching lines @@
 
     EventRegistrationToken token = {kInvalidTokenValue};
     if (!RegisterOnMessageReceived(handle, &token))
       return;
 
     std::string dev_id = GetDeviceIdString(handle);
 
     MidiPort<InterfaceType>* port = GetPortByDeviceId(dev_id);
 
     if (port == nullptr) {
-      // TODO(crbug.com/642604): Fill in manufacturer and driver version.
-      AddPort(MidiPortInfo(dev_id, std::string("Manufacturer"),
-                           port_names_[dev_id], std::string("DriverVersion"),
-                           MIDI_PORT_OPENED));
+      std::string manufacturer = "Unknown", driver_version = "Unknown";
+      GetDriverInfoFromDeviceId(dev_id, &manufacturer, &driver_version);
+
+      AddPort(MidiPortInfo(dev_id, manufacturer, port_names_[dev_id],
+                           driver_version, MIDI_PORT_OPENED));
 
       port = new MidiPort<InterfaceType>;
       port->index = static_cast<uint32_t>(port_ids_.size());
 
       ports_[dev_id].reset(port);
       port_ids_.push_back(dev_id);
     } else {
       SetPortState(port->index, MIDI_PORT_CONNECTED);
     }
 
@@ skipping 341 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