Open HID connections asynchronously.

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"
 
 #include <cstdlib>
 
+#include "base/bind.h"
 #include "base/files/file.h"
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/sys_string_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "device/hid/hid_connection_win.h"
 #include "device/hid/hid_device_info.h"
 #include "net/base/io_buffer.h"
 
 #if defined(OS_WIN)
 
 #define INITGUID
 
 #include <setupapi.h>
 #include <winioctl.h>
 #include "base/win/scoped_handle.h"
 
 #endif  // defined(OS_WIN)
 
 // Setup API is required to enumerate HID devices.
 #pragma comment(lib, "setupapi.lib")
 #pragma comment(lib, "hid.lib")
 
 namespace device {
 namespace {
 
 const char kHIDClass[] = "HIDClass";
 
 }  // namespace
 
 HidServiceWin::HidServiceWin() {
   base::ThreadRestrictions::AssertIOAllowed();
+  task_runner_ = base::ThreadTaskRunnerHandle::Get();
+  DCHECK(task_runner_.get());
   Enumerate();
 }
 
 HidServiceWin::~HidServiceWin() {}
 
 void HidServiceWin::Enumerate() {
   BOOL res;
   HDEVINFO device_info_set;
   SP_DEVINFO_DATA devinfo_data;
   SP_DEVICE_INTERFACE_DATA device_interface_data;
@@ skipping 247 matching lines @@
 
 void HidServiceWin::PlatformRemoveDevice(const std::string& device_path) {
   RemoveDevice(device_path);
 }
 
 void HidServiceWin::GetDevices(std::vector<HidDeviceInfo>* devices) {
   Enumerate();
   HidService::GetDevices(devices);
 }
 
-scoped_refptr<HidConnection> HidServiceWin::Connect(
-    const HidDeviceId& device_id) {
-  HidDeviceInfo device_info;
-  if (!GetDeviceInfo(device_id, &device_info))
-    return NULL;
+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;
+  }
+  const HidDeviceInfo& device_info = map_entry->second;
+
   scoped_refptr<HidConnectionWin> connection(new HidConnectionWin(device_info));
   if (!connection->available()) {
-    PLOG(ERROR) << "Failed to open device.";
-    return NULL;
+    PLOG(ERROR) << "Failed to open device";
+    connection = nullptr;
   }
-  return connection;
+  task_runner_->PostTask(FROM_HERE, base::Bind(callback, connection));
 }
 
 }  // namespace device