Web MIDI: extract manufacturer names on some devices

media/midi/dynamically_initialized_midi_manager_win.cc

 // Copyright 2017 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/dynamically_initialized_midi_manager_win.h"
 
 #include <windows.h>
 
+#include <ks.h>
+#include <ksmedia.h>
 #include <mmreg.h>
 #include <mmsystem.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
+#include "device/usb/usb_ids.h"
 #include "media/midi/message_util.h"
 #include "media/midi/midi_port_info.h"
 #include "media/midi/midi_service.h"
 
 namespace midi {
 
 // Forward declaration of PortManager for anonymous functions and internal
 // classes to use it.
 class DynamicallyInitializedMidiManagerWin::PortManager {
  public:
@@ skipping 147 matching lines @@
   midiInClose(handle);
 }
 
 void FinalizeOutPort(HMIDIOUT handle) {
   // Resets inflight buffers. This will cancel sending data that system
   // holds and were not sent yet.
   midiOutReset(handle);
   midiOutClose(handle);
 }
 
+// Gets manufacturer name in string from identifiers.
+std::string GetManufacturerName(uint16_t id, const GUID& guid) {
+  if (IS_COMPATIBLE_USBAUDIO_MID(&guid)) {
+    const char* name =
+        device::UsbIds::GetVendorName(EXTRACT_USBAUDIO_MID(&guid));
+    if (name)
+      return std::string(name);
+  }
+  if (id == MM_MICROSOFT)
+    return "Microsoft Corporation";
+
+  // TODO(crbug.com/472341): Support other manufacture IDs.
+  return "";
+}
+
 // All instances of Port subclasses are always accessed behind a lock of
 // *GetTaskLock(). Port and subclasses implementation do not need to
 // consider thread safety.
 class Port {
  public:
   Port(const std::string& type,
        uint32_t device_id,
        uint16_t manufacturer_id,
        uint16_t product_id,
        uint32_t driver_version,
-       const std::string& product_name)
+       const std::string& product_name,
+       const GUID& manufacturer_guid)
       : index_(0u),
         type_(type),
         device_id_(device_id),
         manufacturer_id_(manufacturer_id),
         product_id_(product_id),
         driver_version_(driver_version),
         product_name_(product_name) {
-    info_.manufacturer = "unknown";  // TODO(toyoshim): Use USB information.
+    info_.manufacturer =
+        GetManufacturerName(manufacturer_id, manufacturer_guid);
     info_.name = product_name_;
     info_.version = base::StringPrintf("%d.%d", HIBYTE(driver_version_),
                                        LOBYTE(driver_version_));
     info_.state = mojom::PortState::DISCONNECTED;
   }
 
   virtual ~Port() {}
 
   bool operator==(const Port& other) const {
     // Should not use |device_id| for comparison because it can be changed on
@@ skipping 59 matching lines @@
   InPort(DynamicallyInitializedMidiManagerWin* manager,
          int instance_id,
          UINT device_id,
          const MIDIINCAPS2W& caps)
       : Port("input",
              device_id,
              caps.wMid,
              caps.wPid,
              caps.vDriverVersion,
              base::WideToUTF8(
-                 base::string16(caps.szPname, wcslen(caps.szPname)))),
+                 base::string16(caps.szPname, wcslen(caps.szPname))),
+             caps.ManufacturerGuid),
         manager_(manager),
         in_handle_(kInvalidInHandle),
         instance_id_(instance_id) {}
 
   static std::vector<std::unique_ptr<InPort>> EnumerateActivePorts(
       DynamicallyInitializedMidiManagerWin* manager,
       int instance_id) {
     std::vector<std::unique_ptr<InPort>> ports;
     const UINT num_devices = midiInGetNumDevs();
     for (UINT device_id = 0; device_id < num_devices; ++device_id) {
@@ skipping 94 matching lines @@
 
 class DynamicallyInitializedMidiManagerWin::OutPort final : public Port {
  public:
   OutPort(UINT device_id, const MIDIOUTCAPS2W& caps)
       : Port("output",
              device_id,
              caps.wMid,
              caps.wPid,
              caps.vDriverVersion,
              base::WideToUTF8(
-                 base::string16(caps.szPname, wcslen(caps.szPname)))),
+                 base::string16(caps.szPname, wcslen(caps.szPname))),
+             caps.ManufacturerGuid),
         software_(caps.wTechnology == MOD_SWSYNTH),
         out_handle_(kInvalidOutHandle) {}
 
   static std::vector<std::unique_ptr<OutPort>> EnumerateActivePorts() {
     std::vector<std::unique_ptr<OutPort>> ports;
     const UINT num_devices = midiOutGetNumDevs();
     for (UINT device_id = 0; device_id < num_devices; ++device_id) {
       MIDIOUTCAPS2W caps;
       MMRESULT result = midiOutGetDevCaps(
           device_id, reinterpret_cast<LPMIDIOUTCAPSW>(&caps), sizeof(caps));
@@ skipping 410 matching lines @@
     const std::vector<uint8_t>& data) {
   CHECK_GT(port_manager_->outputs()->size(), port_index);
   (*port_manager_->outputs())[port_index]->Send(data);
   // |client| will be checked inside MidiManager::AccumulateMidiBytesSent.
   PostReplyTask(
       base::Bind(&DynamicallyInitializedMidiManagerWin::AccumulateMidiBytesSent,
                  base::Unretained(this), client, data.size()));
 }
 
 }  // namespace midi