Open IOHIDDevices on the FILE thread

device/hid/hid_service_mac.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_mac.h"
 
 #include <CoreFoundation/CoreFoundation.h>
-#include <IOKit/hid/IOHIDDevice.h>
 #include <stdint.h>
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/mac/foundation_util.h"
@@ skipping 58 matching lines @@
   base::STLClearObject(result);
   const uint8_t* bytes = CFDataGetBytePtr(ref);
   result->insert(result->begin(), bytes, bytes + CFDataGetLength(ref));
   return true;
 }
 
 }  // namespace
 
 HidServiceMac::HidServiceMac(
     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner)
-    : file_task_runner_(file_task_runner) {
+    : file_task_runner_(file_task_runner), weak_factory_(this) {
   task_runner_ = base::ThreadTaskRunnerHandle::Get();
   DCHECK(task_runner_.get());
 
   notify_port_.reset(IONotificationPortCreate(kIOMasterPortDefault));
   CFRunLoopAddSource(CFRunLoopGetMain(),
                      IONotificationPortGetRunLoopSource(notify_port_.get()),
                      kCFRunLoopDefaultMode);
 
   IOReturn result = IOServiceAddMatchingNotification(
       notify_port_.get(), kIOFirstMatchNotification,
@@ skipping 27 matching lines @@
 
 void HidServiceMac::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::ScopedCFTypeRef<CFDictionaryRef> matching_dict(
-      IORegistryEntryIDMatching(device_id));
-  if (!matching_dict.get()) {
-    HID_LOG(EVENT) << "Failed to create matching dictionary for ID: "
-                   << device_id;
-    task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
-    return;
-  }
 
+  file_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&HidServiceMac::OpenOnBlockingThread, map_entry->second,
+                 task_runner_, weak_factory_.GetWeakPtr(), callback));
+}
+
+// static
+void HidServiceMac::OpenOnBlockingThread(
+    scoped_refptr<HidDeviceInfo> device_info,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+    base::WeakPtr<HidServiceMac> hid_service,
+    const ConnectCallback& callback) {
+  base::ScopedCFTypeRef<CFDictionaryRef> matching_dict(
+      IORegistryEntryIDMatching(device_info->device_id()));
+  if (!matching_dict.get()) {
+    HID_LOG(EVENT) << "Failed to create matching dictionary for ID: "
+                   << device_info->device_id();
+    task_runner->PostTask(FROM_HERE, base::Bind(callback, nullptr));
+    return;
+  }
+
   // IOServiceGetMatchingService consumes a reference to the matching dictionary
   // passed to it.
   base::mac::ScopedIOObject<io_service_t> service(IOServiceGetMatchingService(
       kIOMasterPortDefault, matching_dict.release()));
   if (!service.get()) {
-    HID_LOG(EVENT) << "IOService not found for ID: " << device_id;
-    task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
+    HID_LOG(EVENT) << "IOService not found for ID: "
+                   << device_info->device_id();
+    task_runner->PostTask(FROM_HERE, base::Bind(callback, nullptr));
     return;
   }
 
   base::ScopedCFTypeRef<IOHIDDeviceRef> hid_device(
       IOHIDDeviceCreate(kCFAllocatorDefault, service));
   if (!hid_device) {
     HID_LOG(EVENT) << "Unable to create IOHIDDevice object.";
-    task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
+    task_runner->PostTask(FROM_HERE, base::Bind(callback, nullptr));
     return;
   }
 
   IOReturn result = IOHIDDeviceOpen(hid_device, kIOHIDOptionsTypeNone);
   if (result != kIOReturnSuccess) {
     HID_LOG(EVENT) << "Failed to open device: " << HexErrorCode(result);
-    task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
+    task_runner->PostTask(FROM_HERE, base::Bind(callback, nullptr));
     return;
   }
 
-  task_runner_->PostTask(
-      FROM_HERE, base::Bind(callback, make_scoped_refptr(new HidConnectionMac(
-                                          hid_device.release(), device_info,
-                                          file_task_runner_))));
+  task_runner->PostTask(
+      FROM_HERE, base::Bind(&HidServiceMac::DeviceOpened, hid_service,
+                            device_info, base::Passed(&hid_device), callback));
+}
+
+void HidServiceMac::DeviceOpened(
+    scoped_refptr<HidDeviceInfo> device_info,
+    base::ScopedCFTypeRef<IOHIDDeviceRef> hid_device,
+    const ConnectCallback& callback) {
+  callback.Run(make_scoped_refptr(new HidConnectionMac(
+      std::move(hid_device), std::move(device_info), file_task_runner_)));
 }
 
 // static
 void HidServiceMac::FirstMatchCallback(void* context, io_iterator_t iterator) {
   DCHECK_EQ(CFRunLoopGetMain(), CFRunLoopGetCurrent());
   HidServiceMac* service = static_cast<HidServiceMac*>(context);
   DCHECK_EQ(service->devices_added_iterator_, iterator);
   service->AddDevices();
 }
 
@@ skipping 67 matching lines @@
   return new HidDeviceInfo(
       entry_id, GetHidIntProperty(hid_device, CFSTR(kIOHIDVendorIDKey)),
       GetHidIntProperty(hid_device, CFSTR(kIOHIDProductIDKey)),
       GetHidStringProperty(hid_device, CFSTR(kIOHIDProductKey)),
       GetHidStringProperty(hid_device, CFSTR(kIOHIDSerialNumberKey)),
       kHIDBusTypeUSB,  // TODO(reillyg): Detect Bluetooth. crbug.com/443335
       report_descriptor);
 }
 
 }  // namespace device