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,
+                                       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