Move UdevDecodeString from media/midi to device/udev_linux

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 <alsa/asoundlib.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/posix/eintr_wrapper.h"
-#include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "media/midi/midi_port_info.h"
 
 namespace media {
 
 namespace {
 
 // Per-output buffer. This can be smaller, but then large sysex messages
 // will be (harmlessly) split across multiple seq events. This should
 // not have any real practical effect, except perhaps to slightly reorder
 // realtime messages with respect to sysex.
 const size_t kSendBufferSize = 256;
 
 // Constants for the capabilities we search for in inputs and outputs.
 // See http://www.alsa-project.org/alsa-doc/alsa-lib/seq.html.
 const unsigned int kRequiredInputPortCaps =
     SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ;
 const unsigned int kRequiredOutputPortCaps =
     SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE;
 
 int AddrToInt(const snd_seq_addr_t* addr) {
   return (addr->client << 8) | addr->port;
 }
 
-#if defined(USE_UDEV)
-// Copied from components/storage_monitor/udev_util_linux.cc.
-// TODO(agoode): Move this into a common place. Maybe device/udev_linux?
-std::string GetUdevDevicePropertyValue(udev_device* udev_device,
-                                       const char* key) {
-  const char* value = device::udev_device_get_property_value(udev_device, key);
-  return value ? value : std::string();
-}
-#endif  // defined(USE_UDEV)
-
 }  // namespace
 
 MidiManagerAlsa::MidiManagerAlsa()
     : in_client_(NULL),
       out_client_(NULL),
       out_client_id_(-1),
       in_port_(-1),
       decoder_(NULL),
 #if defined(USE_UDEV)
       udev_(device::udev_new()),
@@ skipping 263 matching lines @@
   for (EncoderList::iterator i = encoders_.begin(); i != encoders_.end(); ++i)
     snd_midi_event_free(*i);
 }
 
 MidiManagerAlsa::CardInfo::CardInfo(
     const MidiManagerAlsa* outer,
     const std::string& alsa_name, const std::string& alsa_longname,
     const std::string& alsa_driver, int card_index)
     : alsa_name_(alsa_name), alsa_driver_(alsa_driver) {
   // Get udev properties if available.
-  std::string udev_id_vendor_enc;
+  std::string udev_id_vendor;
   std::string udev_id_vendor_id;
   std::string udev_id_vendor_from_database;
 
 #if defined(USE_UDEV)
   const std::string sysname = base::StringPrintf("card%i", card_index);
   device::ScopedUdevDevicePtr udev_device(
       device::udev_device_new_from_subsystem_sysname(
           outer->udev_.get(), "sound", sysname.c_str()));
-  udev_id_vendor_enc = GetUdevDevicePropertyValue(
-      udev_device.get(), "ID_VENDOR_ENC");
-  udev_id_vendor_id = GetUdevDevicePropertyValue(
+  udev_id_vendor = device::UdevDecodeString(device::UdevDeviceGetPropertyValue(
+      udev_device.get(), "ID_VENDOR_ENC"));
+  udev_id_vendor_id = device::UdevDeviceGetPropertyValue(
       udev_device.get(), "ID_VENDOR_ID");
-  udev_id_vendor_from_database = GetUdevDevicePropertyValue(
+  udev_id_vendor_from_database = device::UdevDeviceGetPropertyValue(
       udev_device.get(), "ID_VENDOR_FROM_DATABASE");
 
-  udev_id_path_ = GetUdevDevicePropertyValue(
+  udev_id_path_ = device::UdevDeviceGetPropertyValue(
       udev_device.get(), "ID_PATH");
-  udev_id_id_ = GetUdevDevicePropertyValue(
+  udev_id_id_ = device::UdevDeviceGetPropertyValue(
       udev_device.get(), "ID_ID");
 #endif  // defined(USE_UDEV)
 
   manufacturer_ = ExtractManufacturerString(
-      udev_id_vendor_enc, udev_id_vendor_id, udev_id_vendor_from_database,
+      udev_id_vendor, udev_id_vendor_id, udev_id_vendor_from_database,
       alsa_name, alsa_longname);
 }
 
 MidiManagerAlsa::CardInfo::~CardInfo() {
 }
 
 const std::string MidiManagerAlsa::CardInfo::alsa_name() const {
   return alsa_name_;
 }
 
@@ skipping 120 matching lines @@
   }
 
   // Do again.
   event_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&MidiManagerAlsa::EventLoop, base::Unretained(this)));
 }
 
 // static
 std::string MidiManagerAlsa::CardInfo::ExtractManufacturerString(
-    const std::string& udev_id_vendor_enc,
+    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) {
   // Let's try to determine the manufacturer. Here is the ordered preference
   // in extraction:
-  //  1. Vendor name from the USB device iManufacturer string, stored in
-  //     udev_id_vendor_enc.
-  //  2. Vendor name from the udev hwid database.
+  //  1. Vendor name from the USB device iManufacturer string, from
+  //     the udev property ID_VENDOR_ENC.
+  //  2. Vendor name from the udev database (property ID_VENDOR_FROM_DATABASE).
   //  3. Heuristic from ALSA.
 
   // Is the vendor string not just the USB vendor hex id?
-  std::string udev_id_vendor = UnescapeUdev(udev_id_vendor_enc);
   if (udev_id_vendor != udev_id_vendor_id) {
     return udev_id_vendor;
   }
 
   // Is there a vendor string in the hardware database?
   if (!udev_id_vendor_from_database.empty()) {
     return udev_id_vendor_from_database;
   }
 
   // Ok, udev gave us nothing useful, or was unavailable. So try a heuristic.
   // We assume that card longname is in the format of
   // "<manufacturer> <name> at <bus>". Otherwise, we give up to detect
   // a manufacturer name here.
   size_t at_index = alsa_longname.rfind(" at ");
   if (std::string::npos != at_index) {
     size_t name_index = alsa_longname.rfind(alsa_name, at_index - 1);
     if (std::string::npos != name_index)
       return alsa_longname.substr(0, name_index - 1);
   }
 
   // Failure.
   return "";
 }
 
-// static
-std::string MidiManagerAlsa::CardInfo::UnescapeUdev(const std::string& s) {
-  std::string unescaped;
-  const size_t size = s.size();
-  for (size_t i = 0; i < size; ++i) {
-    char c = s[i];
-    if ((i + 3 < size) && c == '\\' && s[i + 1] == 'x') {
-      c = (HexDigitToInt(s[i + 2]) << 4) +
-          HexDigitToInt(s[i + 3]);
-      i += 3;
-    }
-    unescaped.push_back(c);
-  }
-  return unescaped;
-}
-
 MidiManager* MidiManager::Create() {
   return new MidiManagerAlsa();
 }
 
 }  // namespace media