Convert HidDeviceInfo from a struct to a refcounted class.

device/hid/hid_connection_linux.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_linux.h"
 
 #include <errno.h>
 #include <linux/hidraw.h>
 #include <sys/ioctl.h>
 
@@ skipping 14 matching lines @@
 #endif
 #ifndef HIDIOCGFEATURE
 #define HIDIOCGFEATURE(len) _IOC(_IOC_WRITE | _IOC_READ, 'H', 0x07, len)
 #endif
 
 namespace device {
 
 class HidConnectionLinux::Helper : public base::MessagePumpLibevent::Watcher {
  public:
   Helper(base::PlatformFile platform_file,
-         const HidDeviceInfo& device_info,
+         scoped_refptr<HidDeviceInfo> device_info,
          base::WeakPtr<HidConnectionLinux> connection,
          scoped_refptr<base::SingleThreadTaskRunner> task_runner)
       : platform_file_(platform_file),
         connection_(connection),
         task_runner_(task_runner) {
     // Report buffers must always have room for the report ID.
-    report_buffer_size_ = device_info.max_input_report_size + 1;
-    has_report_id_ = device_info.has_report_id;
+    report_buffer_size_ = device_info->max_input_report_size() + 1;
+    has_report_id_ = device_info->has_report_id();
   }
 
   ~Helper() override { DCHECK(thread_checker_.CalledOnValidThread()); }
 
   // Starts the FileDescriptorWatcher that reads input events from the device.
   // Must be called on a thread that has a base::MessageLoopForIO. The helper
   // object is owned by the thread where it was started.
   void Start() {
     base::ThreadRestrictions::AssertIOAllowed();
     thread_checker_.DetachFromThread();
@@ skipping 50 matching lines @@
   base::ThreadChecker thread_checker_;
   base::PlatformFile platform_file_;
   size_t report_buffer_size_;
   bool has_report_id_;
   base::WeakPtr<HidConnectionLinux> connection_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   base::MessagePumpLibevent::FileDescriptorWatcher file_watcher_;
 };
 
 HidConnectionLinux::HidConnectionLinux(
-    const HidDeviceInfo& device_info,
+    scoped_refptr<HidDeviceInfo> device_info,
     base::File device_file,
     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner)
     : HidConnection(device_info),
       file_task_runner_(file_task_runner),
       weak_factory_(this) {
   task_runner_ = base::ThreadTaskRunnerHandle::Get();
   device_file_ = device_file.Pass();
 
   // The helper is passed a weak pointer to this connection so that it can be
   // cleaned up after the connection is closed.
@@ skipping 43 matching lines @@
                  base::Bind(&HidConnectionLinux::FinishWrite,
                             weak_factory_.GetWeakPtr(), size, callback),
                  task_runner_));
 }
 
 void HidConnectionLinux::PlatformGetFeatureReport(
     uint8_t report_id,
     const ReadCallback& callback) {
   // The first byte of the destination buffer is the report ID being requested
   // and is overwritten by the feature report.
-  DCHECK_GT(device_info().max_feature_report_size, 0u);
+  DCHECK_GT(device_info()->max_feature_report_size(), 0u);
   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));
   buffer->data()[0] = report_id;
 
   file_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &HidConnectionLinux::BlockingIoctl, device_file_.GetPlatformFile(),
           HIDIOCGFEATURE(buffer->size()), buffer,
           base::Bind(&HidConnectionLinux::FinishGetFeatureReport,
                      weak_factory_.GetWeakPtr(), report_id, buffer, callback),
           task_runner_));
@@ skipping 106 matching lines @@
     PendingHidReport report = pending_reports_.front();
 
     pending_reports_.pop();
     if (CompleteRead(report.buffer, report.size, read.callback)) {
       pending_reads_.pop();
     }
   }
 }
 
 }  // namespace device