chrome.hid: enrich model with report IDs

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/mac/foundation_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/thread_restrictions.h"
 #include "device/hid/hid_connection_mac.h"
 
 namespace device {
 
 HidConnectionMac::HidConnectionMac(HidDeviceInfo device_info)
     : HidConnection(device_info),
       device_(device_info.device_id, base::scoped_policy::RETAIN) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   message_loop_ = base::MessageLoopProxy::current();
 
   DCHECK(device_.get());
-  inbound_buffer_.reset((uint8_t*)malloc(device_info.input_report_size));
+  inbound_buffer_.reset((uint8_t*)malloc(device_info.max_input_report_size));
   IOHIDDeviceRegisterInputReportCallback(device_.get(),
                                          inbound_buffer_.get(),
-                                         device_info.input_report_size,
+                                         device_info.max_input_report_size,
                                          &HidConnectionMac::InputReportCallback,
                                          this);
   IOHIDDeviceOpen(device_, kIOHIDOptionsTypeNone);
 }
 
 HidConnectionMac::~HidConnectionMac() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   while (!pending_reads_.empty()) {
     pending_reads_.front().callback.Run(false, 0);
@@ skipping 22 matching lines @@
                              const IOCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   WriteReport(kIOHIDReportTypeOutput, report_id, buffer, callback);
 }
 
 void HidConnectionMac::GetFeatureReport(
     uint8_t report_id,
     scoped_refptr<net::IOBufferWithSize> buffer,
     const IOCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (device_info().feature_report_size == 0) {
+  if (device_info().max_feature_report_size == 0) {
     callback.Run(false, 0);
     return;
   }
 
-  if (buffer->size() < device_info().feature_report_size) {
+  if (buffer->size() < device_info().max_feature_report_size) {
     callback.Run(false, 0);
     return;
   }
 
   uint8_t* feature_report_buffer = reinterpret_cast<uint8_t*>(buffer->data());
-  CFIndex feature_report_size = device_info().feature_report_size;
+  CFIndex max_feature_report_size = device_info().max_feature_report_size;
   IOReturn result = IOHIDDeviceGetReport(device_,
                                          kIOHIDReportTypeFeature,
                                          report_id,
                                          feature_report_buffer,
-                                         &feature_report_size);
+                                         &max_feature_report_size);
   if (result == kIOReturnSuccess)
-    callback.Run(true, feature_report_size);
+    callback.Run(true, max_feature_report_size);
   else
     callback.Run(false, 0);
 }
 
 void HidConnectionMac::SendFeatureReport(
     uint8_t report_id,
     scoped_refptr<net::IOBufferWithSize> buffer,
     const IOCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   WriteReport(kIOHIDReportTypeFeature, report_id, buffer, callback);
@@ skipping 69 matching lines @@
                            reinterpret_cast<uint8_t*>(output_buffer->data()),
                            output_buffer->size());
   if (res != kIOReturnSuccess) {
     callback.Run(false, 0);
   } else {
     callback.Run(true, output_buffer->size());
   }
 }
 
 }  // namespace device