Move device/usb classes from the FILE thread to UI thread.

extensions/browser/api/usb/usb_api.cc

 // Copyright 2014 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 "extensions/browser/api/usb/usb_api.h"
 
 #include <string>
 #include <vector>
 
+#include "base/barrier_closure.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "device/core/device_client.h"
 #include "device/usb/usb_device_handle.h"
 #include "device/usb/usb_service.h"
 #include "extensions/browser/api/device_permissions_manager.h"
 #include "extensions/browser/api/device_permissions_prompt.h"
 #include "extensions/browser/api/extensions_api_client.h"
 #include "extensions/browser/api/usb/usb_device_resource.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/api/usb.h"
 #include "extensions/common/permissions/permissions_data.h"
@@ skipping 41 matching lines @@
 using usb::EndpointDescriptor;
 using usb::GenericTransferInfo;
 using usb::InterfaceDescriptor;
 using usb::IsochronousTransferInfo;
 using usb::Recipient;
 using usb::RequestType;
 using usb::SynchronizationType;
 using usb::TransferType;
 using usb::UsageType;
 
-typedef std::vector<scoped_refptr<UsbDevice> > DeviceVector;
-typedef scoped_ptr<DeviceVector> ScopedDeviceVector;
-
 namespace {
 
 const char kDataKey[] = "data";
 const char kResultCodeKey[] = "resultCode";
 
 const char kErrorInitService[] = "Failed to initialize USB service.";
 
 const char kErrorOpen[] = "Failed to open device.";
 const char kErrorCancelled[] = "Transfer was cancelled.";
 const char kErrorDisconnect[] = "Device disconnected.";
 const char kErrorGeneric[] = "Transfer failed.";
 const char kErrorNotSupported[] = "Not supported on this platform.";
 const char kErrorNotConfigured[] = "The device is not in a configured state.";
 const char kErrorOverflow[] = "Inbound transfer overflow.";
 const char kErrorStalled[] = "Transfer stalled.";
 const char kErrorTimeout[] = "Transfer timed out.";
 const char kErrorTransferLength[] = "Transfer length is insufficient.";
 const char kErrorCannotSetConfiguration[] =
     "Error setting device configuration.";
 const char kErrorCannotClaimInterface[] = "Error claiming interface.";
 const char kErrorCannotReleaseInterface[] = "Error releasing interface.";
 const char kErrorCannotSetInterfaceAlternateSetting[] =
     "Error setting alternate interface setting.";
 const char kErrorConvertDirection[] = "Invalid transfer direction.";
 const char kErrorConvertRecipient[] = "Invalid transfer recipient.";
 const char kErrorConvertRequestType[] = "Invalid request type.";
 const char kErrorMalformedParameters[] = "Error parsing parameters.";
+const char kErrorNoConnection[] = "No such connection.";
 const char kErrorNoDevice[] = "No such device.";
 const char kErrorPermissionDenied[] = "Permission to access device was denied";
 const char kErrorInvalidTransferLength[] =
     "Transfer length must be a positive number less than 104,857,600.";
 const char kErrorInvalidNumberOfPackets[] =
     "Number of packets must be a positive number less than 4,194,304.";
 const char kErrorInvalidPacketLength[] =
     "Packet length must be a positive number less than 65,536.";
 const char kErrorInvalidTimeout[] =
     "Transfer timeout must be greater than or equal to 0.";
@@ skipping 122 matching lines @@
     case device::USB_TRANSFER_OVERFLOW:
       return kErrorOverflow;
     case device::USB_TRANSFER_LENGTH_SHORT:
       return kErrorTransferLength;
     default:
       NOTREACHED();
       return "";
   }
 }
 
-void RequestUsbDevicesAccessHelper(
-    ScopedDeviceVector devices,
-    std::vector<scoped_refptr<UsbDevice> >::iterator i,
-    int interface_id,
-    const base::Callback<void(ScopedDeviceVector result)>& callback,
-    bool success) {
-  if (success) {
-    ++i;
-  } else {
-    i = devices->erase(i);
-  }
-  if (i == devices->end()) {
-    callback.Run(devices.Pass());
-    return;
-  }
-  (*i)->RequestUsbAccess(interface_id,
-                         base::Bind(RequestUsbDevicesAccessHelper,
-                                    base::Passed(devices.Pass()),
-                                    i,
-                                    interface_id,
-                                    callback));
-}
-
-void RequestUsbDevicesAccess(
-    ScopedDeviceVector devices,
-    int interface_id,
-    const base::Callback<void(ScopedDeviceVector result)>& callback) {
-  if (devices->empty()) {
-    callback.Run(devices.Pass());
-    return;
-  }
-  std::vector<scoped_refptr<UsbDevice> >::iterator i = devices->begin();
-  (*i)->RequestUsbAccess(interface_id,
-                         base::Bind(RequestUsbDevicesAccessHelper,
-                                    base::Passed(devices.Pass()),
-                                    i,
-                                    interface_id,
-                                    callback));
-}
-
-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));
-  return result;
-}
-
 base::Value* PopulateConnectionHandle(int handle,
                                       int vendor_id,
                                       int product_id) {
   ConnectionHandle result;
   result.handle = handle;
   result.vendor_id = vendor_id;
   result.product_id = product_id;
   return result.ToValue().release();
 }
 
@@ skipping 122 matching lines @@
   }
   if (input.interface_protocol) {
     output->SetInterfaceProtocol(*input.interface_protocol);
   }
 }
 
 }  // namespace
 
 namespace extensions {
 
-UsbAsyncApiFunction::UsbAsyncApiFunction() : manager_(NULL) {
+UsbPermissionCheckingFunction::UsbPermissionCheckingFunction()
+    : device_permissions_manager_(nullptr) {
 }
 
-UsbAsyncApiFunction::~UsbAsyncApiFunction() {
+UsbPermissionCheckingFunction::~UsbPermissionCheckingFunction() {
 }
 
-bool UsbAsyncApiFunction::PrePrepare() {
-  manager_ = ApiResourceManager<UsbDeviceResource>::Get(browser_context());
-  set_work_thread_id(BrowserThread::FILE);
-  return manager_ != NULL;
-}
+bool UsbPermissionCheckingFunction::HasDevicePermission(
+    scoped_refptr<UsbDevice> device) {
+  if (!device_permissions_manager_) {
+    device_permissions_manager_ =
+        DevicePermissionsManager::Get(browser_context());
+  }
 
-bool UsbAsyncApiFunction::Respond() {
-  return error_.empty();
-}
+  DevicePermissions* device_permissions =
+      device_permissions_manager_->GetForExtension(extension_id());
+  DCHECK(device_permissions);
 
-bool UsbAsyncApiFunction::HasDevicePermission(scoped_refptr<UsbDevice> device) {
-  DCHECK(device_permissions_);
-
-  // Check the DevicePermissionsManager first so that if an entry is found
-  // it can be stored for later. This requires the serial number.
-  base::string16 serial_number;
-  device->GetSerialNumber(&serial_number);
-
-  permission_entry_ = device_permissions_->FindEntry(device, serial_number);
+  permission_entry_ = device_permissions->FindEntry(device);
   if (permission_entry_.get()) {
     return true;
   }
 
   UsbDevicePermission::CheckParam param(
       device->vendor_id(),
       device->product_id(),
       UsbDevicePermissionData::UNSPECIFIED_INTERFACE);
   if (extension()->permissions_data()->CheckAPIPermissionWithParam(
           APIPermission::kUsbDevice, &param)) {
     return true;
   }
 
   return false;
 }
 
-scoped_refptr<UsbDeviceHandle>
-UsbAsyncApiFunction::GetDeviceHandleOrCompleteWithError(
-    const ConnectionHandle& input_device_handle) {
-  UsbDeviceResource* resource =
-      manager_->Get(extension_->id(), input_device_handle.handle);
-  if (!resource) {
-    CompleteWithError(kErrorNoDevice);
-    return NULL;
+void UsbPermissionCheckingFunction::RecordDeviceLastUsed() {
+  if (permission_entry_.get()) {
+    device_permissions_manager_->UpdateLastUsed(extension_id(),
+                                                permission_entry_);
+  }
+}
+
+UsbConnectionFunction::UsbConnectionFunction() {
+}
+
+UsbConnectionFunction::~UsbConnectionFunction() {
+}
+
+scoped_refptr<device::UsbDeviceHandle> UsbConnectionFunction::GetDeviceHandle(
+    const extensions::core_api::usb::ConnectionHandle& handle) {
+  ApiResourceManager<UsbDeviceResource>* manager =
+      ApiResourceManager<UsbDeviceResource>::Get(browser_context());
+  if (!manager) {
+    return nullptr;
   }
 
-  if (!resource->device().get() || !resource->device()->GetDevice().get()) {
-    CompleteWithError(kErrorDisconnect);
-    manager_->Remove(extension_->id(), input_device_handle.handle);
-    return NULL;
-  }
-
-  if (resource->device()->GetDevice()->vendor_id() !=
-          input_device_handle.vendor_id ||
-      resource->device()->GetDevice()->product_id() !=
-          input_device_handle.product_id) {
-    CompleteWithError(kErrorNoDevice);
-    return NULL;
+  UsbDeviceResource* resource = manager->Get(extension_id(), handle.handle);
+  if (!resource) {
+    return nullptr;
   }
 
   return resource->device();
 }
 
-void UsbAsyncApiFunction::RemoveUsbDeviceResource(int api_resource_id) {
-  manager_->Remove(extension_->id(), api_resource_id);
+void UsbConnectionFunction::ReleaseDeviceHandle(
+    const extensions::core_api::usb::ConnectionHandle& handle) {
+  ApiResourceManager<UsbDeviceResource>* manager =
+      ApiResourceManager<UsbDeviceResource>::Get(browser_context());
+  manager->Remove(extension_id(), handle.handle);
 }
 
-void UsbAsyncApiFunction::CompleteWithError(const std::string& error) {
-  SetError(error);
-  AsyncWorkCompleted();
+UsbTransferFunction::UsbTransferFunction() {
 }
 
-UsbAsyncApiTransferFunction::UsbAsyncApiTransferFunction() {
+UsbTransferFunction::~UsbTransferFunction() {
 }
 
-UsbAsyncApiTransferFunction::~UsbAsyncApiTransferFunction() {
-}
+void UsbTransferFunction::OnCompleted(UsbTransferStatus status,
+                                      scoped_refptr<net::IOBuffer> data,
+                                      size_t length) {
+  scoped_ptr<base::DictionaryValue> transfer_info(new base::DictionaryValue());
+  transfer_info->SetInteger(kResultCodeKey, status);
+  transfer_info->Set(kDataKey, base::BinaryValue::CreateWithCopiedBuffer(
+                                   data->data(), length));
 
-void UsbAsyncApiTransferFunction::OnCompleted(UsbTransferStatus status,
-                                              scoped_refptr<net::IOBuffer> data,
-                                              size_t length) {
-  if (status != device::USB_TRANSFER_COMPLETED)
-    SetError(ConvertTransferStatusToApi(status));
-
-  SetResult(CreateTransferInfo(status, data, length));
-  AsyncWorkCompleted();
-}
-
-bool UsbAsyncApiTransferFunction::ConvertDirectionSafely(
-    const Direction& input,
-    UsbEndpointDirection* output) {
-  const bool converted = ConvertDirectionFromApi(input, output);
-  if (!converted)
-    SetError(kErrorConvertDirection);
-  return converted;
-}
-
-bool UsbAsyncApiTransferFunction::ConvertRequestTypeSafely(
-    const RequestType& input,
-    UsbDeviceHandle::TransferRequestType* output) {
-  const bool converted = ConvertRequestTypeFromApi(input, output);
-  if (!converted)
-    SetError(kErrorConvertRequestType);
-  return converted;
-}
-
-bool UsbAsyncApiTransferFunction::ConvertRecipientSafely(
-    const Recipient& input,
-    UsbDeviceHandle::TransferRecipient* output) {
-  const bool converted = ConvertRecipientFromApi(input, output);
-  if (!converted)
-    SetError(kErrorConvertRecipient);
-  return converted;
+  if (status == device::USB_TRANSFER_COMPLETED) {
+    Respond(OneArgument(transfer_info.release()));
+  } else {
+    scoped_ptr<base::ListValue> error_args(new base::ListValue());
+    error_args->Append(transfer_info.release());
+    // Returning arguments with an error is wrong but we're stuck with it.
+    Respond(ErrorWithArguments(error_args.Pass(),
+                               ConvertTransferStatusToApi(status)));
+  }
 }
 
 UsbFindDevicesFunction::UsbFindDevicesFunction() {
 }
 
 UsbFindDevicesFunction::~UsbFindDevicesFunction() {
 }
 
-bool UsbFindDevicesFunction::Prepare() {
-  parameters_ = FindDevices::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
-  return true;
-}
+ExtensionFunction::ResponseAction UsbFindDevicesFunction::Run() {
+  scoped_ptr<extensions::core_api::usb::FindDevices::Params> parameters =
+      FindDevices::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
-void UsbFindDevicesFunction::AsyncWorkStart() {
-  scoped_ptr<base::ListValue> result(new base::ListValue());
-  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);
+  vendor_id_ = parameters->options.vendor_id;
+  product_id_ = parameters->options.product_id;
+  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 (!extension()->permissions_data()->CheckAPIPermissionWithParam(
           APIPermission::kUsbDevice, &param)) {
-    LOG(WARNING) << "Insufficient permissions to access device.";
-    CompleteWithError(kErrorPermissionDenied);
-    return;
+    return RespondNow(Error(kErrorPermissionDenied));
   }
 
   UsbService* service = device::DeviceClient::Get()->GetUsbService();
   if (!service) {
-    CompleteWithError(kErrorInitService);
-    return;
+    return RespondNow(Error(kErrorInitService));
   }
 
-  ScopedDeviceVector devices(new DeviceVector());
-  service->GetDevices(devices.get());
+  service->GetDevices(
+      base::Bind(&UsbFindDevicesFunction::OnGetDevicesComplete, this));
+  return RespondLater();
+}
 
-  for (DeviceVector::iterator it = devices->begin(); it != devices->end();) {
-    if ((*it)->vendor_id() != vendor_id || (*it)->product_id() != product_id) {
-      it = devices->erase(it);
+void UsbFindDevicesFunction::OnGetDevicesComplete(
+    const std::vector<scoped_refptr<UsbDevice>>& devices) {
+  result_.reset(new base::ListValue());
+  barrier_ = base::BarrierClosure(
+      devices.size(), base::Bind(&UsbFindDevicesFunction::OpenComplete, this));
+
+  for (const scoped_refptr<UsbDevice>& device : devices) {
+    if (device->vendor_id() != vendor_id_ ||
+        device->product_id() != product_id_) {
+      barrier_.Run();
     } else {
-      ++it;
+      device->RequestUsbAccess(
+          interface_id_,
+          base::Bind(&UsbFindDevicesFunction::OnRequestAccessComplete, this,
+                     device));
     }
   }
-
-  RequestUsbDevicesAccess(
-      devices.Pass(),
-      interface_id,
-      base::Bind(&UsbFindDevicesFunction::OpenDevices, this));
 }
 
-void UsbFindDevicesFunction::OpenDevices(ScopedDeviceVector devices) {
-  base::ListValue* result = new base::ListValue();
+void UsbFindDevicesFunction::OnRequestAccessComplete(
+    scoped_refptr<UsbDevice> device,
+    bool success) {
+  if (success) {
+    device->Open(base::Bind(&UsbFindDevicesFunction::OnDeviceOpened, this));
+  } else {
+    barrier_.Run();
+  }
+}
 
-  for (size_t i = 0; i < devices->size(); ++i) {
-    scoped_refptr<UsbDeviceHandle> device_handle = devices->at(i)->Open();
-    if (device_handle.get())
-      device_handles_.push_back(device_handle);
+void UsbFindDevicesFunction::OnDeviceOpened(
+    scoped_refptr<UsbDeviceHandle> device_handle) {
+  if (device_handle.get()) {
+    ApiResourceManager<UsbDeviceResource>* manager =
+        ApiResourceManager<UsbDeviceResource>::Get(browser_context());
+    UsbDeviceResource* resource =
+        new UsbDeviceResource(extension_id(), device_handle);
+    scoped_refptr<UsbDevice> device = device_handle->GetDevice();
+    result_->Append(PopulateConnectionHandle(
+        manager->Add(resource), device->vendor_id(), device->product_id()));
   }
+  barrier_.Run();
+}
 
-  for (size_t i = 0; i < device_handles_.size(); ++i) {
-    UsbDeviceHandle* const device_handle = device_handles_[i].get();
-    UsbDeviceResource* const resource =
-        new UsbDeviceResource(extension_->id(), device_handle);
-
-    result->Append(PopulateConnectionHandle(manager_->Add(resource),
-                                            parameters_->options.vendor_id,
-                                            parameters_->options.product_id));
-  }
-
-  SetResult(result);
-  AsyncWorkCompleted();
+void UsbFindDevicesFunction::OpenComplete() {
+  Respond(OneArgument(result_.release()));
 }
 
 UsbGetDevicesFunction::UsbGetDevicesFunction() {
 }
 
 UsbGetDevicesFunction::~UsbGetDevicesFunction() {
 }
 
-bool UsbGetDevicesFunction::Prepare() {
-  parameters_ = GetDevices::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
-  device_permissions_ = DevicePermissionsManager::Get(browser_context())
-                            ->GetForExtension(extension()->id());
-  return true;
-}
+ExtensionFunction::ResponseAction UsbGetDevicesFunction::Run() {
+  scoped_ptr<extensions::core_api::usb::GetDevices::Params> parameters =
+      GetDevices::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
-void UsbGetDevicesFunction::AsyncWorkStart() {
-  std::vector<UsbDeviceFilter> filters;
-  if (parameters_->options.filters) {
-    filters.resize(parameters_->options.filters->size());
-    for (size_t i = 0; i < parameters_->options.filters->size(); ++i) {
-      ConvertDeviceFilter(*parameters_->options.filters->at(i).get(),
-                          &filters[i]);
+  if (parameters->options.filters) {
+    filters_.resize(parameters->options.filters->size());
+    for (size_t i = 0; i < parameters->options.filters->size(); ++i) {
+      ConvertDeviceFilter(*parameters->options.filters->at(i).get(),
+                          &filters_[i]);
     }
   }
-  if (parameters_->options.vendor_id) {
-    filters.resize(filters.size() + 1);
-    filters.back().SetVendorId(*parameters_->options.vendor_id);
-    if (parameters_->options.product_id) {
-      filters.back().SetProductId(*parameters_->options.product_id);
+  if (parameters->options.vendor_id) {
+    filters_.resize(filters_.size() + 1);
+    filters_.back().SetVendorId(*parameters->options.vendor_id);
+    if (parameters->options.product_id) {
+      filters_.back().SetProductId(*parameters->options.product_id);
     }
   }
 
   UsbService* service = device::DeviceClient::Get()->GetUsbService();
   if (!service) {
-    CompleteWithError(kErrorInitService);
-    return;
+    return RespondNow(Error(kErrorInitService));
   }
 
-  DeviceVector devices;
-  service->GetDevices(&devices);
+  service->GetDevices(
+      base::Bind(&UsbGetDevicesFunction::OnGetDevicesComplete, this));
+  return RespondLater();
+}
 
+void UsbGetDevicesFunction::OnGetDevicesComplete(
+    const std::vector<scoped_refptr<UsbDevice>>& devices) {
   scoped_ptr<base::ListValue> result(new base::ListValue());
-  for (DeviceVector::iterator it = devices.begin(); it != devices.end(); ++it) {
-    scoped_refptr<UsbDevice> device = *it;
-    if ((filters.empty() || UsbDeviceFilter::MatchesAny(device, filters)) &&
+  for (const scoped_refptr<UsbDevice>& device : devices) {
+    if ((filters_.empty() || UsbDeviceFilter::MatchesAny(device, filters_)) &&
         HasDevicePermission(device)) {
-      result->Append(PopulateDevice(it->get()));
+      result->Append(PopulateDevice(device.get()));
     }
   }
 
-  SetResult(result.release());
-  AsyncWorkCompleted();
+  Respond(OneArgument(result.release()));
 }
 
 UsbGetUserSelectedDevicesFunction::UsbGetUserSelectedDevicesFunction() {
 }
 
 UsbGetUserSelectedDevicesFunction::~UsbGetUserSelectedDevicesFunction() {
 }
 
-AsyncApiFunction::ResponseAction UsbGetUserSelectedDevicesFunction::Run() {
+ExtensionFunction::ResponseAction UsbGetUserSelectedDevicesFunction::Run() {
   scoped_ptr<extensions::core_api::usb::GetUserSelectedDevices::Params>
       parameters = GetUserSelectedDevices::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   if (!user_gesture()) {
     return RespondNow(OneArgument(new base::ListValue()));
   }
 
   bool multiple = false;
   if (parameters->options.multiple) {
@@ skipping 21 matching lines @@
   return RespondLater();
 }
 
 void UsbGetUserSelectedDevicesFunction::OnUsbDevicesChosen(
     const std::vector<scoped_refptr<UsbDevice>>& devices) {
   scoped_ptr<base::ListValue> result(new base::ListValue());
   for (const auto& device : devices) {
     result->Append(PopulateDevice(device.get()));
   }
 
-  SetResult(result.release());
-  SendResponse(true);
+  Respond(OneArgument(result.release()));
   Release();
 }
 
 UsbRequestAccessFunction::UsbRequestAccessFunction() {
 }
 
 UsbRequestAccessFunction::~UsbRequestAccessFunction() {
 }
 
-bool UsbRequestAccessFunction::Prepare() {
-  parameters_ = RequestAccess::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
-  return true;
-}
-
-void UsbRequestAccessFunction::AsyncWorkStart() {
-  SetResult(new base::FundamentalValue(true));
-  AsyncWorkCompleted();
+ExtensionFunction::ResponseAction UsbRequestAccessFunction::Run() {
+  scoped_ptr<extensions::core_api::usb::RequestAccess::Params> parameters =
+      RequestAccess::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters.get());
+  return RespondNow(OneArgument(new base::FundamentalValue(true)));
 }
 
 UsbOpenDeviceFunction::UsbOpenDeviceFunction() {
 }
 
 UsbOpenDeviceFunction::~UsbOpenDeviceFunction() {
 }
 
-bool UsbOpenDeviceFunction::Prepare() {
-  parameters_ = OpenDevice::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
-  device_permissions_manager_ =
-      DevicePermissionsManager::Get(browser_context());
-  device_permissions_ =
-      device_permissions_manager_->GetForExtension(extension()->id());
-  return true;
+ExtensionFunction::ResponseAction UsbOpenDeviceFunction::Run() {
+  scoped_ptr<extensions::core_api::usb::OpenDevice::Params> parameters =
+      OpenDevice::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters.get());
+
+  UsbService* service = device::DeviceClient::Get()->GetUsbService();
+  if (!service) {
+    return RespondNow(Error(kErrorInitService));
+  }
+
+  scoped_refptr<UsbDevice> device =
+      service->GetDeviceById(parameters->device.device);
+  if (!device.get()) {
+    return RespondNow(Error(kErrorNoDevice));
+  }
+
+  if (!HasDevicePermission(device)) {
+    // This function must act as if there is no such device. Otherwise it can be
+    // used to fingerprint unauthorized devices.
+    return RespondNow(Error(kErrorNoDevice));
+  }
+
+  device->RequestUsbAccess(
+      -1, /* any interface, unused by the permission broker */
+      base::Bind(&UsbOpenDeviceFunction::OnRequestAccessComplete, this,
+                 device));
+  return RespondLater();
 }
 
-void UsbOpenDeviceFunction::AsyncWorkStart() {
-  UsbService* service = device::DeviceClient::Get()->GetUsbService();
-  if (!service) {
-    CompleteWithError(kErrorInitService);
+void UsbOpenDeviceFunction::OnRequestAccessComplete(
+    scoped_refptr<UsbDevice> device,
+    bool success) {
+  if (success) {
+    device->Open(base::Bind(&UsbOpenDeviceFunction::OnDeviceOpened, this));
+  } else {
+    Respond(Error(kErrorPermissionDenied));
+  }
+}
+
+void UsbOpenDeviceFunction::OnDeviceOpened(
+    scoped_refptr<UsbDeviceHandle> device_handle) {
+  if (!device_handle.get()) {
+    Respond(Error(kErrorOpen));
     return;
   }
 
-  device_ = service->GetDeviceById(parameters_->device.device);
-  if (!device_.get()) {
-    CompleteWithError(kErrorNoDevice);
-    return;
-  }
+  RecordDeviceLastUsed();
 
-  if (!HasDevicePermission(device_)) {
-    // This function must act as if there is no such device. Otherwise it can be
-    // used to fingerprint unauthorized devices.
-    CompleteWithError(kErrorNoDevice);
-    return;
-  }
-
-  device_->RequestUsbAccess(
-      -1, /* any interface, unused by the permission broker */
-      base::Bind(&UsbOpenDeviceFunction::OnRequestAccessComplete, this));
-}
-
-void UsbOpenDeviceFunction::OnRequestAccessComplete(bool success) {
-  if (!success) {
-    SetError(kErrorPermissionDenied);
-    AsyncWorkCompleted();
-    return;
-  }
-
-  scoped_refptr<UsbDeviceHandle> handle = device_->Open();
-  if (!handle.get()) {
-    SetError(kErrorOpen);
-    AsyncWorkCompleted();
-    return;
-  }
-
-  SetResult(PopulateConnectionHandle(
-      manager_->Add(new UsbDeviceResource(extension_->id(), handle)),
-      device_->vendor_id(), device_->product_id()));
-  AsyncWorkCompleted();
-}
-
-bool UsbOpenDeviceFunction::Respond() {
-  if (permission_entry_.get()) {
-    device_permissions_manager_->UpdateLastUsed(extension_->id(),
-                                                permission_entry_);
-  }
-  return UsbAsyncApiFunction::Respond();
+  ApiResourceManager<UsbDeviceResource>* manager =
+      ApiResourceManager<UsbDeviceResource>::Get(browser_context());
+  scoped_refptr<UsbDevice> device = device_handle->GetDevice();
+  Respond(OneArgument(PopulateConnectionHandle(
+      manager->Add(new UsbDeviceResource(extension_id(), device_handle)),
+      device->vendor_id(), device->product_id())));
 }
 
 UsbSetConfigurationFunction::UsbSetConfigurationFunction() {
 }
 
 UsbSetConfigurationFunction::~UsbSetConfigurationFunction() {
 }
 
-bool UsbSetConfigurationFunction::Prepare() {
-  parameters_ = SetConfiguration::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
-  return true;
+ExtensionFunction::ResponseAction UsbSetConfigurationFunction::Run() {
+  scoped_ptr<extensions::core_api::usb::SetConfiguration::Params> parameters =
+      SetConfiguration::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters.get());
+
+  scoped_refptr<UsbDeviceHandle> device_handle =
+      GetDeviceHandle(parameters->handle);
+  if (!device_handle.get()) {
+    return RespondNow(Error(kErrorNoConnection));
+  }
+
+  device_handle->SetConfiguration(
+      parameters->configuration_value,
+      base::Bind(&UsbSetConfigurationFunction::OnComplete, this));
+  return RespondLater();
 }
 
-void UsbSetConfigurationFunction::AsyncWorkStart() {
-  scoped_refptr<UsbDeviceHandle> device_handle =
-      GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle.get()) {
-    return;
+void UsbSetConfigurationFunction::OnComplete(bool success) {
+  if (success) {
+    Respond(NoArguments());
+  } else {
+    Respond(Error(kErrorCannotSetConfiguration));
   }
-
-  if (!device_handle->SetConfiguration(parameters_->configuration_value)) {
-    SetError(kErrorCannotSetConfiguration);
-  }
-  AsyncWorkCompleted();
 }
 
 UsbGetConfigurationFunction::UsbGetConfigurationFunction() {
 }
 
 UsbGetConfigurationFunction::~UsbGetConfigurationFunction() {
 }
 
-bool UsbGetConfigurationFunction::Prepare() {
-  parameters_ = GetConfiguration::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
-  return true;
-}
+ExtensionFunction::ResponseAction UsbGetConfigurationFunction::Run() {
+  scoped_ptr<extensions::core_api::usb::GetConfiguration::Params> parameters =
+      GetConfiguration::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
-void UsbGetConfigurationFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
-      GetDeviceHandleOrCompleteWithError(parameters_->handle);
+      GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
-    return;
+    return RespondNow(Error(kErrorNoConnection));
   }
 
   const UsbConfigDescriptor* config_descriptor =
       device_handle->GetDevice()->GetConfiguration();
   if (config_descriptor) {
     ConfigDescriptor config;
     ConvertConfigDescriptor(*config_descriptor, &config);
-    SetResult(config.ToValue().release());
+    return RespondNow(OneArgument(config.ToValue().release()));
   } else {
-    SetError(kErrorNotConfigured);
+    return RespondNow(Error(kErrorNotConfigured));
   }
-
-  AsyncWorkCompleted();
 }
 
 UsbListInterfacesFunction::UsbListInterfacesFunction() {
 }
 
 UsbListInterfacesFunction::~UsbListInterfacesFunction() {
 }
 
-bool UsbListInterfacesFunction::Prepare() {
-  parameters_ = ListInterfaces::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
-  return true;
-}
+ExtensionFunction::ResponseAction UsbListInterfacesFunction::Run() {
+  scoped_ptr<extensions::core_api::usb::ListInterfaces::Params> parameters =
+      ListInterfaces::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
-void UsbListInterfacesFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
-      GetDeviceHandleOrCompleteWithError(parameters_->handle);
+      GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
-    return;
+    return RespondNow(Error(kErrorNoConnection));
   }
 
   const UsbConfigDescriptor* config_descriptor =
       device_handle->GetDevice()->GetConfiguration();
   if (config_descriptor) {
     ConfigDescriptor config;
     ConvertConfigDescriptor(*config_descriptor, &config);
 
     scoped_ptr<base::ListValue> result(new base::ListValue);
     for (size_t i = 0; i < config.interfaces.size(); ++i) {
       result->Append(config.interfaces[i]->ToValue().release());
     }
 
-    SetResult(result.release());
+    return RespondNow(OneArgument(result.release()));
   } else {
-    SetError(kErrorNotConfigured);
+    return RespondNow(Error(kErrorNotConfigured));
   }
-
-  AsyncWorkCompleted();
 }
 
 UsbCloseDeviceFunction::UsbCloseDeviceFunction() {
 }
 
 UsbCloseDeviceFunction::~UsbCloseDeviceFunction() {
 }
 
-bool UsbCloseDeviceFunction::Prepare() {
-  parameters_ = CloseDevice::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
-  return true;
-}
+ExtensionFunction::ResponseAction UsbCloseDeviceFunction::Run() {
+  scoped_ptr<extensions::core_api::usb::CloseDevice::Params> parameters =
+      CloseDevice::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
-void UsbCloseDeviceFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
-      GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle.get())
-    return;
+      GetDeviceHandle(parameters->handle);
+  if (!device_handle.get()) {
+    return RespondNow(Error(kErrorNoConnection));
+  }
 
   // The device handle is closed when the resource is destroyed.
-  RemoveUsbDeviceResource(parameters_->handle.handle);
-  AsyncWorkCompleted();
+  ReleaseDeviceHandle(parameters->handle);
+  return RespondNow(NoArguments());
 }
 
 UsbClaimInterfaceFunction::UsbClaimInterfaceFunction() {
 }
 
 UsbClaimInterfaceFunction::~UsbClaimInterfaceFunction() {
 }
 
-bool UsbClaimInterfaceFunction::Prepare() {
-  parameters_ = ClaimInterface::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
-  return true;
+ExtensionFunction::ResponseAction UsbClaimInterfaceFunction::Run() {
+  scoped_ptr<extensions::core_api::usb::ClaimInterface::Params> parameters =
+      ClaimInterface::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters.get());
+
+  scoped_refptr<UsbDeviceHandle> device_handle =
+      GetDeviceHandle(parameters->handle);
+  if (!device_handle.get()) {
+    return RespondNow(Error(kErrorNoConnection));
+  }
+
+  device_handle->ClaimInterface(
+      parameters->interface_number,
+      base::Bind(&UsbClaimInterfaceFunction::OnComplete, this));
+  return RespondLater();
 }
 
-void UsbClaimInterfaceFunction::AsyncWorkStart() {
-  scoped_refptr<UsbDeviceHandle> device_handle =
-      GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle.get())
-    return;
-
-  bool success = device_handle->ClaimInterface(parameters_->interface_number);
-
-  if (!success)
-    SetError(kErrorCannotClaimInterface);
-  AsyncWorkCompleted();
+void UsbClaimInterfaceFunction::OnComplete(bool success) {
+  if (success) {
+    Respond(NoArguments());
+  } else {
+    Respond(Error(kErrorCannotClaimInterface));
+  }
 }
 
 UsbReleaseInterfaceFunction::UsbReleaseInterfaceFunction() {
 }
 
 UsbReleaseInterfaceFunction::~UsbReleaseInterfaceFunction() {
 }
 
-bool UsbReleaseInterfaceFunction::Prepare() {
-  parameters_ = ReleaseInterface::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
-  return true;
-}
+ExtensionFunction::ResponseAction UsbReleaseInterfaceFunction::Run() {
+  scoped_ptr<extensions::core_api::usb::ReleaseInterface::Params> parameters =
+      ReleaseInterface::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
-void UsbReleaseInterfaceFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
-      GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle.get())
-    return;
+      GetDeviceHandle(parameters->handle);
+  if (!device_handle.get()) {
+    return RespondNow(Error(kErrorNoConnection));
+  }
 
-  bool success = device_handle->ReleaseInterface(parameters_->interface_number);
-  if (!success)
-    SetError(kErrorCannotReleaseInterface);
-  AsyncWorkCompleted();
+  if (device_handle->ReleaseInterface(parameters->interface_number)) {
+    return RespondNow(NoArguments());
+  } else {
+    return RespondNow(Error(kErrorCannotReleaseInterface));
+  }
 }
 
 UsbSetInterfaceAlternateSettingFunction::
     UsbSetInterfaceAlternateSettingFunction() {
 }
 
 UsbSetInterfaceAlternateSettingFunction::
     ~UsbSetInterfaceAlternateSettingFunction() {
 }
 
-bool UsbSetInterfaceAlternateSettingFunction::Prepare() {
-  parameters_ = SetInterfaceAlternateSetting::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
-  return true;
+ExtensionFunction::ResponseAction
+UsbSetInterfaceAlternateSettingFunction::Run() {
+  scoped_ptr<extensions::core_api::usb::SetInterfaceAlternateSetting::Params>
+      parameters = SetInterfaceAlternateSetting::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters.get());
+
+  scoped_refptr<UsbDeviceHandle> device_handle =
+      GetDeviceHandle(parameters->handle);
+  if (!device_handle.get()) {
+    return RespondNow(Error(kErrorNoConnection));
+  }
+
+  device_handle->SetInterfaceAlternateSetting(
+      parameters->interface_number, parameters->alternate_setting,
+      base::Bind(&UsbSetInterfaceAlternateSettingFunction::OnComplete, this));
+  return RespondLater();
 }
 
-void UsbSetInterfaceAlternateSettingFunction::AsyncWorkStart() {
-  scoped_refptr<UsbDeviceHandle> device_handle =
-      GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle.get())
-    return;
-
-  bool success = device_handle->SetInterfaceAlternateSetting(
-      parameters_->interface_number, parameters_->alternate_setting);
-  if (!success)
-    SetError(kErrorCannotSetInterfaceAlternateSetting);
-
-  AsyncWorkCompleted();
+void UsbSetInterfaceAlternateSettingFunction::OnComplete(bool success) {
+  if (success) {
+    Respond(NoArguments());
+  } else {
+    Respond(Error(kErrorCannotSetInterfaceAlternateSetting));
+  }
 }
 
 UsbControlTransferFunction::UsbControlTransferFunction() {
 }
 
 UsbControlTransferFunction::~UsbControlTransferFunction() {
 }
 
-bool UsbControlTransferFunction::Prepare() {
-  parameters_ = ControlTransfer::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
-  return true;
-}
+ExtensionFunction::ResponseAction UsbControlTransferFunction::Run() {
+  scoped_ptr<extensions::core_api::usb::ControlTransfer::Params> parameters =
+      ControlTransfer::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
-void UsbControlTransferFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
-      GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle.get())
-    return;
+      GetDeviceHandle(parameters->handle);
+  if (!device_handle.get()) {
+    return RespondNow(Error(kErrorNoConnection));
+  }
 
-  const ControlTransferInfo& transfer = parameters_->transfer_info;
-
+  const ControlTransferInfo& transfer = parameters->transfer_info;
   UsbEndpointDirection direction;
   UsbDeviceHandle::TransferRequestType request_type;
   UsbDeviceHandle::TransferRecipient recipient;
   size_t size = 0;
 
-  if (!ConvertDirectionSafely(transfer.direction, &direction) ||
-      !ConvertRequestTypeSafely(transfer.request_type, &request_type) ||
-      !ConvertRecipientSafely(transfer.recipient, &recipient)) {
-    AsyncWorkCompleted();
-    return;
+  if (!ConvertDirectionFromApi(transfer.direction, &direction)) {
+    return RespondNow(Error(kErrorConvertDirection));
+  }
+
+  if (!ConvertRequestTypeFromApi(transfer.request_type, &request_type)) {
+    return RespondNow(Error(kErrorConvertRequestType));
+  }
+
+  if (!ConvertRecipientFromApi(transfer.recipient, &recipient)) {
+    return RespondNow(Error(kErrorConvertRecipient));
   }
 
   if (!GetTransferSize(transfer, &size)) {
-    CompleteWithError(kErrorInvalidTransferLength);
-    return;
+    return RespondNow(Error(kErrorInvalidTransferLength));
   }
 
   scoped_refptr<net::IOBuffer> buffer =
       CreateBufferForTransfer(transfer, direction, size);
   if (!buffer.get()) {
-    CompleteWithError(kErrorMalformedParameters);
-    return;
+    return RespondNow(Error(kErrorMalformedParameters));
   }
 
   int timeout = transfer.timeout ? *transfer.timeout : 0;
   if (timeout < 0) {
-    CompleteWithError(kErrorInvalidTimeout);
-    return;
+    return RespondNow(Error(kErrorInvalidTimeout));
   }
 
   device_handle->ControlTransfer(
       direction, request_type, recipient, transfer.request, transfer.value,
       transfer.index, buffer.get(), size, timeout,
       base::Bind(&UsbControlTransferFunction::OnCompleted, this));
+  return RespondLater();
 }
 
 UsbBulkTransferFunction::UsbBulkTransferFunction() {
 }
 
 UsbBulkTransferFunction::~UsbBulkTransferFunction() {
 }
 
-bool UsbBulkTransferFunction::Prepare() {
-  parameters_ = BulkTransfer::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
-  return true;
-}
+ExtensionFunction::ResponseAction UsbBulkTransferFunction::Run() {
+  scoped_ptr<extensions::core_api::usb::BulkTransfer::Params> parameters =
+      BulkTransfer::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
-void UsbBulkTransferFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
-      GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle.get())
-    return;
+      GetDeviceHandle(parameters->handle);
+  if (!device_handle.get()) {
+    return RespondNow(Error(kErrorNoConnection));
+  }
 
-  const GenericTransferInfo& transfer = parameters_->transfer_info;
-
+  const GenericTransferInfo& transfer = parameters->transfer_info;
   UsbEndpointDirection direction;
   size_t size = 0;
 
-  if (!ConvertDirectionSafely(transfer.direction, &direction)) {
-    AsyncWorkCompleted();
-    return;
+  if (!ConvertDirectionFromApi(transfer.direction, &direction)) {
+    return RespondNow(Error(kErrorConvertDirection));
   }
 
   if (!GetTransferSize(transfer, &size)) {
-    CompleteWithError(kErrorInvalidTransferLength);
-    return;
+    return RespondNow(Error(kErrorInvalidTransferLength));
   }
 
   scoped_refptr<net::IOBuffer> buffer =
       CreateBufferForTransfer(transfer, direction, size);
   if (!buffer.get()) {
-    CompleteWithError(kErrorMalformedParameters);
-    return;
+    return RespondNow(Error(kErrorMalformedParameters));
   }
 
   int timeout = transfer.timeout ? *transfer.timeout : 0;
   if (timeout < 0) {
-    CompleteWithError(kErrorInvalidTimeout);
-    return;
+    return RespondNow(Error(kErrorInvalidTimeout));
   }
 
   device_handle->BulkTransfer(
       direction, transfer.endpoint, buffer.get(), size, timeout,
       base::Bind(&UsbBulkTransferFunction::OnCompleted, this));
+  return RespondLater();
 }
 
 UsbInterruptTransferFunction::UsbInterruptTransferFunction() {
 }
 
 UsbInterruptTransferFunction::~UsbInterruptTransferFunction() {
 }
 
-bool UsbInterruptTransferFunction::Prepare() {
-  parameters_ = InterruptTransfer::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
-  return true;
-}
+ExtensionFunction::ResponseAction UsbInterruptTransferFunction::Run() {
+  scoped_ptr<extensions::core_api::usb::InterruptTransfer::Params> parameters =
+      InterruptTransfer::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
-void UsbInterruptTransferFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
-      GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle.get())
-    return;
+      GetDeviceHandle(parameters->handle);
+  if (!device_handle.get()) {
+    return RespondNow(Error(kErrorNoConnection));
+  }
 
-  const GenericTransferInfo& transfer = parameters_->transfer_info;
-
+  const GenericTransferInfo& transfer = parameters->transfer_info;
   UsbEndpointDirection direction;
   size_t size = 0;
 
-  if (!ConvertDirectionSafely(transfer.direction, &direction)) {
-    AsyncWorkCompleted();
-    return;
+  if (!ConvertDirectionFromApi(transfer.direction, &direction)) {
+    return RespondNow(Error(kErrorConvertDirection));
   }
 
   if (!GetTransferSize(transfer, &size)) {
-    CompleteWithError(kErrorInvalidTransferLength);
-    return;
+    return RespondNow(Error(kErrorInvalidTransferLength));
   }
 
   scoped_refptr<net::IOBuffer> buffer =
       CreateBufferForTransfer(transfer, direction, size);
   if (!buffer.get()) {
-    CompleteWithError(kErrorMalformedParameters);
-    return;
+    return RespondNow(Error(kErrorMalformedParameters));
   }
 
   int timeout = transfer.timeout ? *transfer.timeout : 0;
   if (timeout < 0) {
-    CompleteWithError(kErrorInvalidTimeout);
-    return;
+    return RespondNow(Error(kErrorInvalidTimeout));
   }
 
   device_handle->InterruptTransfer(
       direction, transfer.endpoint, buffer.get(), size, timeout,
       base::Bind(&UsbInterruptTransferFunction::OnCompleted, this));
+  return RespondLater();
 }
 
 UsbIsochronousTransferFunction::UsbIsochronousTransferFunction() {
 }
 
 UsbIsochronousTransferFunction::~UsbIsochronousTransferFunction() {
 }
 
-bool UsbIsochronousTransferFunction::Prepare() {
-  parameters_ = IsochronousTransfer::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(parameters_.get());
-  return true;
-}
+ExtensionFunction::ResponseAction UsbIsochronousTransferFunction::Run() {
+  scoped_ptr<extensions::core_api::usb::IsochronousTransfer::Params>
+      parameters = IsochronousTransfer::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
-void UsbIsochronousTransferFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
-      GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle.get())
-    return;
+      GetDeviceHandle(parameters->handle);
+  if (!device_handle.get()) {
+    return RespondNow(Error(kErrorNoConnection));
+  }
 
-  const IsochronousTransferInfo& transfer = parameters_->transfer_info;
+  const IsochronousTransferInfo& transfer = parameters->transfer_info;
   const GenericTransferInfo& generic_transfer = transfer.transfer_info;
-
   size_t size = 0;
   UsbEndpointDirection direction;
 
-  if (!ConvertDirectionSafely(generic_transfer.direction, &direction)) {
-    AsyncWorkCompleted();
-    return;
+  if (!ConvertDirectionFromApi(generic_transfer.direction, &direction)) {
+    return RespondNow(Error(kErrorConvertDirection));
   }
+
   if (!GetTransferSize(generic_transfer, &size)) {
-    CompleteWithError(kErrorInvalidTransferLength);
-    return;
+    return RespondNow(Error(kErrorInvalidTransferLength));
   }
+
   if (transfer.packets < 0 || transfer.packets >= kMaxPackets) {
-    CompleteWithError(kErrorInvalidNumberOfPackets);
-    return;
+    return RespondNow(Error(kErrorInvalidNumberOfPackets));
   }
+
   unsigned int packets = transfer.packets;
   if (transfer.packet_length < 0 ||
       transfer.packet_length >= kMaxPacketLength) {
-    CompleteWithError(kErrorInvalidPacketLength);
-    return;
+    return RespondNow(Error(kErrorInvalidPacketLength));
   }
+
   unsigned int packet_length = transfer.packet_length;
   const uint64 total_length = packets * packet_length;
   if (packets > size || total_length > size) {
-    CompleteWithError(kErrorTransferLength);
-    return;
+    return RespondNow(Error(kErrorTransferLength));
   }
 
   scoped_refptr<net::IOBuffer> buffer =
       CreateBufferForTransfer(generic_transfer, direction, size);
   if (!buffer.get()) {
-    CompleteWithError(kErrorMalformedParameters);
-    return;
+    return RespondNow(Error(kErrorMalformedParameters));
   }
 
   int timeout = generic_transfer.timeout ? *generic_transfer.timeout : 0;
   if (timeout < 0) {
-    CompleteWithError(kErrorInvalidTimeout);
-    return;
+    return RespondNow(Error(kErrorInvalidTimeout));
   }
 
   device_handle->IsochronousTransfer(
       direction, generic_transfer.endpoint, buffer.get(), size, packets,
       packet_length, timeout,
       base::Bind(&UsbIsochronousTransferFunction::OnCompleted, this));
+  return RespondLater();
 }
 
 UsbResetDeviceFunction::UsbResetDeviceFunction() {
 }
 
 UsbResetDeviceFunction::~UsbResetDeviceFunction() {
 }
 
-bool UsbResetDeviceFunction::Prepare() {
+ExtensionFunction::ResponseAction UsbResetDeviceFunction::Run() {
   parameters_ = ResetDevice::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
-  return true;
+
+  scoped_refptr<UsbDeviceHandle> device_handle =
+      GetDeviceHandle(parameters_->handle);
+  if (!device_handle.get()) {
+    return RespondNow(Error(kErrorNoConnection));
+  }
+
+  device_handle->ResetDevice(
+      base::Bind(&UsbResetDeviceFunction::OnComplete, this));
+  return RespondLater();
 }
 
-void UsbResetDeviceFunction::AsyncWorkStart() {
-  scoped_refptr<UsbDeviceHandle> device_handle =
-      GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle.get())
-    return;
+void UsbResetDeviceFunction::OnComplete(bool success) {
+  if (success) {
+    Respond(OneArgument(new base::FundamentalValue(true)));
+  } else {
+    scoped_refptr<UsbDeviceHandle> device_handle =
+        GetDeviceHandle(parameters_->handle);
+    if (device_handle.get()) {
+      device_handle->Close();
+    }
+    ReleaseDeviceHandle(parameters_->handle);
 
-  bool success = device_handle->ResetDevice();
-  if (!success) {
-    device_handle->Close();
-    RemoveUsbDeviceResource(parameters_->handle.handle);
-    SetResult(new base::FundamentalValue(false));
-    CompleteWithError(kErrorResetDevice);
-    return;
+    scoped_ptr<base::ListValue> error_args(new base::ListValue());
+    error_args->AppendBoolean(false);
+    // Returning arguments with an error is wrong but we're stuck with it.
+    Respond(ErrorWithArguments(error_args.Pass(), kErrorResetDevice));
   }
-
-  SetResult(new base::FundamentalValue(true));
-  AsyncWorkCompleted();
 }
 
 }  // namespace extensions