They will be restricted to FILE thread. No need for callback.

Review URL: https://chromiumcodereview.appspot.com/19981004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@213314 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 94 insertions, 121 deletions

diff --git a/chrome/browser/devtools/adb/android_usb_device.cc b/chrome/browser/devtools/adb/android_usb_device.cc
index 4fd1390..9408328 100644
--- a/chrome/browser/devtools/adb/android_usb_device.cc
+++ b/chrome/browser/devtools/adb/android_usb_device.cc
@@ -22,9 +22,6 @@
 
 namespace {
 
-void Noop() {}
-void BoolNoop(bool success) {}
-
 const size_t kHeaderSize = 24;
 
 const int kAdbClass = 0xff;
@@ -93,23 +90,6 @@ static std::string ReadSerialNumSync(libusb_device_handle* handle) {
   return std::string();
 }
 
-static void InterfaceClaimed(crypto::RSAPrivateKey* rsa_key,
-                             scoped_refptr<UsbDeviceHandle> usb_device,
-                             int inbound_address,
-                             int outbound_address,
-                             int zero_mask,
-                             AndroidUsbDevices* devices,
-                             bool success) {
-  if (!success)
-    return;
-
-  std::string serial = ReadSerialNumSync(usb_device->handle());
-  scoped_refptr<AndroidUsbDevice> device =
-      new AndroidUsbDevice(rsa_key, usb_device, serial, inbound_address,
-                           outbound_address, zero_mask);
-  devices->push_back(device);
-}
-
 static void ClaimInterface(
     crypto::RSAPrivateKey* rsa_key,
     scoped_refptr<UsbDeviceHandle> usb_device,
@@ -147,24 +127,14 @@ static void ClaimInterface(
   if (inbound_address == 0 || outbound_address == 0)
     return;
 
-  usb_device->ClaimInterface(1, base::Bind(&InterfaceClaimed,
-                                           rsa_key, usb_device,
-                                           inbound_address, outbound_address,
-                                           zero_mask, devices));
-}
-
-static void InterfacesListed(
-    crypto::RSAPrivateKey* rsa_key,
-    scoped_refptr<UsbDeviceHandle> usb_device,
-    scoped_refptr<UsbConfigDescriptor> config,
-    AndroidUsbDevices* devices,
-    bool success) {
-  if (!success)
+  if (!usb_device->ClaimInterface(1))
     return;
-  for (size_t j = 0; j < config->GetNumInterfaces(); ++j) {
-    ClaimInterface(rsa_key, usb_device, config->GetInterface(j),
-                   devices);
-  }
+
+  std::string serial = ReadSerialNumSync(usb_device->handle());
+  scoped_refptr<AndroidUsbDevice> device =
+      new AndroidUsbDevice(rsa_key, usb_device, serial, inbound_address,
+                           outbound_address, zero_mask);
+  devices->push_back(device);
 }
 
 static uint32 Checksum(const std::string& data) {
@@ -257,10 +227,13 @@ void AndroidUsbDevice::Enumerate(Profile* profile,
     if (claimed_devices.find(usb_device.get()) != claimed_devices.end())
       continue;
     scoped_refptr<UsbConfigDescriptor> config = new UsbConfigDescriptor();
-    usb_device->ListInterfaces(config.get(),
-                               base::Bind(&InterfacesListed, rsa_key,
-                                          usb_device, config,
-                                          &g_devices.Get()));
+    bool success = usb_device->ListInterfaces(config.get());
+    if (!success)
+      continue;
+    for (size_t j = 0; j < config->GetNumInterfaces(); ++j) {
+      ClaimInterface(rsa_key, usb_device, config->GetInterface(j),
+                     &g_devices.Get());
+    }
   }
   callback.Run(g_devices.Get());
 }
@@ -533,8 +506,8 @@ void AndroidUsbDevice::Terminate() {
     it->second->Terminated();
   }
 
-  usb_device_->ReleaseInterface(1, base::Bind(&BoolNoop));
-  usb_device_->Close(base::Bind(&Noop));
+  usb_device_->ReleaseInterface(1);
+  usb_device_->Close();
 }
 
 void AndroidUsbDevice::SocketDeleted(uint32 socket_id) {
diff --git a/chrome/browser/extensions/api/usb/usb_api.cc b/chrome/browser/extensions/api/usb/usb_api.cc
index 7dc90e6..5b123ad 100644
--- a/chrome/browser/extensions/api/usb/usb_api.cc
+++ b/chrome/browser/extensions/api/usb/usb_api.cc
@@ -488,8 +488,13 @@ void UsbListInterfacesFunction::AsyncWorkStart() {
   }
 
   config_ = new UsbConfigDescriptor();
-  resource->device()->ListInterfaces(
-      config_.get(), base::Bind(&UsbListInterfacesFunction::OnCompleted, this));
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UsbDeviceHandle::ListInterfaces,
+                 resource->device(),
+                 config_),
+      base::Bind(&UsbListInterfacesFunction::OnCompleted, this));
 }
 
 void UsbListInterfacesFunction::OnCompleted(bool success) {
@@ -612,8 +617,11 @@ void UsbCloseDeviceFunction::AsyncWorkStart() {
     return;
   }
 
-  resource->device()->Close(base::Bind(&UsbCloseDeviceFunction::OnCompleted,
-                                     this));
+  BrowserThread::PostTaskAndReply(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UsbDeviceHandle::Close, resource->device()),
+      base::Bind(&UsbCloseDeviceFunction::OnCompleted, this));
   RemoveUsbDeviceResource(parameters_->device.handle);
 }
 
@@ -639,7 +647,12 @@ void UsbClaimInterfaceFunction::AsyncWorkStart() {
     return;
   }
 
-  resource->device()->ClaimInterface(parameters_->interface_number,
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UsbDeviceHandle::ClaimInterface,
+                 resource->device(),
+                 parameters_->interface_number),
       base::Bind(&UsbClaimInterfaceFunction::OnCompleted, this));
 }
 
@@ -667,7 +680,12 @@ void UsbReleaseInterfaceFunction::AsyncWorkStart() {
     return;
   }
 
-  resource->device()->ReleaseInterface(parameters_->interface_number,
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UsbDeviceHandle::ReleaseInterface,
+                 resource->device(),
+                 parameters_->interface_number),
       base::Bind(&UsbReleaseInterfaceFunction::OnCompleted, this));
 }
 
@@ -697,9 +715,13 @@ void UsbSetInterfaceAlternateSettingFunction::AsyncWorkStart() {
     return;
   }
 
-  resource->device()->SetInterfaceAlternateSetting(
-      parameters_->interface_number,
-      parameters_->alternate_setting,
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UsbDeviceHandle::SetInterfaceAlternateSetting,
+                 resource->device(),
+                 parameters_->interface_number,
+                 parameters_->alternate_setting),
       base::Bind(&UsbSetInterfaceAlternateSettingFunction::OnCompleted, this));
 }
 
@@ -956,8 +978,7 @@ void UsbResetDeviceFunction::AsyncWorkStart() {
 
 void UsbResetDeviceFunction::OnStartResest(UsbDeviceResource* resource) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  resource->device()->ResetDevice(
-      base::Bind(&UsbResetDeviceFunction::OnCompletedFileThread, this));
+  OnCompletedFileThread(resource->device()->ResetDevice());
 }
 
 void UsbResetDeviceFunction::OnCompletedFileThread(bool success) {
@@ -979,8 +1000,12 @@ void UsbResetDeviceFunction::OnCompleted(bool success) {
     }
     // Close the device now because the handle is invalid after an
     // unsuccessful reset.
-    resource->device()->Close(
-        base::Bind(&UsbResetDeviceFunction::OnError, this));
+    BrowserThread::PostTaskAndReply(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UsbDeviceHandle::Close,
+                 resource->device()),
+      base::Bind(&UsbResetDeviceFunction::OnError, this));
     return;
   }
   SetResult(Value::CreateBooleanValue(true));
diff --git a/chrome/browser/extensions/api/usb/usb_apitest.cc b/chrome/browser/extensions/api/usb/usb_apitest.cc
index 19b3100..bb64f14 100644
--- a/chrome/browser/extensions/api/usb/usb_apitest.cc
+++ b/chrome/browser/extensions/api/usb/usb_apitest.cc
@@ -13,25 +13,16 @@
 
 using testing::AnyNumber;
 using testing::_;
+using testing::Return;
 
 namespace {
 
-ACTION(InvokeUsbCallback) {
-  ::std::tr1::get<0>(args).Run();
-}
-
 ACTION_TEMPLATE(InvokeUsbTransferCallback,
                 HAS_1_TEMPLATE_PARAMS(int, k),
                 AND_1_VALUE_PARAMS(p1)) {
   ::std::tr1::get<k>(args).Run(p1, new net::IOBuffer(1), 1);
 }
 
-ACTION_TEMPLATE(InvokeUsbResultCallback,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_1_VALUE_PARAMS(p1)) {
-  ::std::tr1::get<k>(args).Run(p1);
-}
-
 // MSVC erroneously thinks that at least one of the arguments for the transfer
 // methods differ by const or volatility and emits a warning about the old
 // standards-noncompliant behaviour of their compiler.
@@ -43,7 +34,7 @@ class MockUsbDeviceHandle : public UsbDeviceHandle {
  public:
   MockUsbDeviceHandle() : UsbDeviceHandle() {}
 
-  MOCK_METHOD1(Close, void(const base::Callback<void()>& callback));
+  MOCK_METHOD0(Close, void());
 
   MOCK_METHOD10(ControlTransfer, void(const UsbEndpointDirection direction,
       const TransferRequestType request_type, const TransferRecipient recipient,
@@ -64,11 +55,9 @@ class MockUsbDeviceHandle : public UsbDeviceHandle {
       const unsigned int packets, const unsigned int packet_length,
       const unsigned int timeout, const UsbTransferCallback& callback));
 
-  MOCK_METHOD1(ResetDevice, void(
-      const base::Callback<void(bool success)>& callback));
+  MOCK_METHOD0(ResetDevice, bool());
 
-  MOCK_METHOD2(ListInterfaces, void(UsbConfigDescriptor* config,
-      const UsbInterfaceCallback& callback));
+  MOCK_METHOD1(ListInterfaces, bool(UsbConfigDescriptor* config));
 
  protected:
   virtual ~MockUsbDeviceHandle() {}
@@ -96,11 +85,10 @@ class UsbApiTest : public ExtensionApiTest {
 }  // namespace
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, DeviceHandling) {
-  EXPECT_CALL(*mock_device_.get(), Close(_))
-      .WillRepeatedly(InvokeUsbCallback());
-  EXPECT_CALL(*mock_device_.get(), ResetDevice(_))
-      .WillOnce(InvokeUsbResultCallback<0>(true))
-      .WillOnce(InvokeUsbResultCallback<0>(false));
+  EXPECT_CALL(*mock_device_.get(), Close()).Times(AnyNumber());
+  EXPECT_CALL(*mock_device_.get(), ResetDevice())
+      .WillOnce(Return(true))
+      .WillOnce(Return(false));
   EXPECT_CALL(*mock_device_.get(),
               InterruptTransfer(USB_DIRECTION_OUTBOUND, 2, _, 1, _, _))
       .WillOnce(InvokeUsbTransferCallback<5>(USB_TRANSFER_COMPLETED));
@@ -108,9 +96,9 @@ IN_PROC_BROWSER_TEST_F(UsbApiTest, DeviceHandling) {
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, ListInterfaces) {
-  EXPECT_CALL(*mock_device_.get(), ListInterfaces(_, _))
-      .WillOnce(InvokeUsbResultCallback<1>(false));
-  EXPECT_CALL(*mock_device_.get(), Close(_)).Times(AnyNumber());
+  EXPECT_CALL(*mock_device_.get(), ListInterfaces(_))
+      .WillOnce(Return(false));
+  EXPECT_CALL(*mock_device_.get(), Close()).Times(AnyNumber());
   ASSERT_TRUE(RunExtensionTest("usb/list_interfaces"));
 }
 
@@ -136,14 +124,14 @@ IN_PROC_BROWSER_TEST_F(UsbApiTest, TransferEvent) {
   EXPECT_CALL(*mock_device_.get(),
               IsochronousTransfer(USB_DIRECTION_OUTBOUND, 3, _, 1, 1, 1, _, _))
       .WillOnce(InvokeUsbTransferCallback<7>(USB_TRANSFER_COMPLETED));
-  EXPECT_CALL(*mock_device_.get(), Close(_)).Times(AnyNumber());
+  EXPECT_CALL(*mock_device_.get(), Close()).Times(AnyNumber());
   ASSERT_TRUE(RunExtensionTest("usb/transfer_event"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, ZeroLengthTransfer) {
   EXPECT_CALL(*mock_device_.get(), BulkTransfer(_, _, _, 0, _, _))
       .WillOnce(InvokeUsbTransferCallback<5>(USB_TRANSFER_COMPLETED));
-  EXPECT_CALL(*mock_device_.get(), Close(_)).Times(AnyNumber());
+  EXPECT_CALL(*mock_device_.get(), Close()).Times(AnyNumber());
   ASSERT_TRUE(RunExtensionTest("usb/zero_length_transfer"));
 }
 
@@ -152,12 +140,12 @@ IN_PROC_BROWSER_TEST_F(UsbApiTest, TransferFailure) {
       .WillOnce(InvokeUsbTransferCallback<5>(USB_TRANSFER_COMPLETED))
       .WillOnce(InvokeUsbTransferCallback<5>(USB_TRANSFER_ERROR))
       .WillOnce(InvokeUsbTransferCallback<5>(USB_TRANSFER_TIMEOUT));
-  EXPECT_CALL(*mock_device_.get(), Close(_)).Times(AnyNumber());
+  EXPECT_CALL(*mock_device_.get(), Close()).Times(AnyNumber());
   ASSERT_TRUE(RunExtensionTest("usb/transfer_failure"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, InvalidLengthTransfer) {
-  EXPECT_CALL(*mock_device_.get(), Close(_)).Times(AnyNumber());
+  EXPECT_CALL(*mock_device_.get(), Close()).Times(AnyNumber());
   ASSERT_TRUE(RunExtensionTest("usb/invalid_length_transfer"));
 }
 
diff --git a/chrome/browser/usb/usb_device_handle.cc b/chrome/browser/usb/usb_device_handle.cc
index bfac067..99faad1 100644
--- a/chrome/browser/usb/usb_device_handle.cc
+++ b/chrome/browser/usb/usb_device_handle.cc
@@ -113,11 +113,10 @@ UsbDeviceHandle::UsbDeviceHandle() : service_(NULL), handle_(NULL) {}
 
 UsbDeviceHandle::~UsbDeviceHandle() {}
 
-void UsbDeviceHandle::Close(const base::Callback<void()>& callback) {
+void UsbDeviceHandle::Close() {
   CheckDevice();
   service_->CloseDevice(this);
   handle_ = NULL;
-  callback.Run();
 }
 
 void UsbDeviceHandle::TransferComplete(PlatformUsbTransferHandle handle) {
@@ -200,8 +199,7 @@ void UsbDeviceHandle::TransferComplete(PlatformUsbTransferHandle handle) {
   libusb_free_transfer(handle);
 }
 
-void UsbDeviceHandle::ListInterfaces(UsbConfigDescriptor* config,
-                               const UsbInterfaceCallback& callback) {
+bool UsbDeviceHandle::ListInterfaces(UsbConfigDescriptor* config) {
   CheckDevice();
 
   PlatformUsbDevice device = libusb_get_device(handle_);
@@ -212,36 +210,38 @@ void UsbDeviceHandle::ListInterfaces(UsbConfigDescriptor* config,
   if (list_result == 0) {
     config->Reset(platform_config);
   }
-  callback.Run(list_result == 0);
+  return list_result == 0;
 }
 
-void UsbDeviceHandle::ClaimInterface(const int interface_number,
-                               const UsbInterfaceCallback& callback) {
+bool UsbDeviceHandle::ClaimInterface(const int interface_number) {
   CheckDevice();
 
   const int claim_result = libusb_claim_interface(handle_, interface_number);
-  callback.Run(claim_result == 0);
+  return claim_result == 0;
 }
 
-void UsbDeviceHandle::ReleaseInterface(const int interface_number,
-                                 const UsbInterfaceCallback& callback) {
+bool UsbDeviceHandle::ReleaseInterface(const int interface_number) {
   CheckDevice();
 
   const int release_result = libusb_release_interface(handle_,
                                                       interface_number);
-  callback.Run(release_result == 0);
+  return release_result == 0;
 }
 
-void UsbDeviceHandle::SetInterfaceAlternateSetting(
+bool UsbDeviceHandle::SetInterfaceAlternateSetting(
     const int interface_number,
-    const int alternate_setting,
-    const UsbInterfaceCallback& callback) {
+    const int alternate_setting) {
   CheckDevice();
 
   const int setting_result = libusb_set_interface_alt_setting(handle_,
       interface_number, alternate_setting);
 
-  callback.Run(setting_result == 0);
+  return setting_result == 0;
+}
+
+bool UsbDeviceHandle::ResetDevice() {
+  CheckDevice();
+  return libusb_reset_device(handle_) == 0;
 }
 
 void UsbDeviceHandle::ControlTransfer(const UsbEndpointDirection direction,
@@ -317,11 +317,6 @@ void UsbDeviceHandle::IsochronousTransfer(const UsbEndpointDirection direction,
   SubmitTransfer(transfer, USB_TRANSFER_ISOCHRONOUS, buffer, length, callback);
 }
 
-void UsbDeviceHandle::ResetDevice(const base::Callback<void(bool)>& callback) {
-  CheckDevice();
-  callback.Run(libusb_reset_device(handle_) == 0);
-}
-
 void UsbDeviceHandle::CheckDevice() {
   DCHECK(handle_) << "Device is already closed.";
 }
diff --git a/chrome/browser/usb/usb_device_handle.h b/chrome/browser/usb/usb_device_handle.h
index 54ed216..e46ab19 100644
--- a/chrome/browser/usb/usb_device_handle.h
+++ b/chrome/browser/usb/usb_device_handle.h
@@ -43,7 +43,6 @@ enum UsbTransferStatus {
 
 typedef base::Callback<void(UsbTransferStatus, scoped_refptr<net::IOBuffer>,
     size_t)> UsbTransferCallback;
-typedef base::Callback<void(bool success)> UsbInterfaceCallback;
 
 // A UsbDevice wraps the platform's underlying representation of what a USB
 // device actually is, and provides accessors for performing many of the
@@ -60,24 +59,19 @@ class UsbDeviceHandle : public base::RefCounted<UsbDeviceHandle> {
 
   PlatformUsbDeviceHandle handle() { return handle_; }
 
-  // Close the USB device and release the underlying platform device. |callback|
-  // is invoked after the device has been closed.
-  virtual void Close(const base::Callback<void()>& callback);
+  // Close the USB device and release the underlying platform device.
+  virtual void Close();
 
-  virtual void ListInterfaces(UsbConfigDescriptor* config,
-                              const UsbInterfaceCallback& callback);
-
-  virtual void ClaimInterface(const int interface_number,
-                              const UsbInterfaceCallback& callback);
-
-  virtual void ReleaseInterface(const int interface_number,
-                                const UsbInterfaceCallback& callback);
-
-  virtual void SetInterfaceAlternateSetting(
+  // Device manipulation operations. These methods are blocking.
+  virtual bool ListInterfaces(UsbConfigDescriptor* config);
+  virtual bool ClaimInterface(const int interface_number);
+  virtual bool ReleaseInterface(const int interface_number);
+  virtual bool SetInterfaceAlternateSetting(
       const int interface_number,
-      const int alternate_setting,
-      const UsbInterfaceCallback& callback);
+      const int alternate_setting);
+  virtual bool ResetDevice();
 
+  // Async IO.
   virtual void ControlTransfer(const UsbEndpointDirection direction,
                                const TransferRequestType request_type,
                                const TransferRecipient recipient,
@@ -112,8 +106,6 @@ class UsbDeviceHandle : public base::RefCounted<UsbDeviceHandle> {
                                    const unsigned int timeout,
                                    const UsbTransferCallback& callback);
 
-  virtual void ResetDevice(const base::Callback<void(bool success)>& callback);
-
   // Normal code should not call this function. It is called by the platform's
   // callback mechanism in such a way that it cannot be made private. Invokes
   // the callbacks associated with a given transfer, and removes it from the