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

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

Index: chrome/browser/extensions/api/usb/usb_device_resource.cc
diff --git a/chrome/browser/extensions/api/usb/usb_device_resource.cc b/chrome/browser/extensions/api/usb/usb_device_resource.cc
index 4d8aa953343e36cf10739eb27833f0ce8113ea6f..9a518c897a0bbf27d9ce72f7c25e3f20849e92be 100644
--- a/chrome/browser/extensions/api/usb/usb_device_resource.cc
+++ b/chrome/browser/extensions/api/usb/usb_device_resource.cc
@@ -13,9 +13,16 @@
 #include "chrome/browser/extensions/api/api_resource.h"
 #include "chrome/browser/usb/usb_device.h"
 #include "chrome/common/extensions/api/usb.h"
+#include "content/public/browser/browser_thread.h"
 
 namespace extensions {
 
+namespace {
+
+void EmptyCallback(void) {}
+
+}
+
 static base::LazyInstance<ProfileKeyedAPIFactory<
         ApiResourceManager<UsbDeviceResource> > >
             g_factory = LAZY_INSTANCE_INITIALIZER;
@@ -31,6 +38,172 @@ UsbDeviceResource::UsbDeviceResource(const std::string& owner_extension_id,
                                      scoped_refptr<UsbDevice> device)
     : ApiResource(owner_extension_id), device_(device) {}
 
-UsbDeviceResource::~UsbDeviceResource() {}
+UsbDeviceResource::~UsbDeviceResource() {
+  Close(base::Bind(EmptyCallback));
+}
+
+void UsbDeviceResource::Close(const base::Callback<void()>& callback) {
+  scoped_refptr<UsbDevice> handle;
+  handle.swap(device_);
+  if (!handle.get()) {
+    callback.Run();
+    return;
+  }
+  content::BrowserThread::PostTask(
+      content::BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UsbDevice::Close, handle, callback));
+}
+
+void UsbDeviceResource::ListInterfaces(UsbConfigDescriptor* config,

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

Unfortunately, all your clients would need to have wrappers like this. It would
be great if longer term, your UsbDevice would allow operation on any thread
while doing things on FILE under the hood.

+                                       const UsbInterfaceCallback& callback) {
+  if (!device_.get()) {
+    callback.Run(false);
+    return;
+  }
+  content::BrowserThread::PostTask(
+      content::BrowserThread::FILE, FROM_HERE,
+      base::Bind(&UsbDevice::ListInterfaces,
+                 device_,
+                 make_scoped_refptr(config),
+                 callback));
+}
+
+void UsbDeviceResource::ClaimInterface(const int interface_number,
+                                       const UsbInterfaceCallback& callback) {
+  if (!device_.get()) {
+    callback.Run(false);
+    return;
+  }
+  content::BrowserThread::PostTask(
+      content::BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UsbDevice::ClaimInterface,
+                 device_,
+                 interface_number,
+                 callback));
+}
+
+void UsbDeviceResource::ReleaseInterface(const int interface_number,
+                                         const UsbInterfaceCallback& callback) {
+  if (!device_.get()) {
+    callback.Run(false);
+    return;
+  }
+  content::BrowserThread::PostTask(
+      content::BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UsbDevice::ReleaseInterface,
+                 device_,
+                 interface_number,
+                 callback));
+}
+
+void UsbDeviceResource::SetInterfaceAlternateSetting(
+    const int interface_number,
+    const int alternate_setting,
+    const UsbInterfaceCallback& callback) {
+  if (!device_.get()) {
+    callback.Run(false);
+    return;
+  }
+  content::BrowserThread::PostTask(
+      content::BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UsbDevice::SetInterfaceAlternateSetting,
+                 device_,
+                 interface_number,
+                 alternate_setting,
+                 callback));
+}
+
+void UsbDeviceResource::ControlTransfer(
+    const UsbEndpointDirection direction,
+    const UsbDevice::TransferRequestType request_type,
+    const UsbDevice::TransferRecipient recipient,
+    const uint8 request,
+    const uint16 value,
+    const uint16 index,
+    net::IOBuffer* buffer,
+    const size_t length,
+    const unsigned int timeout,
+    const UsbTransferCallback& callback) {
+  if (!device_.get()) {
+    callback.Run(USB_TRANSFER_DISCONNECT, buffer, 0);
+    return;
+  }
+  device_->ControlTransfer(direction,
+                           request_type,
+                           recipient,
+                           request,
+                           value,
+                           index,
+                           buffer,
+                           length,
+                           timeout,
+                           callback);
+}
+
+void UsbDeviceResource::BulkTransfer(const UsbEndpointDirection direction,
+                                     const uint8 endpoint,
+                                     net::IOBuffer* buffer,
+                                     const size_t length,
+                                     const unsigned int timeout,
+                                     const UsbTransferCallback& callback) {
+  if (!device_.get()) {
+    callback.Run(USB_TRANSFER_DISCONNECT, buffer, 0);
+    return;
+  }
+  device_->BulkTransfer(direction, endpoint, buffer, length, timeout, callback);
+}
+
+void UsbDeviceResource::InterruptTransfer(const UsbEndpointDirection direction,
+                                          const uint8 endpoint,
+                                          net::IOBuffer* buffer,
+                                          const size_t length,
+                                          const unsigned int timeout,
+                                          const UsbTransferCallback& callback) {
+  if (!device_.get()) {
+    callback.Run(USB_TRANSFER_DISCONNECT, buffer, 0);
+    return;
+  }
+  device_->InterruptTransfer(direction, endpoint, buffer, length, timeout,
+                             callback);
+}
+
+void UsbDeviceResource::IsochronousTransfer(
+    const UsbEndpointDirection direction,
+    const uint8 endpoint,
+    net::IOBuffer* buffer,
+    const size_t length,
+    const unsigned int packets,
+    const unsigned int packet_length,
+    const unsigned int timeout,
+    const UsbTransferCallback& callback) {
+  if (!device_.get()) {
+    callback.Run(USB_TRANSFER_DISCONNECT, buffer, 0);
+    return;
+  }
+  device_->IsochronousTransfer(direction,
+                               endpoint,
+                               buffer,
+                               length,
+                               packets,
+                               packet_length,
+                               timeout,
+                               callback);
+}
+
+void UsbDeviceResource::ResetDevice(const UsbResetDeviceCallback& callback) {
+  if (!device_.get()) {
+    callback.Run(false);
+    return;
+  }
+  content::BrowserThread::PostTask(
+      content::BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UsbDevice::ResetDevice, device_, callback));
+}
+
 
 }  // namespace extensions