Convert HidDeviceInfo from a struct to a refcounted class.

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 <set>
@@ skipping 109 matching lines @@
       if (collection_info.report_ids.size() > 0) {
         *has_report_id = true;
       }
       top_level_collections->push_back(collection_info);
     }
   }
 
   return true;
 }
 
-bool PopulateDeviceInfo(io_service_t service, HidDeviceInfo* device_info) {
-  io_string_t service_path;
-  IOReturn result =
-      IORegistryEntryGetPath(service, kIOServicePlane, service_path);
-  if (result != kIOReturnSuccess) {
-    VLOG(1) << "Failed to get IOService path: "
-            << base::StringPrintf("0x%04x", result);
-    return false;
-  }
-
-  base::ScopedCFTypeRef<IOHIDDeviceRef> hid_device(
-      IOHIDDeviceCreate(kCFAllocatorDefault, service));
-  if (!hid_device) {
-    VLOG(1) << "Unable to create IOHIDDevice object for " << service_path
-            << ".";
-    return false;
-  }
-
-  device_info->device_id = service_path;
-  device_info->vendor_id =
-      GetHidIntProperty(hid_device, CFSTR(kIOHIDVendorIDKey));
-  device_info->product_id =
-      GetHidIntProperty(hid_device, CFSTR(kIOHIDProductIDKey));
-  device_info->product_name =
-      GetHidStringProperty(hid_device, CFSTR(kIOHIDProductKey));
-  device_info->serial_number =
-      GetHidStringProperty(hid_device, CFSTR(kIOHIDSerialNumberKey));
-  if (!GetCollectionInfos(hid_device, &device_info->has_report_id,
-                          &device_info->collections)) {
-    VLOG(1) << "Unable to get collection info for " << service_path << ".";
-    return false;
-  }
-  device_info->max_input_report_size =
-      GetHidIntProperty(hid_device, CFSTR(kIOHIDMaxInputReportSizeKey));
-  if (device_info->has_report_id && device_info->max_input_report_size > 0) {
-    device_info->max_input_report_size--;
-  }
-  device_info->max_output_report_size =
-      GetHidIntProperty(hid_device, CFSTR(kIOHIDMaxOutputReportSizeKey));
-  if (device_info->has_report_id && device_info->max_output_report_size > 0) {
-    device_info->max_output_report_size--;
-  }
-  device_info->max_feature_report_size =
-      GetHidIntProperty(hid_device, CFSTR(kIOHIDMaxFeatureReportSizeKey));
-  if (device_info->has_report_id && device_info->max_feature_report_size > 0) {
-    device_info->max_feature_report_size--;
-  }
-
-  return true;
-}
-
 }  // namespace
 
 HidServiceMac::HidServiceMac(
     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner)
     : file_task_runner_(file_task_runner) {
   task_runner_ = base::ThreadTaskRunnerHandle::Get();
   DCHECK(task_runner_.get());
 
   notify_port_ = IONotificationPortCreate(kIOMasterPortDefault);
   CFRunLoopAddSource(CFRunLoopGetMain(),
@@ skipping 30 matching lines @@
                << base::StringPrintf("0x%04x", result);
     return;
   }
 
   // Drain devices_added_iterator_ to arm the notification.
   devices_removed_iterator_.reset(iterator);
   RemoveDevices();
   FirstEnumerationComplete();
 }
 
+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;
+
+  io_string_t service_path;
+  strncpy(service_path, device_id.c_str(), sizeof service_path);
+  base::mac::ScopedIOObject<io_service_t> service(
+      IORegistryEntryFromPath(kIOMasterPortDefault, service_path));
+  if (!service.get()) {
+    VLOG(1) << "IOService not found for path: " << device_id;
+    task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
+    return;
+  }
+
+  base::ScopedCFTypeRef<IOHIDDeviceRef> hid_device(
+      IOHIDDeviceCreate(kCFAllocatorDefault, service));
+  if (!hid_device) {
+    VLOG(1) << "Unable to create IOHIDDevice object.";
+    task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
+    return;
+  }
+
+  IOReturn result = IOHIDDeviceOpen(hid_device, kIOHIDOptionsTypeNone);
+  if (result != kIOReturnSuccess) {
+    VLOG(1) << "Failed to open device: " << base::StringPrintf("0x%04x",
+                                                               result);
+    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_))));
+}
+
 HidServiceMac::~HidServiceMac() {
 }
 
 // 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();
 }
 
 // static
 void HidServiceMac::TerminatedCallback(void* context, io_iterator_t iterator) {
   DCHECK_EQ(CFRunLoopGetMain(), CFRunLoopGetCurrent());
   HidServiceMac* service = static_cast<HidServiceMac*>(context);
   DCHECK_EQ(service->devices_removed_iterator_, iterator);
   service->RemoveDevices();
 }
 
 void HidServiceMac::AddDevices() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   io_service_t device;
   while ((device = IOIteratorNext(devices_added_iterator_)) != IO_OBJECT_NULL) {
-    HidDeviceInfo device_info;
-    if (PopulateDeviceInfo(device, &device_info)) {
+    scoped_refptr<HidDeviceInfo> device_info = CreateDeviceInfo(device);
+    if (device_info) {
       AddDevice(device_info);
+      // The reference retained by IOIteratorNext is released below in
+      // RemoveDevices when the device is removed.
+    } else {
+      IOObjectRelease(device);
     }
-    // The reference retained by IOIteratorNext is released below in
-    // RemoveDevices when the device is removed.
   }
 }
 
 void HidServiceMac::RemoveDevices() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   io_service_t device;
   while ((device = IOIteratorNext(devices_removed_iterator_)) !=
          IO_OBJECT_NULL) {
     io_string_t service_path;
     IOReturn result =
         IORegistryEntryGetPath(device, kIOServicePlane, service_path);
     if (result == kIOReturnSuccess) {
       RemoveDevice(service_path);
     }
 
     // Release reference retained by AddDevices above.
     IOObjectRelease(device);
     // Release the reference retained by IOIteratorNext.
     IOObjectRelease(device);
   }
 }
 
-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;
-  }
-  const HidDeviceInfo& device_info = map_entry->second;
-
+// static
+scoped_refptr<HidDeviceInfo> HidServiceMac::CreateDeviceInfo(
+    io_service_t service) {
+  scoped_refptr<HidDeviceInfo> device_info(new HidDeviceInfo());
   io_string_t service_path;
-  strncpy(service_path, device_id.c_str(), sizeof service_path);
-  base::mac::ScopedIOObject<io_service_t> service(
-      IORegistryEntryFromPath(kIOMasterPortDefault, service_path));
-  if (!service.get()) {
-    VLOG(1) << "IOService not found for path: " << device_id;
-    task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
-    return;
+  IOReturn result =
+      IORegistryEntryGetPath(service, kIOServicePlane, service_path);
+  if (result != kIOReturnSuccess) {
+    VLOG(1) << "Failed to get IOService path: " << base::StringPrintf("0x%04x",
+                                                                      result);
+    return nullptr;
   }
 
   base::ScopedCFTypeRef<IOHIDDeviceRef> hid_device(
       IOHIDDeviceCreate(kCFAllocatorDefault, service));
   if (!hid_device) {
-    VLOG(1) << "Unable to create IOHIDDevice object.";
-    task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
-    return;
+    VLOG(1) << "Unable to create IOHIDDevice object for " << service_path
+            << ".";
+    return nullptr;
   }
 
-  IOReturn result = IOHIDDeviceOpen(hid_device, kIOHIDOptionsTypeNone);
-  if (result != kIOReturnSuccess) {
-    VLOG(1) << "Failed to open device: "
-            << base::StringPrintf("0x%04x", result);
-    task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
-    return;
+  device_info->device_id_ = service_path;
+  device_info->vendor_id_ =
+      GetHidIntProperty(hid_device, CFSTR(kIOHIDVendorIDKey));
+  device_info->product_id_ =
+      GetHidIntProperty(hid_device, CFSTR(kIOHIDProductIDKey));
+  device_info->product_name_ =
+      GetHidStringProperty(hid_device, CFSTR(kIOHIDProductKey));
+  device_info->serial_number_ =
+      GetHidStringProperty(hid_device, CFSTR(kIOHIDSerialNumberKey));
+  if (!GetCollectionInfos(hid_device, &device_info->has_report_id_,
+                          &device_info->collections_)) {
+    VLOG(1) << "Unable to get collection info for " << service_path << ".";
+    return nullptr;
+  }
+  device_info->max_input_report_size_ =
+      GetHidIntProperty(hid_device, CFSTR(kIOHIDMaxInputReportSizeKey));
+  if (device_info->has_report_id() &&
+      device_info->max_input_report_size() > 0) {
+    device_info->max_input_report_size_--;
+  }
+  device_info->max_output_report_size_ =
+      GetHidIntProperty(hid_device, CFSTR(kIOHIDMaxOutputReportSizeKey));
+  if (device_info->has_report_id() &&
+      device_info->max_output_report_size_ > 0) {
+    device_info->max_output_report_size_--;
+  }
+  device_info->max_feature_report_size_ =
+      GetHidIntProperty(hid_device, CFSTR(kIOHIDMaxFeatureReportSizeKey));
+  if (device_info->has_report_id() &&
+      device_info->max_feature_report_size_ > 0) {
+    device_info->max_feature_report_size_--;
   }
 
-  task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(callback,
-                 make_scoped_refptr(new HidConnectionMac(
-                     hid_device.release(), device_info, file_task_runner_))));
+  return device_info;
 }
 
 }  // namespace device