Add device path enumeration to the new Windows USB backend.

device/usb/usb_service_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 "device/usb/usb_service_win.h"
 
+#include <setupapi.h>
+#include <stdint.h>
+#include <usbiodef.h>
+
+#define INITGUID
+#include <devpkey.h>
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/memory/free_deleter.h"
+#include "base/memory/ptr_util.h"
+#include "base/scoped_generic.h"
+#include "base/single_thread_task_runner.h"
+#include "base/stl_util.h"
+#include "base/strings/string_util.h"
+#include "base/strings/sys_string_conversions.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "base/win/scoped_handle.h"
+#include "components/device_event_log/device_event_log.h"
+#include "device/usb/usb_descriptors.h"
+#include "device/usb/usb_device_handle.h"
+#include "device/usb/webusb_descriptors.h"
+
 namespace device {
 
+namespace {
+
+struct DevInfoScopedTraits {
+  static HDEVINFO InvalidValue() { return INVALID_HANDLE_VALUE; }
+  static void Free(HDEVINFO h) { SetupDiDestroyDeviceInfoList(h); }
+};
+
+using ScopedDevInfo = base::ScopedGeneric<HDEVINFO, DevInfoScopedTraits>;
+
+bool GetDeviceStringProperty(HDEVINFO dev_info,
+                             SP_DEVINFO_DATA* dev_info_data,
+                             const DEVPROPKEY& property,
+                             std::string* property_buffer) {
+  DEVPROPTYPE property_type;
+  DWORD required_size;
+  if (SetupDiGetDeviceProperty(dev_info, dev_info_data, &property,

[scheib, 2017/02/14 19:40:05]

When bluetooth windows work was underway doing similar things to this, I pushed
back to have a testing wrapper at the OS level and to have test coverage for
code such as this. Super tedious, but does get test coverage for all these
permutations of errors. There are many logic paths here and
GetDeviceInterfaceDetails, GetHubDevicePath, FileThreadHelper.

[Reilly Grant (use Gerrit), 2017/02/15 22:03:13]

We discussed the test plan offline.

+                               &property_type, nullptr, 0, &required_size, 0) ||
+      GetLastError() != ERROR_INSUFFICIENT_BUFFER ||
+      property_type != DEVPROP_TYPE_STRING) {
+    return false;
+  }
+
+  std::wstring wide_buffer;
+  if (!SetupDiGetDeviceProperty(
+          dev_info, dev_info_data, &property, &property_type,
+          reinterpret_cast<PBYTE>(base::WriteInto(&wide_buffer, required_size)),
+          required_size, nullptr, 0)) {
+    return false;
+  }
+
+  *property_buffer = base::SysWideToUTF8(wide_buffer);
+  return true;
+}
+
+bool GetDeviceInterfaceDetails(HDEVINFO dev_info,
+                               SP_DEVICE_INTERFACE_DATA* device_interface_data,
+                               std::string* device_path,
+                               uint32_t* port_number,
+                               std::string* parent_instance_id) {
+  DWORD required_size;
+  if (SetupDiGetDeviceInterfaceDetail(dev_info, device_interface_data, nullptr,
+                                      0, &required_size, nullptr) ||
+      GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
+    return false;
+  }
+
+  std::unique_ptr<SP_DEVICE_INTERFACE_DETAIL_DATA, base::FreeDeleter>
+  device_interface_detail_data(
+      static_cast<SP_DEVICE_INTERFACE_DETAIL_DATA*>(malloc(required_size)));
+  device_interface_detail_data->cbSize = sizeof(*device_interface_detail_data);
+
+  SP_DEVINFO_DATA dev_info_data;
+  dev_info_data.cbSize = sizeof(dev_info_data);
+
+  if (!SetupDiGetDeviceInterfaceDetail(
+          dev_info, device_interface_data, device_interface_detail_data.get(),
+          required_size, nullptr, &dev_info_data)) {
+    USB_PLOG(ERROR) << "SetupDiGetDeviceInterfaceDetail";
+    return false;
+  }
+
+  if (device_path) {
+    *device_path =
+        base::SysWideToUTF8(device_interface_detail_data->DevicePath);
+  }
+
+  if (port_number) {
+    DEVPROPTYPE property_type;
+    if (!SetupDiGetDeviceProperty(dev_info, &dev_info_data,
+                                  &DEVPKEY_Device_Address, &property_type,
+                                  reinterpret_cast<PBYTE>(port_number),
+                                  sizeof(*port_number), nullptr, 0) ||
+        property_type != DEVPROP_TYPE_UINT32) {
+      USB_PLOG(ERROR) << "Failed to get device address";
+      return false;
+    }
+  }
+
+  if (parent_instance_id) {
+    if (!GetDeviceStringProperty(dev_info, &dev_info_data,
+                                 DEVPKEY_Device_Parent, parent_instance_id)) {
+      USB_PLOG(ERROR) << "Failed to get the device parent";
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool GetHubDevicePath(const std::string& instance_id,
+                      std::string* device_path) {
+  ScopedDevInfo dev_info(
+      SetupDiGetClassDevsA(&GUID_DEVINTERFACE_USB_HUB, instance_id.c_str(), 0,
+                           DIGCF_DEVICEINTERFACE | DIGCF_PRESENT));
+  if (!dev_info.is_valid()) {
+    USB_PLOG(ERROR) << "SetupDiGetClassDevs";
+    return false;
+  }
+
+  SP_DEVICE_INTERFACE_DATA device_interface_data;
+  device_interface_data.cbSize = sizeof(device_interface_data);
+  if (!SetupDiEnumDeviceInterfaces(dev_info.get(), nullptr,
+                                   &GUID_DEVINTERFACE_USB_HUB, 0,
+                                   &device_interface_data)) {
+    USB_PLOG(ERROR) << "SetupDiEnumDeviceInterfaces";
+    return false;
+  }
+
+  return GetDeviceInterfaceDetails(dev_info.get(), &device_interface_data,
+                                   device_path, nullptr, nullptr);
+}
+
+}  // namespace
+
+class UsbServiceWin::FileThreadHelper {
+ public:
+  explicit FileThreadHelper(base::WeakPtr<UsbServiceWin> service)
+      : task_runner_(base::ThreadTaskRunnerHandle::Get()), service_(service) {}
+  ~FileThreadHelper() {}
+
+  void EnumerateDevices() {
+    ScopedDevInfo dev_info(
+        SetupDiGetClassDevs(&GUID_DEVINTERFACE_USB_DEVICE, nullptr, 0,
+                            DIGCF_DEVICEINTERFACE | DIGCF_PRESENT));
+    if (!dev_info.is_valid()) {
+      USB_PLOG(ERROR) << "Failed to set up device enumeration";
+      task_runner_->PostTask(
+          FROM_HERE, base::Bind(&UsbServiceWin::HelperStarted, service_));
+      return;
+    }
+
+    SP_DEVICE_INTERFACE_DATA device_interface_data;
+    device_interface_data.cbSize = sizeof(device_interface_data);
+    for (DWORD i = 0; SetupDiEnumDeviceInterfaces(dev_info.get(), nullptr,
+                                                  &GUID_DEVINTERFACE_USB_DEVICE,
+                                                  i, &device_interface_data);
+         ++i) {
+      std::string device_path;
+      uint32_t port_number;
+      std::string parent_instance_id;
+      if (!GetDeviceInterfaceDetails(dev_info.get(), &device_interface_data,
+                                     &device_path, &port_number,
+                                     &parent_instance_id)) {
+        continue;
+      }
+
+      std::string& hub_path = hub_paths_[parent_instance_id];
+      if (hub_path.empty()) {
+        std::string parent_path;
+        if (!GetHubDevicePath(parent_instance_id, &parent_path))
+          continue;
+
+        hub_path = parent_path;
+      }
+
+      task_runner_->PostTask(FROM_HERE,
+                             base::Bind(&UsbServiceWin::AddDevice, service_,
+                                        device_path, hub_path, port_number));
+    }
+
+    if (GetLastError() != ERROR_NO_MORE_ITEMS)
+      USB_PLOG(ERROR) << "Failed to enumerate devices";
+
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(&UsbServiceWin::HelperStarted, service_));
+  }
+
+  void EnumerateDevicePath(const std::string& device_path) {
+    ScopedDevInfo dev_info(
+        SetupDiGetClassDevs(&GUID_DEVINTERFACE_USB_DEVICE, nullptr, 0,
+                            DIGCF_DEVICEINTERFACE | DIGCF_PRESENT));
+    if (!dev_info.is_valid()) {
+      USB_PLOG(ERROR) << "Failed to set up device enumeration";
+      return;
+    }
+
+    SP_DEVICE_INTERFACE_DATA device_interface_data;
+    device_interface_data.cbSize = sizeof(device_interface_data);
+    if (!SetupDiOpenDeviceInterfaceA(dev_info.get(), device_path.c_str(), 0,
+                                     &device_interface_data)) {
+      USB_PLOG(ERROR) << "Failed to add device interface: " << device_path;
+      return;
+    }
+
+    uint32_t port_number;
+    std::string parent_instance_id;
+    if (!GetDeviceInterfaceDetails(dev_info.get(), &device_interface_data,
+                                   nullptr, &port_number,
+                                   &parent_instance_id)) {
+      return;
+    }
+
+    std::string& hub_path = hub_paths_[parent_instance_id];
+    if (hub_path.empty()) {
+      std::string parent_path;
+      if (!GetHubDevicePath(parent_instance_id, &parent_path))
+        return;
+
+      hub_path = parent_path;
+    }
+
+    task_runner_->PostTask(
+        FROM_HERE, base::Bind(&UsbServiceWin::AddDevice, service_, device_path,
+                              hub_path, port_number));
+  }
+
+ private:
+  std::unordered_map<std::string, std::string> hub_paths_;
+  // Calls back to |service_| must be posted to |task_runner_|, where it is
+  // okay to check the validity of this weak pointer.
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;

[scheib, 2017/02/14 19:40:05]

I'm still not quickly understanding the hop via task_runner and then
blocking_task_runner. Perhaps that could be explained some here. I'm assuming
task_runner is back on UI thread? Or is that wrong? --- ohh, late breaking, I
see that this class is calling DeviceAdded, not OnDeviceAdded. I need to go see
why/when OnDeviceAdded is called. Ah-ha ha it does bounce through from here to
there via DeviceMonitorWin. I didn't take the time to fully grok that.. I'll
trust you if it's needed. But.. yeah.. demonstrating complexity here - makes me
wonder if we can demonstrate simplicity? :)

[Reilly Grant (use Gerrit), 2017/02/15 22:03:13]

We discussed naming offline and I've made a number of changes that should make
the flow clearer.

+  base::WeakPtr<UsbServiceWin> service_;
+};
+
 UsbServiceWin::UsbServiceWin(
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner)
-    : UsbService(blocking_task_runner) {}
+    : UsbService(blocking_task_runner),
+      device_observer_(this),
+      weak_factory_(this) {
+  DeviceMonitorWin* device_monitor =
+      DeviceMonitorWin::GetForDeviceInterface(GUID_DEVINTERFACE_USB_DEVICE);
+  if (device_monitor)
+    device_observer_.Add(device_monitor);
+
+  helper_ = new FileThreadHelper(weak_factory_.GetWeakPtr());
+  blocking_task_runner->PostTask(FROM_HERE,
+                                 base::Bind(&FileThreadHelper::EnumerateDevices,
+                                            base::Unretained(helper_)));
+}
 
 UsbServiceWin::~UsbServiceWin() {}
 
+void UsbServiceWin::GetDevices(const GetDevicesCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  if (enumeration_ready())
+    UsbService::GetDevices(callback);
+  else
+    enumeration_callbacks_.push_back(callback);
+}
+
+void UsbServiceWin::OnDeviceAdded(const GUID& class_guid,
+                                  const std::string& device_path) {
+  blocking_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&FileThreadHelper::EnumerateDevicePath,
+                            base::Unretained(helper_), device_path));
+}
+
+void UsbServiceWin::OnDeviceRemoved(const GUID& class_guid,
+                                    const std::string& device_path) {
+  DCHECK(CalledOnValidThread());
+  auto by_path_it = devices_by_path_.find(device_path);
+  if (by_path_it == devices_by_path_.end())
+    return;
+
+  scoped_refptr<UsbDeviceWin> device = by_path_it->second;
+  devices_by_path_.erase(by_path_it);
+  device->OnDisconnect();
+
+  auto by_guid_it = devices().find(device->guid());
+  if (by_guid_it != devices().end() && enumeration_ready()) {
+    USB_LOG(USER) << "USB device removed: path=" << device->device_path()
+                  << " guid=" << device->guid();
+
+    devices().erase(by_guid_it);
+    NotifyDeviceRemoved(device);
+  }
+}
+
+void UsbServiceWin::HelperStarted() {
+  DCHECK(CalledOnValidThread());
+  helper_started_ = true;
+  if (enumeration_ready()) {
+    std::vector<scoped_refptr<UsbDevice>> result;
+    result.reserve(devices().size());
+    for (const auto& map_entry : devices())
+      result.push_back(map_entry.second);
+    for (const auto& callback : enumeration_callbacks_)
+      callback.Run(result);
+    enumeration_callbacks_.clear();
+  }
+}
+
+void UsbServiceWin::AddDevice(const std::string& device_path,
+                              const std::string& hub_path,
+                              int port_number) {
+  // Devices that appear during initial enumeration are gathered into the first
+  // result returned by GetDevices() and prevent device add/remove notifications
+  // from being sent.
+  if (!enumeration_ready())
+    ++first_enumeration_countdown_;
+
+  scoped_refptr<UsbDeviceWin> device(new UsbDeviceWin(
+      device_path, hub_path, port_number, blocking_task_runner()));
+  devices_by_path_[device->device_path()] = device;
+
+  // TODO(reillyg): Read device descriptors.
+  DeviceReady(device, true);
+}
+
+void UsbServiceWin::DeviceReady(scoped_refptr<UsbDeviceWin> device,
+                                bool success) {
+  DCHECK(CalledOnValidThread());
+
+  bool enumeration_became_ready = false;
+  if (!enumeration_ready()) {
+    DCHECK_GT(first_enumeration_countdown_, 0u);
+    first_enumeration_countdown_--;
+    if (enumeration_ready())
+      enumeration_became_ready = true;
+  }
+
+  // If |device| was disconnected while descriptors were being read then it
+  // will have been removed from |devices_by_path_|.
+  auto it = devices_by_path_.find(device->device_path());
+  if (it == devices_by_path_.end()) {
+    success = false;
+  } else if (success) {
+    DCHECK(!base::ContainsKey(devices(), device->guid()));
+    devices()[device->guid()] = device;
+
+    USB_LOG(USER) << "USB device added: path=" << device->device_path()
+                  << " vendor=" << device->vendor_id() << " \""
+                  << device->manufacturer_string()
+                  << "\", product=" << device->product_id() << " \""
+                  << device->product_string() << "\", serial=\""
+                  << device->serial_number() << "\", guid=" << device->guid();
+  } else {
+    devices_by_path_.erase(it);
+  }
+
+  if (enumeration_became_ready) {
+    std::vector<scoped_refptr<UsbDevice>> result;
+    result.reserve(devices().size());
+    for (const auto& map_entry : devices())
+      result.push_back(map_entry.second);
+    for (const auto& callback : enumeration_callbacks_)
+      callback.Run(result);
+    enumeration_callbacks_.clear();
+  } else if (success && enumeration_ready()) {
+    NotifyDeviceAdded(device);
+  }
+}
+
 }  // namespace device