Convert HidDeviceInfo from a struct to a refcounted class.

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"
 
 #define INITGUID
 
 #include <dbt.h>
 #include <setupapi.h>
@@ skipping 29 matching lines @@
 }
 
 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<HidDeviceInfo> device_info = map_entry->second;
 
-  base::win::ScopedHandle file(OpenDevice(device_info.device_id));
+  base::win::ScopedHandle file(OpenDevice(device_info->device_id()));
   if (!file.IsValid()) {
     PLOG(ERROR) << "Failed to open device";
     task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
     return;
   }
 
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(callback, new HidConnectionWin(device_info, file.Pass())));
 }
@@ skipping 86 matching lines @@
         int report_id = value_caps[i].ReportID;
         if (report_id != 0) {
           collection_info->report_ids.insert(report_id);
         }
       }
     }
   }
 }
 
 void HidServiceWin::OnDeviceAdded(const std::string& device_path) {
-  HidDeviceInfo device_info;
-  device_info.device_id = device_path;
-
   // Try to open the device.
   base::win::ScopedHandle device_handle(OpenDevice(device_path));
   if (!device_handle.IsValid()) {
     return;
   }
 
   // Get VID/PID pair.
   HIDD_ATTRIBUTES attrib = {0};
   attrib.Size = sizeof(HIDD_ATTRIBUTES);
   if (!HidD_GetAttributes(device_handle.Get(), &attrib)) {
     return;
   }
 
-  device_info.vendor_id = attrib.VendorID;
-  device_info.product_id = attrib.ProductID;
+  scoped_refptr<HidDeviceInfo> device_info(new HidDeviceInfo());
+  device_info->device_id_ = device_path;
+  device_info->vendor_id_ = attrib.VendorID;
+  device_info->product_id_ = attrib.ProductID;
 
   // Get usage and usage page (optional).
   PHIDP_PREPARSED_DATA preparsed_data;
   if (HidD_GetPreparsedData(device_handle.Get(), &preparsed_data) &&
       preparsed_data) {
     HIDP_CAPS capabilities = {0};
     if (HidP_GetCaps(preparsed_data, &capabilities) == HIDP_STATUS_SUCCESS) {
-      device_info.max_input_report_size = capabilities.InputReportByteLength;
-      device_info.max_output_report_size = capabilities.OutputReportByteLength;
-      device_info.max_feature_report_size =
+      device_info->max_input_report_size_ = capabilities.InputReportByteLength;
+      device_info->max_output_report_size_ =
+          capabilities.OutputReportByteLength;
+      device_info->max_feature_report_size_ =
           capabilities.FeatureReportByteLength;
       HidCollectionInfo collection_info;
       collection_info.usage = HidUsageAndPage(
           capabilities.Usage,
           static_cast<HidUsageAndPage::Page>(capabilities.UsagePage));
       CollectInfoFromButtonCaps(preparsed_data,
                                 HidP_Input,
                                 capabilities.NumberInputButtonCaps,
                                 &collection_info);
       CollectInfoFromButtonCaps(preparsed_data,
@@ skipping 10 matching lines @@
                                &collection_info);
       CollectInfoFromValueCaps(preparsed_data,
                                HidP_Output,
                                capabilities.NumberOutputValueCaps,
                                &collection_info);
       CollectInfoFromValueCaps(preparsed_data,
                                HidP_Feature,
                                capabilities.NumberFeatureValueCaps,
                                &collection_info);
       if (!collection_info.report_ids.empty()) {
-        device_info.has_report_id = true;
+        device_info->has_report_id_ = true;
       }
-      device_info.collections.push_back(collection_info);
+      device_info->collections_.push_back(collection_info);
     }
     // Whether or not the device includes report IDs in its reports the size
     // of the report ID is included in the value provided by Windows. This
     // appears contrary to the MSDN documentation.
-    if (device_info.max_input_report_size > 0) {
-      device_info.max_input_report_size--;
+    if (device_info->max_input_report_size() > 0) {
+      device_info->max_input_report_size_--;
     }
-    if (device_info.max_output_report_size > 0) {
-      device_info.max_output_report_size--;
+    if (device_info->max_output_report_size() > 0) {
+      device_info->max_output_report_size_--;
     }
-    if (device_info.max_feature_report_size > 0) {
-      device_info.max_feature_report_size--;
+    if (device_info->max_feature_report_size() > 0) {
+      device_info->max_feature_report_size_--;
     }
     HidD_FreePreparsedData(preparsed_data);
   }
 
   AddDevice(device_info);
 }
 
 void HidServiceWin::OnDeviceRemoved(const std::string& device_path) {
   RemoveDevice(device_path);
 }
 
 base::win::ScopedHandle HidServiceWin::OpenDevice(
     const std::string& device_path) {
   base::win::ScopedHandle file(
       CreateFileA(device_path.c_str(), GENERIC_WRITE | GENERIC_READ,
                   FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
                   FILE_FLAG_OVERLAPPED, NULL));
   if (!file.IsValid() &&
       GetLastError() == base::File::FILE_ERROR_ACCESS_DENIED) {
     file.Set(CreateFileA(device_path.c_str(), GENERIC_READ, FILE_SHARE_READ,
                          NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL));
   }
   return file.Pass();
 }
 
 }  // namespace device