Remove callbacks on USB manipulation methods.

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 470 matching lines @@
 
 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));
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UsbDeviceHandle::ListInterfaces,
+                 resource->device(),
+                 config_),
+      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));
+  BrowserThread::PostTaskAndReply(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UsbDeviceHandle::Close, resource->device()),
+      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,
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UsbDeviceHandle::ClaimInterface,
+                 resource->device(),
+                 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,
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UsbDeviceHandle::ReleaseInterface,
+                 resource->device(),
+                 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(
-      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));
 }
 
 void UsbSetInterfaceAlternateSettingFunction::OnCompleted(bool success) {
   if (!success)
     SetError(kErrorCannotSetInterfaceAlternateSetting);
   AsyncWorkCompleted();
 }
 
 UsbControlTransferFunction::UsbControlTransferFunction() {}
@@ skipping 236 matching lines @@
     return;
   }
 
   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(
-      base::Bind(&UsbResetDeviceFunction::OnCompletedFileThread, this));
+  OnCompletedFileThread(resource->device()->ResetDevice());
 }
 
 void UsbResetDeviceFunction::OnCompletedFileThread(bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   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));
+    BrowserThread::PostTaskAndReply(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&UsbDeviceHandle::Close,
+                 resource->device()),
+      base::Bind(&UsbResetDeviceFunction::OnError, this));
     return;
   }
   SetResult(Value::CreateBooleanValue(true));
   AsyncWorkCompleted();
 }
 
 void UsbResetDeviceFunction::OnError() {
   RemoveUsbDeviceResource(parameters_->device.handle);
   SetError(kErrorResetDevice);
   SetResult(Value::CreateBooleanValue(false));
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions