Usb backend refactor step 2: Separate Usb Device Handle and Usb Device (deprecate)

chrome/browser/extensions/api/usb/usb_api.cc

 // Copyright (c) 2012 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/usb/usb_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 281 matching lines @@
       return "";
   }
 }
 
 static base::DictionaryValue* CreateTransferInfo(
     UsbTransferStatus status,
     scoped_refptr<net::IOBuffer> data,
     size_t length) {
   base::DictionaryValue* result = new base::DictionaryValue();
   result->SetInteger(kResultCodeKey, status);
-  result->Set(kDataKey, base::BinaryValue::CreateWithCopiedBuffer(data->data(),
-                                                                  length));
+  if (data) {
+    result->Set(
+        kDataKey,
+        base::BinaryValue::CreateWithCopiedBuffer(data->data(), length));
+  }
   return result;
 }
 
 static base::Value* PopulateDevice(int handle, int vendor_id, int product_id) {
   Device device;
   device.handle = handle;
   device.vendor_id = vendor_id;
   device.product_id = product_id;
   return device.ToValue().release();
 }
@@ skipping 77 matching lines @@
 }
 
 bool UsbAsyncApiTransferFunction::ConvertRecipientSafely(
     const Recipient& input, UsbDevice::TransferRecipient* output) {
   const bool converted = ConvertRecipient(input, output);
   if (!converted)
     SetError(kErrorConvertRecipient);
   return converted;
 }
 
-UsbFindDevicesFunction::UsbFindDevicesFunction() {}
+UsbFindDevicesFunction::UsbFindDevicesFunction() : service_(NULL) {}
 
 UsbFindDevicesFunction::~UsbFindDevicesFunction() {}
 
 void UsbFindDevicesFunction::SetDeviceForTest(UsbDevice* device) {
   device_for_test_ = device;
 }
 
 bool UsbFindDevicesFunction::Prepare() {
   parameters_ = FindDevices::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
+  if (device_for_test_) return true;
+  service_ = UsbServiceFactory::GetForProfile(profile());
+  if (!service_) {
+    LOG(ERROR) << "Could not get UsbService for active profile.";
+    return false;
+  }
   return true;
 }
 
 void UsbFindDevicesFunction::AsyncWorkStart() {
   result_.reset(new base::ListValue());
 
   if (device_for_test_) {
     UsbDeviceResource* const resource = new UsbDeviceResource(
         extension_->id(),
         device_for_test_);
 
-    Device device;
     result_->Append(PopulateDevice(manager_->Add(resource), 0, 0));
     SetResult(result_.release());
     AsyncWorkCompleted();
     return;
   }
 
   const uint16_t vendor_id = parameters_->options.vendor_id;
   const uint16_t product_id = parameters_->options.product_id;
   int interface_id = parameters_->options.interface_id.get() ?
       *parameters_->options.interface_id.get() :
       UsbDevicePermissionData::ANY_INTERFACE;
   UsbDevicePermission::CheckParam param(vendor_id, product_id, interface_id);
   if (!PermissionsData::CheckAPIPermissionWithParam(
           GetExtension(), APIPermission::kUsbDevice, &param)) {
     LOG(WARNING) << "Insufficient permissions to access device.";
     CompleteWithError(kErrorPermissionDenied);
     return;
   }
 
-  UsbService* const service = UsbServiceFactory::GetInstance()->GetForProfile(
-      profile());
-  if (!service) {
-    LOG(WARNING) << "Could not get UsbService for active profile.";
-    CompleteWithError(kErrorNoDevice);
-    return;
-  }
+  BrowserThread::PostTask(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UsbService::FindDevices,
+                 base::Unretained(service_),

[pfeldman, 2013/07/22 18:23:13]

service_ might have been deleted by now. You should make it RefCountedThreadSafe
(and wrap with another object for browsercontextgetter).

[Bei Zhang, 2013/07/23 17:58:44]

I will make it Singleton and it will never shows up in the PostTask. Also,
libusb_context is designed to have only one instance as well.

On 2013/07/22 18:23:13, pfeldman wrote:

+                 vendor_id,
+                 product_id,
+                 interface_id,
+                 &device_ids_,
+                 base::Bind(&UsbFindDevicesFunction::OpenDevices, this)));
+}
 
-  service->FindDevices(vendor_id, product_id, interface_id, &devices_,
-                       base::Bind(&UsbFindDevicesFunction::OnCompleted, this));
+void UsbFindDevicesFunction::OpenDevices() {
+  for (size_t i = 0; i < device_ids_.size(); ++i)
+    devices_.push_back(service_->OpenDevice(device_ids_[i]));
+
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&UsbFindDevicesFunction::OnCompleted, this));
 }
 
 void UsbFindDevicesFunction::OnCompleted() {
   for (size_t i = 0; i < devices_.size(); ++i) {
-    UsbDevice* const device = devices_[i].get();
+    scoped_refptr<UsbDevice> device = devices_[i];
     UsbDeviceResource* const resource =
         new UsbDeviceResource(extension_->id(), device);
 
-    Device js_device;
     result_->Append(PopulateDevice(manager_->Add(resource),
                                    parameters_->options.vendor_id,
                                    parameters_->options.product_id));
   }
 
   SetResult(result_.release());
   AsyncWorkCompleted();
 }
 
 UsbListInterfacesFunction::UsbListInterfacesFunction() {}
 
 UsbListInterfacesFunction::~UsbListInterfacesFunction() {}
 
 bool UsbListInterfacesFunction::Prepare() {
   parameters_ = ListInterfaces::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbListInterfacesFunction::AsyncWorkStart() {
   UsbDeviceResource* const resource = GetUsbDeviceResource(
       parameters_->device.handle);
   if (!resource) {
     CompleteWithError(kErrorNoDevice);
     return;
   }
 
   config_ = new UsbConfigDescriptor();
-  resource->device()->ListInterfaces(
-      config_.get(), base::Bind(&UsbListInterfacesFunction::OnCompleted, this));
+  resource->ListInterfaces(
+      config_.get(),
+      base::Bind(&UsbListInterfacesFunction::OnCompleted, this));
 }
 
 void UsbListInterfacesFunction::OnCompleted(bool success) {
   if (!success) {
     SetError(kErrorCannotListInterfaces);
     AsyncWorkCompleted();
     return;
   }
 
   result_.reset(new base::ListValue());
@@ skipping 102 matching lines @@
 }
 
 void UsbCloseDeviceFunction::AsyncWorkStart() {
   UsbDeviceResource* const resource = GetUsbDeviceResource(
       parameters_->device.handle);
   if (!resource) {
     CompleteWithError(kErrorNoDevice);
     return;
   }
 
-  resource->device()->Close(base::Bind(&UsbCloseDeviceFunction::OnCompleted,
-                                     this));
+  resource->Close(base::Bind(&UsbCloseDeviceFunction::OnCompleted, this));
   RemoveUsbDeviceResource(parameters_->device.handle);
 }
 
 void UsbCloseDeviceFunction::OnCompleted() {
   AsyncWorkCompleted();
 }
 
 UsbClaimInterfaceFunction::UsbClaimInterfaceFunction() {}
 
 UsbClaimInterfaceFunction::~UsbClaimInterfaceFunction() {}
 
 bool UsbClaimInterfaceFunction::Prepare() {
   parameters_ = ClaimInterface::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbClaimInterfaceFunction::AsyncWorkStart() {
   UsbDeviceResource* resource =
       GetUsbDeviceResource(parameters_->device.handle);
   if (!resource) {
     CompleteWithError(kErrorNoDevice);
     return;
   }
 
-  resource->device()->ClaimInterface(parameters_->interface_number,
+  resource->ClaimInterface(
+      parameters_->interface_number,
       base::Bind(&UsbClaimInterfaceFunction::OnCompleted, this));
 }
 
 void UsbClaimInterfaceFunction::OnCompleted(bool success) {
   if (!success)
     SetError(kErrorCannotClaimInterface);
   AsyncWorkCompleted();
 }
 
 UsbReleaseInterfaceFunction::UsbReleaseInterfaceFunction() {}
 
 UsbReleaseInterfaceFunction::~UsbReleaseInterfaceFunction() {}
 
 bool UsbReleaseInterfaceFunction::Prepare() {
   parameters_ = ReleaseInterface::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbReleaseInterfaceFunction::AsyncWorkStart() {
   UsbDeviceResource* resource =
       GetUsbDeviceResource(parameters_->device.handle);
   if (!resource) {
     CompleteWithError(kErrorNoDevice);
     return;
   }
 
-  resource->device()->ReleaseInterface(parameters_->interface_number,
+  resource->ReleaseInterface(
+      parameters_->interface_number,
       base::Bind(&UsbReleaseInterfaceFunction::OnCompleted, this));
 }
 
 void UsbReleaseInterfaceFunction::OnCompleted(bool success) {
   if (!success)
     SetError(kErrorCannotReleaseInterface);
   AsyncWorkCompleted();
 }
 
 UsbSetInterfaceAlternateSettingFunction::
     UsbSetInterfaceAlternateSettingFunction() {}
 
 UsbSetInterfaceAlternateSettingFunction::
     ~UsbSetInterfaceAlternateSettingFunction() {}
 
 bool UsbSetInterfaceAlternateSettingFunction::Prepare() {
   parameters_ = SetInterfaceAlternateSetting::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbSetInterfaceAlternateSettingFunction::AsyncWorkStart() {
   UsbDeviceResource* resource =
       GetUsbDeviceResource(parameters_->device.handle);
   if (!resource) {
     CompleteWithError(kErrorNoDevice);
     return;
   }
 
-  resource->device()->SetInterfaceAlternateSetting(
+  resource->SetInterfaceAlternateSetting(
       parameters_->interface_number,
       parameters_->alternate_setting,
       base::Bind(&UsbSetInterfaceAlternateSettingFunction::OnCompleted, this));
 }
 
 void UsbSetInterfaceAlternateSettingFunction::OnCompleted(bool success) {
   if (!success)
     SetError(kErrorCannotSetInterfaceAlternateSetting);
   AsyncWorkCompleted();
 }
@@ skipping 35 matching lines @@
     return;
   }
 
   scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(
       transfer, direction, size);
   if (!buffer.get()) {
     CompleteWithError(kErrorMalformedParameters);
     return;
   }
 
-  resource->device()->ControlTransfer(
+  resource->ControlTransfer(
       direction,
       request_type,
       recipient,
       transfer.request,
       transfer.value,
       transfer.index,
       buffer.get(),
       size,
       0,
       base::Bind(&UsbControlTransferFunction::OnCompleted, this));
@@ skipping 32 matching lines @@
     return;
   }
 
   scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(
       transfer, direction, size);
   if (!buffer.get()) {
     CompleteWithError(kErrorMalformedParameters);
     return;
   }
 
-  resource->device()
-      ->BulkTransfer(direction,
-                     transfer.endpoint,
-                     buffer.get(),
-                     size,
-                     0,
-                     base::Bind(&UsbBulkTransferFunction::OnCompleted, this));
+  resource->BulkTransfer(
+      direction,
+      transfer.endpoint,
+      buffer.get(),
+      size,
+      0,
+      base::Bind(&UsbBulkTransferFunction::OnCompleted, this));
 }
 
 UsbInterruptTransferFunction::UsbInterruptTransferFunction() {}
 
 UsbInterruptTransferFunction::~UsbInterruptTransferFunction() {}
 
 bool UsbInterruptTransferFunction::Prepare() {
   parameters_ = InterruptTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
@@ skipping 22 matching lines @@
     return;
   }
 
   scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(
       transfer, direction, size);
   if (!buffer.get()) {
     CompleteWithError(kErrorMalformedParameters);
     return;
   }
 
-  resource->device()->InterruptTransfer(
+  resource->InterruptTransfer(
       direction,
       transfer.endpoint,
       buffer.get(),
       size,
       0,
       base::Bind(&UsbInterruptTransferFunction::OnCompleted, this));
 }
 
 UsbIsochronousTransferFunction::UsbIsochronousTransferFunction() {}
 
@@ skipping 44 matching lines @@
     return;
   }
 
   scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(
       generic_transfer, direction, size);
   if (!buffer.get()) {
     CompleteWithError(kErrorMalformedParameters);
     return;
   }
 
-  resource->device()->IsochronousTransfer(
+  resource->IsochronousTransfer(
       direction,
       generic_transfer.endpoint,
       buffer.get(),
       size,
       packets,
       packet_length,
       0,
       base::Bind(&UsbIsochronousTransferFunction::OnCompleted, this));
 }
 
 UsbResetDeviceFunction::UsbResetDeviceFunction() {}
 
 UsbResetDeviceFunction::~UsbResetDeviceFunction() {}
 
 bool UsbResetDeviceFunction::Prepare() {
   parameters_ = ResetDevice::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbResetDeviceFunction::AsyncWorkStart() {
   UsbDeviceResource* const resource = GetUsbDeviceResource(
       parameters_->device.handle);
   if (!resource) {
     CompleteWithError(kErrorNoDevice);
     return;
   }
 
-  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-                          base::Bind(&UsbResetDeviceFunction::OnStartResest,
-                                     this, resource));
+  BrowserThread::PostTask(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UsbResetDeviceFunction::OnStartResest, this, resource));
 }
 
 void UsbResetDeviceFunction::OnStartResest(UsbDeviceResource* resource) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  resource->device()->ResetDevice(
+  resource->ResetDevice(
       base::Bind(&UsbResetDeviceFunction::OnCompletedFileThread, this));
 }
 
 void UsbResetDeviceFunction::OnCompletedFileThread(bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(&UsbResetDeviceFunction::OnCompleted,
-                                     this, success));
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&UsbResetDeviceFunction::OnCompleted, this, success));
   return;
 }
 
 void UsbResetDeviceFunction::OnCompleted(bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!success) {
     UsbDeviceResource* const resource = GetUsbDeviceResource(
         parameters_->device.handle);
     if (!resource) {
       CompleteWithError(kErrorNoDevice);
       return;
     }
     // Close the device now because the handle is invalid after an
     // unsuccessful reset.
-    resource->device()->Close(
-        base::Bind(&UsbResetDeviceFunction::OnError, this));
+    resource->Close(base::Bind(&UsbResetDeviceFunction::OnClosed, this));
     return;
   }
   SetResult(Value::CreateBooleanValue(true));
   AsyncWorkCompleted();
 }
 
+void UsbResetDeviceFunction::OnClosed() {
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&UsbResetDeviceFunction::OnError, this));
+}
+
 void UsbResetDeviceFunction::OnError() {
   RemoveUsbDeviceResource(parameters_->device.handle);
   SetError(kErrorResetDevice);
   SetResult(Value::CreateBooleanValue(false));
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions