Web MIDI ALSA: Enable hardware based device matching

media/midi/midi_manager_alsa.cc

 // Copyright 2014 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_alsa.h"
 
 #include <poll.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <string>
@@ skipping 106 matching lines @@
   size_t i = syspath_str.rfind(kCardSyspath);
   if (i == std::string::npos)
     return -1;
 
   int number;
   if (!base::StringToInt(syspath_str.substr(i + strlen(kCardSyspath)), &number))
     return -1;
   return number;
 }
 
+std::string GetVendor(udev_device* dev) {
+  // Try to get the vendor string. Sometimes it is encoded.
+  std::string vendor = device::UdevDecodeString(
+      device::UdevDeviceGetPropertyValue(dev, kUdevIdVendorEnc));
+  // Sometimes it is not encoded.
+  if (vendor.empty())
+    vendor =
+        UdevDeviceGetPropertyOrSysattr(dev, kUdevIdVendor, kSysattrVendorName);
+  return vendor;
+}
+
 void SetStringIfNonEmpty(base::DictionaryValue* value,
                          const std::string& path,
                          const std::string& in_value) {
   if (!in_value.empty())
     value->SetString(path, in_value);
 }
 
 }  // namespace
 
 MidiManagerAlsa::MidiManagerAlsa()
@@ skipping 154 matching lines @@
       FROM_HERE, base::Bind(&MidiManagerAlsa::SendMidiData,
                             base::Unretained(this), port_index, data),
       delay);
 
   // Acknowledge send.
   send_thread_.message_loop()->PostTask(
       FROM_HERE, base::Bind(&MidiManagerClient::AccumulateMidiBytesSent,
                             base::Unretained(client), data.size()));
 }
 
+MidiManagerAlsa::MidiPort::Id::Id() = default;
+
+MidiManagerAlsa::MidiPort::Id::Id(const std::string& bus,
+                                  const std::string& vendor_id,
+                                  const std::string& model_id,
+                                  const std::string& usb_interface_num,
+                                  const std::string& serial)
+    : bus_(bus),
+      vendor_id_(vendor_id),
+      model_id_(model_id),
+      usb_interface_num_(usb_interface_num),
+      serial_(serial) {
+}
+
+MidiManagerAlsa::MidiPort::Id::Id(const Id&) = default;
+
+MidiManagerAlsa::MidiPort::Id::~Id() = default;
+
+bool MidiManagerAlsa::MidiPort::Id::operator==(const Id& rhs) const {
+  return (bus_ == rhs.bus_) && (vendor_id_ == rhs.vendor_id_) &&
+         (model_id_ == rhs.model_id_) &&
+         (usb_interface_num_ == rhs.usb_interface_num_) &&
+         (serial_ == rhs.serial_);
+}
+
+bool MidiManagerAlsa::MidiPort::Id::empty() const {
+  return bus_.empty() && vendor_id_.empty() && model_id_.empty() &&
+         usb_interface_num_.empty() && serial_.empty();
+}
+
 MidiManagerAlsa::MidiPort::MidiPort(const std::string& path,
-                                    const std::string& id,
+                                    const Id& id,
                                     int client_id,
                                     int port_id,
                                     int midi_device,
                                     const std::string& client_name,
                                     const std::string& port_name,
                                     const std::string& manufacturer,
                                     const std::string& version,
                                     Type type)
     : id_(id),
       midi_device_(midi_device),
@@ skipping 19 matching lines @@
   switch (type_) {
     case Type::kInput:
       type = "input";
       break;
     case Type::kOutput:
       type = "output";
       break;
   }
   value->SetString("type", type);
   SetStringIfNonEmpty(value.get(), "path", path_);
-  SetStringIfNonEmpty(value.get(), "id", id_);
   SetStringIfNonEmpty(value.get(), "clientName", client_name_);
   SetStringIfNonEmpty(value.get(), "portName", port_name_);
   value->SetInteger("clientId", client_id_);
   value->SetInteger("portId", port_id_);
   value->SetInteger("midiDevice", midi_device_);
 
+  // Flatten id fields.
+  SetStringIfNonEmpty(value.get(), "bus", id_.bus());
+  SetStringIfNonEmpty(value.get(), "vendorId", id_.vendor_id());
+  SetStringIfNonEmpty(value.get(), "modelId", id_.model_id());
+  SetStringIfNonEmpty(value.get(), "usbInterfaceNum", id_.usb_interface_num());
+  SetStringIfNonEmpty(value.get(), "serial", id_.serial());
+
   return value.Pass();
 }
 
 std::string MidiManagerAlsa::MidiPort::JSONValue() const {
   std::string json;
   JSONStringValueSerializer serializer(&json);
   serializer.Serialize(*Value().get());
   return json;
 }
 
@@ skipping 255 matching lines @@
   int card_midi_device = -1;
   for (const auto& client_pair : clients_) {
     int client_id = client_pair.first;
     const auto& client = client_pair.second;
 
     // Get client metadata.
     const std::string client_name = client->name();
     std::string manufacturer;
     std::string driver;
     std::string path;
-    std::string id;
-    std::string serial;
+    MidiPort::Id id;
     std::string card_name;
     std::string card_longname;
     int midi_device = -1;
 
     if (IsCardClient(client->type(), client_id)) {
       auto& card = card_it->second;
       if (card_midi_device == -1)
         card_midi_device = 0;
 
       manufacturer = card->manufacturer();
+      path = card->path();
+      id = MidiPort::Id(card->bus(), card->vendor_id(), card->model_id(),
+                        card->usb_interface_num(), card->serial());
+      card_name = card->name();
+      card_longname = card->longname();
       midi_device = card_midi_device;
 
       ++card_midi_device;
       if (card_midi_device >= card->midi_device_count()) {
         card_midi_device = -1;
         ++card_it;
       }
     }
 
     for (const auto& port_pair : *client) {
@@ skipping 62 matching lines @@
 MidiManagerAlsa::AlsaSeqState::Client::begin() const {
   return ports_.begin();
 }
 
 MidiManagerAlsa::AlsaSeqState::Client::PortMap::const_iterator
 MidiManagerAlsa::AlsaSeqState::Client::end() const {
   return ports_.end();
 }
 
 MidiManagerAlsa::AlsaCard::AlsaCard(udev_device* dev,
-                                    const std::string& alsa_name,
-                                    const std::string& alsa_longname,
-                                    const std::string& alsa_driver,
+                                    const std::string& name,
+                                    const std::string& longname,
+                                    const std::string& driver,
                                     int midi_device_count)
-    : alsa_name_(alsa_name),
-      alsa_longname_(alsa_longname),
-      alsa_driver_(alsa_driver),
-      midi_device_count_(midi_device_count) {
-  // Try to get the vendor string. Sometimes it is encoded.
-  std::string vendor = device::UdevDecodeString(
-      device::UdevDeviceGetPropertyValue(dev, kUdevIdVendorEnc));
-  // Sometimes it is not encoded.
-  if (vendor.empty())
-    vendor =
-        UdevDeviceGetPropertyOrSysattr(dev, kUdevIdVendor, kSysattrVendorName);
-  // Also get the vendor string from the hardware database.
-  std::string vendor_from_database =
-      device::UdevDeviceGetPropertyValue(dev, kUdevIdVendorFromDatabase);
-
-  // Get the device path.
-  path_ = device::UdevDeviceGetPropertyValue(dev, kUdevIdPath);
-  // Get the bus.
-  bus_ = device::UdevDeviceGetPropertyValue(dev, kUdevIdBus);
-
-  // Get the "serial" number. (Often untrustable or missing.)
-  serial_ =
-      UdevDeviceGetPropertyOrSysattr(dev, kUdevIdSerialShort, kSysattrGuid);
-
-  // Get the vendor id, by either property or sysattr.
-  vendor_id_ =
-      UdevDeviceGetPropertyOrSysattr(dev, kUdevIdVendorId, kSysattrVendor);
-  // Get the model id, by either property or sysattr.
-  model_id_ =
-      UdevDeviceGetPropertyOrSysattr(dev, kUdevIdModelId, kSysattrModel);
-  // Get the usb interface number.
-  usb_interface_num_ =
-      device::UdevDeviceGetPropertyValue(dev, kUdevIdUsbInterfaceNum);
-  manufacturer_ = ExtractManufacturerString(
-      vendor, vendor_id_, vendor_from_database, alsa_name, alsa_longname);
+    : name_(name),
+      longname_(longname),
+      driver_(driver),
+      path_(device::UdevDeviceGetPropertyValue(dev, kUdevIdPath)),
+      bus_(device::UdevDeviceGetPropertyValue(dev, kUdevIdBus)),
+      vendor_id_(
+          UdevDeviceGetPropertyOrSysattr(dev, kUdevIdVendorId, kSysattrVendor)),
+      model_id_(
+          UdevDeviceGetPropertyOrSysattr(dev, kUdevIdModelId, kSysattrModel)),
+      usb_interface_num_(
+          device::UdevDeviceGetPropertyValue(dev, kUdevIdUsbInterfaceNum)),
+      serial_(UdevDeviceGetPropertyOrSysattr(dev,
+                                             kUdevIdSerialShort,
+                                             kSysattrGuid)),
+      midi_device_count_(midi_device_count),
+      manufacturer_(ExtractManufacturerString(
+          GetVendor(dev),
+          vendor_id_,
+          device::UdevDeviceGetPropertyValue(dev, kUdevIdVendorFromDatabase),
+          name,
+          longname)) {
 }
 
 MidiManagerAlsa::AlsaCard::~AlsaCard() = default;
 
 // static
 std::string MidiManagerAlsa::AlsaCard::ExtractManufacturerString(
     const std::string& udev_id_vendor,
     const std::string& udev_id_vendor_id,
     const std::string& udev_id_vendor_from_database,
     const std::string& alsa_name,
@@ skipping 554 matching lines @@
   source_map_[AddrToInt(client_id, port_id)] = port_index;
   return true;
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerAlsa();
 }
 
 }  // namespace midi
 }  // namespace media