Web MIDI ALSA: Enable hardware based device matching

media/midi/midi_manager_alsa.h

 // 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.
 
 #ifndef MEDIA_MIDI_MIDI_MANAGER_ALSA_H_
 #define MEDIA_MIDI_MIDI_MANAGER_ALSA_H_
 
 #include <alsa/asoundlib.h>
 #include <map>
 #include <vector>
@@ skipping 30 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(MidiManagerAlsaTest, ExtractManufacturer);
   FRIEND_TEST_ALL_PREFIXES(MidiManagerAlsaTest, ToMidiPortState);
 
   class AlsaCard;
   typedef std::map<int, AlsaCard*> AlsaCardMap;
 
   class MidiPort {
    public:
     enum class Type { kInput, kOutput };
 
+    // The Id class is used to keep the multiple strings separate
+    // but compare them all together for equality purposes.
+    // The individual strings that make up the Id can theoretically contain
+    // arbitrary characters, so unfortunately there is no simple way to
+    // concatenate them into a single string.
+    class Id final {
+     public:
+      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);
+      Id(const Id&);
+      ~Id();
+      bool operator==(const Id&) const;
+      bool empty() const;
+
+      std::string bus() const { return bus_; }
+      std::string vendor_id() const { return vendor_id_; }
+      std::string model_id() const { return model_id_; }
+      std::string usb_interface_num() const { return usb_interface_num_; }
+      std::string serial() const { return serial_; }
+
+     private:
+      std::string bus_;
+      std::string vendor_id_;
+      std::string model_id_;
+      std::string usb_interface_num_;
+      std::string serial_;
+    };
+
     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);
     ~MidiPort();
 
@@ skipping 14 matching lines @@
     bool MatchCardPass1(const MidiPort& query) const;
     // Checks for equality for kernel cards with id, pass 2.
     bool MatchCardPass2(const MidiPort& query) const;
     // Checks for equality for non-card clients, pass 1.
     bool MatchNoCardPass1(const MidiPort& query) const;
     // Checks for equality for non-card clients, pass 2.
     bool MatchNoCardPass2(const MidiPort& query) const;
 
     // accessors
     std::string path() const { return path_; }
-    std::string id() const { return id_; }
+    Id id() const { return id_; }
     std::string client_name() const { return client_name_; }
     std::string port_name() const { return port_name_; }
     std::string manufacturer() const { return manufacturer_; }
     std::string version() const { return version_; }
     int client_id() const { return client_id_; }
     int port_id() const { return port_id_; }
     int midi_device() const { return midi_device_; }
     Type type() const { return type_; }
     uint32 web_port_index() const { return web_port_index_; }
     bool connected() const { return connected_; }
@@ skipping 14 matching lines @@
       client_id_ = client_id;
       port_id_ = port_id;
       client_name_ = client_name;
       port_name_ = port_name;
       manufacturer_ = manufacturer;
       version_ = version;
     }
 
    private:
     // Immutable properties.
-    const std::string id_;
+    const Id id_;
     const int midi_device_;
 
     const Type type_;
 
     // Mutable properties. These will get updated as ports move around or
     // drivers change.
     std::string path_;
     int client_id_;
     int port_id_;
     std::string client_name_;
@@ skipping 137 matching lines @@
     // we are in sync between ALSA and udev. Until then, we cannot generate
     // MIDIConnectionEvents to web clients.
     int card_client_count_;
 
     DISALLOW_COPY_AND_ASSIGN(AlsaSeqState);
   };
 
   class AlsaCard {
    public:
     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);
     ~AlsaCard();
-    const std::string alsa_name() const { return alsa_name_; }
-    const std::string alsa_longname() const { return alsa_longname_; }
-    const std::string manufacturer() const { return manufacturer_; }
-    const std::string alsa_driver() const { return alsa_driver_; }
+    std::string name() const { return name_; }
+    std::string longname() const { return longname_; }
+    std::string driver() const { return driver_; }
+    std::string path() const { return path_; }
+    std::string bus() const { return bus_; }
+    std::string vendor_id() const { return vendor_id_; }
+    std::string model_id() const { return model_id_; }
+    std::string usb_interface_num() const { return usb_interface_num_; }
+    std::string serial() const { return serial_; }
     int midi_device_count() const { return midi_device_count_; }
-    // Returns hardware path.
-    const std::string path() const;
-    // Returns the id we can use to try to match hardware across different
-    // paths.
-    const std::string id() const;
+    std::string manufacturer() const { return manufacturer_; }
 
    private:
     FRIEND_TEST_ALL_PREFIXES(MidiManagerAlsaTest, ExtractManufacturer);
 
     // Extracts the manufacturer using heuristics and a variety of sources.
     static std::string 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,
-        const std::string& alsa_longname);
+        const std::string& name,
+        const std::string& longname);
 
-    std::string alsa_name_;
-    std::string alsa_longname_;
-    std::string manufacturer_;
-    std::string alsa_driver_;
-    std::string path_;
-    std::string bus_;
-    std::string serial_;
-    std::string vendor_id_;
-    std::string model_id_;
-    std::string usb_interface_num_;
-    int midi_device_count_;
+    const std::string name_;
+    const std::string longname_;
+    const std::string driver_;
+    const std::string path_;
+    const std::string bus_;
+    const std::string vendor_id_;
+    const std::string model_id_;
+    const std::string usb_interface_num_;
+    const std::string serial_;
+    const int midi_device_count_;
+    const std::string manufacturer_;
 
     DISALLOW_COPY_AND_ASSIGN(AlsaCard);
   };
 
   typedef base::hash_map<int, uint32> SourceMap;
   typedef base::hash_map<uint32, int> OutPortMap;
 
   // An internal callback that runs on MidiSendThread.
   void SendMidiData(uint32 port_index, const std::vector<uint8>& data);
 
@@ skipping 61 matching lines @@
   bool event_thread_shutdown_;  // guarded by shutdown_lock_
   base::Lock shutdown_lock_;    // guards event_thread_shutdown_
 
   DISALLOW_COPY_AND_ASSIGN(MidiManagerAlsa);
 };
 
 }  // namespace midi
 }  // namespace media
 
 #endif  // MEDIA_MIDI_MIDI_MANAGER_ALSA_H_