HID: Support top-level collection usages in device info.

device/hid/hid_connection_linux.cc

 // Copyright (c) 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 "device/hid/hid_connection_linux.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <libudev.h>
 #include <linux/hidraw.h>
@@ skipping 24 matching lines @@
 scoped_refptr<net::IOBufferWithSize> CopyBufferWithReportId(
     scoped_refptr<net::IOBufferWithSize> buffer,
     uint8_t report_id) {
   scoped_refptr<net::IOBufferWithSize> new_buffer(
       new net::IOBufferWithSize(buffer->size() + 1));
   new_buffer->data()[0] = report_id;
   memcpy(new_buffer->data() + 1, buffer->data(), buffer->size());
   return new_buffer;
 }
 
-const char kHidrawSubsystem[] = "hidraw";
-
 }  // namespace
 
 HidConnectionLinux::HidConnectionLinux(HidDeviceInfo device_info,
-                                       ScopedUdevDevicePtr udev_raw_device)
+                                       std::string dev_node)
     : HidConnection(device_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  udev_device* dev = udev_raw_device.get();
-  std::string dev_node;
-  if (!FindHidrawDevNode(dev, &dev_node)) {
-    LOG(ERROR) << "Cannot open HID device as hidraw device.";
-    return;
-  }
-
   int flags = base::File::FLAG_OPEN |
               base::File::FLAG_READ |
               base::File::FLAG_WRITE;
 
   base::File device_file(base::FilePath(dev_node), flags);
   if (!device_file.IsValid()) {
     base::File::Error file_error = device_file.error_details();
 
     if (file_error == base::File::FILE_ERROR_ACCESS_DENIED) {
       flags = base::File::FLAG_OPEN | base::File::FLAG_READ;
@@ skipping 138 matching lines @@
     if (report.buffer->size() > read.buffer->size()) {
       read.callback.Run(false, report.buffer->size());
     } else {
       memcpy(read.buffer->data(), report.buffer->data(), report.buffer->size());
       pending_reports_.pop();
       read.callback.Run(true, report.buffer->size());
     }
   }
 }
 
-bool HidConnectionLinux::FindHidrawDevNode(udev_device* parent,
-                                           std::string* result) {
-  udev* udev = udev_device_get_udev(parent);
-  if (!udev) {
-      return false;
-  }
-  ScopedUdevEnumeratePtr enumerate(udev_enumerate_new(udev));
-  if (!enumerate) {
-    return false;
-  }
-  if (udev_enumerate_add_match_subsystem(enumerate.get(), kHidrawSubsystem)) {
-    return false;
-  }
-  if (udev_enumerate_scan_devices(enumerate.get())) {
-    return false;
-  }
-  std::string parent_path(udev_device_get_devpath(parent));
-  if (parent_path.length() == 0 || *parent_path.rbegin() != '/')
-    parent_path += '/';
-  udev_list_entry* devices = udev_enumerate_get_list_entry(enumerate.get());
-  for (udev_list_entry* i = devices; i != NULL;
-       i = udev_list_entry_get_next(i)) {
-    ScopedUdevDevicePtr hid_dev(
-        udev_device_new_from_syspath(udev, udev_list_entry_get_name(i)));
-    const char* raw_path = udev_device_get_devnode(hid_dev.get());
-    std::string device_path = udev_device_get_devpath(hid_dev.get());
-    if (raw_path &&
-        !device_path.compare(0, parent_path.length(), parent_path)) {
-      std::string sub_path = device_path.substr(parent_path.length());
-      if (sub_path.substr(0, sizeof(kHidrawSubsystem)-1) == kHidrawSubsystem) {
-        *result = raw_path;
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
 }  // namespace device
-