Convert HidDeviceInfo from a struct to a refcounted class.

device/hid/hid_connection_mac.cc

 // Copyright (c) 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_connection_mac.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/mac/foundation_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "device/hid/hid_connection_mac.h"
 
 namespace device {
 
 HidConnectionMac::HidConnectionMac(
     IOHIDDeviceRef device,
-    HidDeviceInfo device_info,
+    scoped_refptr<HidDeviceInfo> device_info,
     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner)
     : HidConnection(device_info),
       device_(device, base::scoped_policy::RETAIN),
       file_task_runner_(file_task_runner) {
   task_runner_ = base::ThreadTaskRunnerHandle::Get();
   DCHECK(task_runner_.get());
 
   IOHIDDeviceScheduleWithRunLoop(
       device_.get(), CFRunLoopGetMain(), kCFRunLoopDefaultMode);
 
-  size_t expected_report_size = device_info.max_input_report_size;
-  if (device_info.has_report_id) {
+  size_t expected_report_size = device_info->max_input_report_size();
+  if (device_info->has_report_id()) {
     expected_report_size++;
   }
   inbound_buffer_.resize(expected_report_size);
 
   if (inbound_buffer_.size() > 0) {
     AddRef();  // Hold a reference to this while this callback is registered.
     IOHIDDeviceRegisterInputReportCallback(
         device_.get(),
         &inbound_buffer_[0],
         inbound_buffer_.size(),
@@ skipping 77 matching lines @@
                                            uint8_t* report_bytes,
                                            CFIndex report_length) {
   HidConnectionMac* connection = static_cast<HidConnectionMac*>(context);
   if (result != kIOReturnSuccess) {
     VLOG(1) << "Failed to read input report: "
             << base::StringPrintf("0x%08x", result);
     return;
   }
 
   scoped_refptr<net::IOBufferWithSize> buffer;
-  if (connection->device_info().has_report_id) {
+  if (connection->device_info()->has_report_id()) {
     // report_id is already contained in report_bytes
     buffer = new net::IOBufferWithSize(report_length);
     memcpy(buffer->data(), report_bytes, report_length);
   } else {
     buffer = new net::IOBufferWithSize(report_length + 1);
     buffer->data()[0] = 0;
     memcpy(buffer->data() + 1, report_bytes, report_length);
   }
 
   connection->ProcessInputReport(buffer);
@@ skipping 18 matching lines @@
     pending_reports_.pop();
     if (CompleteRead(report.buffer, report.size, read.callback)) {
       pending_reads_.pop();
     }
   }
 }
 
 void HidConnectionMac::GetFeatureReportAsync(uint8_t report_id,
                                              const ReadCallback& callback) {
   scoped_refptr<net::IOBufferWithSize> buffer(
-      new net::IOBufferWithSize(device_info().max_feature_report_size + 1));
+      new net::IOBufferWithSize(device_info()->max_feature_report_size() + 1));
   CFIndex report_size = buffer->size();
 
   // The IOHIDDevice object is shared with the UI thread and so this function
   // should probably be called there but it may block and the asynchronous
   // version is NOT IMPLEMENTED. I've examined the open source implementation
   // of this function and believe it is a simple enough wrapper around the
   // kernel API that this is safe.
   IOReturn result =
       IOHIDDeviceGetReport(device_.get(),
                            kIOHIDReportTypeFeature,
@@ skipping 49 matching lines @@
                                       this,
                                       base::Bind(callback, false)));
   }
 }
 
 void HidConnectionMac::ReturnAsyncResult(const base::Closure& callback) {
   callback.Run();
 }
 
 }  // namespace device