Enumerate HID devices asynchronously on Windows.

device/hid/hid_service_win.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 "device/hid/hid_service_win.h"
 
 #define INITGUID
 
 #include <dbt.h>
 #include <setupapi.h>
@@ skipping 10 matching lines @@
 #include "device/hid/hid_connection_win.h"
 #include "device/hid/hid_device_info.h"
 #include "net/base/io_buffer.h"
 
 // Setup API is required to enumerate HID devices.
 #pragma comment(lib, "setupapi.lib")
 #pragma comment(lib, "hid.lib")
 
 namespace device {
 
-HidServiceWin::HidServiceWin() : device_observer_(this) {
+namespace {
+
+void Noop() {
+  // This function does nothing.
+}
+}
+
+HidServiceWin::HidServiceWin(
+    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner)
+    : device_observer_(this),
+      file_task_runner_(file_task_runner),
+      weak_factory_(this) {
   task_runner_ = base::ThreadTaskRunnerHandle::Get();
   DCHECK(task_runner_.get());
   DeviceMonitorWin* device_monitor =
       DeviceMonitorWin::GetForDeviceInterface(GUID_DEVINTERFACE_HID);
   if (device_monitor) {
     device_observer_.Add(device_monitor);
   }
-  DoInitialEnumeration();
+  file_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&HidServiceWin::InitialEnumerationFileThread,
+                            weak_factory_.GetWeakPtr(), task_runner_));
 }
 
 void HidServiceWin::Connect(const HidDeviceId& device_id,
                             const ConnectCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const auto& map_entry = devices().find(device_id);
   if (map_entry == devices().end()) {
     task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
     return;
   }
   scoped_refptr<HidDeviceInfo> device_info = map_entry->second;
 
   base::win::ScopedHandle file(OpenDevice(device_info->device_id()));
   if (!file.IsValid()) {
     PLOG(ERROR) << "Failed to open device";
     task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
     return;
   }
 
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(callback, new HidConnectionWin(device_info, file.Pass())));
 }
 
 HidServiceWin::~HidServiceWin() {
 }
 
-void HidServiceWin::DoInitialEnumeration() {
+// static
+void HidServiceWin::InitialEnumerationFileThread(
+    base::WeakPtr<HidServiceWin> service,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   HDEVINFO device_info_set =
       SetupDiGetClassDevs(&GUID_DEVINTERFACE_HID, NULL, NULL,
                           DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
 
   if (device_info_set != INVALID_HANDLE_VALUE) {
     SP_DEVICE_INTERFACE_DATA device_interface_data;
     device_interface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
 
     for (int device_index = 0;
          SetupDiEnumDeviceInterfaces(device_info_set,
@@ skipping 18 matching lines @@
       BOOL res = SetupDiGetDeviceInterfaceDetail(
           device_info_set, &device_interface_data,
           device_interface_detail_data.get(), required_size, NULL, NULL);
       if (!res) {
         continue;
       }
 
       std::string device_path(
           base::SysWideToUTF8(device_interface_detail_data->DevicePath));
       DCHECK(base::IsStringASCII(device_path));
-      OnDeviceAdded(base::StringToLowerASCII(device_path));
+      AddDeviceFileThread(service, task_runner,
+                          base::StringToLowerASCII(device_path));
     }
   }
 
-  FirstEnumerationComplete();
+  task_runner->PostTask(
+      FROM_HERE, base::Bind(&HidServiceWin::FirstEnumerationComplete, service));
 }
 
 // static
 void HidServiceWin::CollectInfoFromButtonCaps(
     PHIDP_PREPARSED_DATA preparsed_data,
     HIDP_REPORT_TYPE report_type,
     USHORT button_caps_length,
     HidCollectionInfo* collection_info) {
   if (button_caps_length > 0) {
     scoped_ptr<HIDP_BUTTON_CAPS[]> button_caps(
@@ skipping 27 matching lines @@
       for (size_t i = 0; i < value_caps_length; i++) {
         int report_id = value_caps[i].ReportID;
         if (report_id != 0) {
           collection_info->report_ids.insert(report_id);
         }
       }
     }
   }
 }
 
-void HidServiceWin::OnDeviceAdded(const std::string& device_path) {
+// static
+void HidServiceWin::AddDeviceFileThread(
+    base::WeakPtr<HidServiceWin> service,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+    const std::string& device_path) {
   base::win::ScopedHandle device_handle(OpenDevice(device_path));
   if (!device_handle.IsValid()) {
     return;
   }
 
   HIDD_ATTRIBUTES attrib = {0};
   attrib.Size = sizeof(HIDD_ATTRIBUTES);
   if (!HidD_GetAttributes(device_handle.Get(), &attrib)) {
     VLOG(1) << "Failed to get device attributes.";
     return;
@@ skipping 44 matching lines @@
                             &collection_info);
   CollectInfoFromValueCaps(preparsed_data, HidP_Input,
                            capabilities.NumberInputValueCaps, &collection_info);
   CollectInfoFromValueCaps(preparsed_data, HidP_Output,
                            capabilities.NumberOutputValueCaps,
                            &collection_info);
   CollectInfoFromValueCaps(preparsed_data, HidP_Feature,
                            capabilities.NumberFeatureValueCaps,
                            &collection_info);
 
+  // 1023 characters plus NULL terminator is more than enough for a USB string
+  // descriptor which is limited to 126 characters.
+  wchar_t buffer[1024];
+  std::string product_name;
+  if (HidD_GetProductString(device_handle.Get(), &buffer[0], sizeof(buffer))) {
+    // NULL termination guaranteed by the API.
+    product_name = base::SysWideToUTF8(buffer);
+  }
+  std::string serial_number;
+  if (HidD_GetSerialNumberString(device_handle.Get(), &buffer[0],
+                                 sizeof(buffer))) {
+    // NULL termination guaranteed by the API.
+    serial_number = base::SysWideToUTF8(buffer);
+  }
+
   // This populates the HidDeviceInfo instance without a raw report descriptor.
   // The descriptor is unavailable on Windows because HID devices are exposed to
   // user-space as individual top-level collections.
   scoped_refptr<HidDeviceInfo> device_info(new HidDeviceInfo(
-      device_path, attrib.VendorID, attrib.ProductID,
-      "",              // TODO(reillyg): Get product name from Windows.
-      "",              // TODO(reillyg): Get serial number from Windows.
+      device_path, attrib.VendorID, attrib.ProductID, product_name,
+      serial_number,
       kHIDBusTypeUSB,  // TODO(reillyg): Detect Bluetooth. crbug.com/443335
       collection_info, max_input_report_size, max_output_report_size,
       max_feature_report_size));
 
   HidD_FreePreparsedData(preparsed_data);
-  AddDevice(device_info);
+  task_runner->PostTask(
+      FROM_HERE, base::Bind(&HidServiceWin::AddDevice, service, device_info));
+}
+
+void HidServiceWin::OnDeviceAdded(const std::string& device_path) {
+  file_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&HidServiceWin::AddDeviceFileThread,
+                 weak_factory_.GetWeakPtr(), task_runner_, device_path));
 }
 
 void HidServiceWin::OnDeviceRemoved(const std::string& device_path) {
-  RemoveDevice(device_path);
+  // Execute a no-op closure on the file task runner to synchronize with any
+  // devices that are still being enumerated.
+  file_task_runner_->PostTaskAndReply(
+      FROM_HERE, base::Bind(&Noop),
+      base::Bind(&HidServiceWin::RemoveDevice, weak_factory_.GetWeakPtr(),
+                 device_path));
 }
 
+// static
 base::win::ScopedHandle HidServiceWin::OpenDevice(
     const std::string& device_path) {
   base::win::ScopedHandle file(
       CreateFileA(device_path.c_str(), GENERIC_WRITE | GENERIC_READ,
                   FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
                   FILE_FLAG_OVERLAPPED, NULL));
   if (!file.IsValid() &&
       GetLastError() == base::File::FILE_ERROR_ACCESS_DENIED) {
     file.Set(CreateFileA(device_path.c_str(), GENERIC_READ, FILE_SHARE_READ,
                          NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL));
   }
   return file.Pass();
 }
 
 }  // namespace device