Clean up HID backend and API.

chrome/browser/extensions/api/hid/hid_api.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 "chrome/browser/extensions/api/hid/hid_api.h"
 
 #include <string>
 #include <vector>
 
 #include "chrome/browser/extensions/api/api_resource_manager.h"
 #include "chrome/browser/extensions/api/hid/hid_device_resource.h"
 #include "chrome/common/extensions/api/hid.h"
 #include "chrome/common/extensions/permissions/usb_device_permission.h"
 #include "device/hid/hid_connection.h"
 #include "device/hid/hid_device_info.h"
 #include "device/hid/hid_service.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "net/base/io_buffer.h"
 
 namespace hid = extensions::api::hid;
 
 using device::HidConnection;
 using device::HidService;
 using device::HidDeviceInfo;
 
 namespace {
 
 const char kErrorPermissionDenied[] = "Permission to access device was denied.";
 const char kErrorServiceFailed[] = "HID service failed be created.";
-const char kErrorDeviceNotFound[] = "HID device not found.";
 const char kErrorFailedToOpenDevice[] = "Failed to open HID device.";
 const char kErrorConnectionNotFound[] = "Connection not established.";
 const char kErrorTransfer[] = "Transfer failed.";
 
 base::Value* PopulateHidDevice(const HidDeviceInfo& info) {
   hid::HidDeviceInfo device_info;
-  device_info.path = info.device_id;
+  device_info.device_id = info.device_id;
   device_info.product_id = info.product_id;
   device_info.vendor_id = info.vendor_id;
   return device_info.ToValue().release();
 }
 
 base::Value* PopulateHidConnection(int connection_id,
                                    scoped_refptr<HidConnection> connection) {
   hid::HidConnectInfo connection_value;
   connection_value.connection_id = connection_id;
   return connection_value.ToValue().release();
@@ skipping 81 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void HidConnectFunction::AsyncWorkStart() {
   HidService* service = HidService::GetInstance();
   if (!service) {
     CompleteWithError(kErrorServiceFailed);
     return;
   }
-  HidDeviceInfo device;
-  if (!service->GetInfo(parameters_->device_info.path, &device)) {
-    CompleteWithError(kErrorDeviceNotFound);
-    return;
-  }
-  if (device.vendor_id != parameters_->device_info.vendor_id ||
-      device.product_id != parameters_->device_info.product_id) {
-    CompleteWithError(kErrorDeviceNotFound);
-    return;
-  }
-  scoped_refptr<HidConnection> connection = service->Connect(device.device_id);
+  scoped_refptr<HidConnection> connection =
+      service->Connect(parameters_->device_id);
   if (!connection) {
     CompleteWithError(kErrorFailedToOpenDevice);
     return;
   }
   int connection_id =
       manager_->Add(new HidConnectionResource(extension_->id(), connection));
   SetResult(PopulateHidConnection(connection_id, connection));
   AsyncWorkCompleted();
 }
 
@@ skipping 31 matching lines @@
 
 void HidReceiveFunction::AsyncWorkStart() {
   int connection_id = parameters_->connection_id;
   HidConnectionResource* resource =
       manager_->Get(extension_->id(), connection_id);
   if (!resource) {
     CompleteWithError(kErrorConnectionNotFound);
     return;
   }
 
-  buffer_ = new net::IOBuffer(parameters_->size);
+  buffer_ = new net::IOBufferWithSize(parameters_->size);
   resource->connection()->Read(
       buffer_,
-      parameters_->size,
       base::Bind(&HidReceiveFunction::OnFinished, this));
 }
 
 void HidReceiveFunction::OnFinished(bool success, size_t bytes) {
   if (!success) {
     CompleteWithError(kErrorTransfer);
     return;
   }
 
   SetResult(base::BinaryValue::CreateWithCopiedBuffer(buffer_->data(), bytes));
@@ skipping 12 matching lines @@
 
 void HidSendFunction::AsyncWorkStart() {
   int connection_id = parameters_->connection_id;
   HidConnectionResource* resource =
       manager_->Get(extension_->id(), connection_id);
   if (!resource) {
     CompleteWithError(kErrorConnectionNotFound);
     return;
   }
 
-  scoped_refptr<net::IOBuffer> buffer(
-      new net::WrappedIOBuffer(parameters_->data.c_str()));
+  scoped_refptr<net::IOBufferWithSize> buffer(
+      new net::IOBufferWithSize(parameters_->data.size()));
   memcpy(buffer->data(),
          parameters_->data.c_str(),
          parameters_->data.size());
   resource->connection()->Write(
       buffer,
-      parameters_->data.size(),
       base::Bind(&HidSendFunction::OnFinished, this));
 }
 
 void HidSendFunction::OnFinished(bool success, size_t bytes) {
   if (!success) {
     CompleteWithError(kErrorTransfer);
     return;
   }
   AsyncWorkCompleted();
 }
 
 HidReceiveFeatureReportFunction::HidReceiveFeatureReportFunction() {}
 
 HidReceiveFeatureReportFunction::~HidReceiveFeatureReportFunction() {}
 
 bool HidReceiveFeatureReportFunction::Prepare() {
   parameters_ = hid::ReceiveFeatureReport::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void HidReceiveFeatureReportFunction::AsyncWorkStart() {
   int connection_id = parameters_->connection_id;
   HidConnectionResource* resource =
       manager_->Get(extension_->id(), connection_id);
   if (!resource) {
     CompleteWithError(kErrorConnectionNotFound);
     return;
   }
-  buffer_ = new net::IOBuffer(parameters_->size);
+  buffer_ = new net::IOBufferWithSize(parameters_->size);
   resource->connection()->GetFeatureReport(
       buffer_,
-      parameters_->size,
       base::Bind(&HidReceiveFeatureReportFunction::OnFinished, this));
 }
 
 void HidReceiveFeatureReportFunction::OnFinished(bool success, size_t bytes) {
   if (!success) {
     CompleteWithError(kErrorTransfer);
     return;
   }
 
   SetResult(base::BinaryValue::CreateWithCopiedBuffer(buffer_->data(), bytes));
@@ skipping 11 matching lines @@
 }
 
 void HidSendFeatureReportFunction::AsyncWorkStart() {
   int connection_id = parameters_->connection_id;
   HidConnectionResource* resource =
       manager_->Get(extension_->id(), connection_id);
   if (!resource) {
     CompleteWithError(kErrorConnectionNotFound);
     return;
   }
-  scoped_refptr<net::IOBuffer> buffer(
-      new net::WrappedIOBuffer(parameters_->data.c_str()));
+  scoped_refptr<net::IOBufferWithSize> buffer(
+      new net::IOBufferWithSize(parameters_->data.size()));
   resource->connection()->SendFeatureReport(
       buffer,
-      parameters_->data.size(),
       base::Bind(&HidSendFeatureReportFunction::OnFinished, this));
 }
 
 void HidSendFeatureReportFunction::OnFinished(bool success, size_t bytes) {
   if (!success) {
     CompleteWithError(kErrorTransfer);
     return;
   }
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions