Remove callbacks on USB manipulation methods.

chrome/browser/usb/usb_device_handle.cc

 // Copyright 2013 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/usb/usb_device_handle.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/stl_util.h"
@@ skipping 95 matching lines @@
     UsbService* service,
     PlatformUsbDeviceHandle handle)
     : service_(service), handle_(handle) {
   DCHECK(handle) << "Cannot create device with NULL handle.";
 }
 
 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) {
   base::AutoLock lock(lock_);
 
   // TODO(gdk): Handle device disconnect.
   DCHECK(ContainsKey(transfers_, handle)) << "Missing transfer completed";
   Transfer* const transfer = &transfers_[handle];
 
   DCHECK(handle->actual_length >= 0) << "Negative actual length received";
@@ skipping 62 matching lines @@
       NOTREACHED() << "Invalid usb transfer type";
   }
 
   transfer->callback.Run(ConvertTransferStatus(handle->status), buffer,
                          actual_length);
 
   transfers_.erase(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_);
 
   PlatformUsbConfigDescriptor platform_config;
   const int list_result = libusb_get_active_config_descriptor(device,
       &platform_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,
     const TransferRequestType request_type, const 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) {
   CheckDevice();
 
   const size_t resized_length = LIBUSB_CONTROL_SETUP_SIZE + length;
@@ skipping 55 matching lines @@
   struct libusb_transfer* const transfer = libusb_alloc_transfer(packets);
   const uint8 new_endpoint = ConvertTransferDirection(direction) | endpoint;
   libusb_fill_iso_transfer(transfer, handle_, new_endpoint,
       reinterpret_cast<uint8*>(buffer->data()), length, packets,
       HandleTransferCompletion, this, timeout);
   libusb_set_iso_packet_lengths(transfer, packet_length);
 
   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.";
 }
 
 void UsbDeviceHandle::SubmitTransfer(PlatformUsbTransferHandle handle,
                                UsbTransferType transfer_type,
                                net::IOBuffer* buffer,
                                const size_t length,
                                const UsbTransferCallback& callback) {
   Transfer transfer;
   transfer.transfer_type = transfer_type;
   transfer.buffer = buffer;
   transfer.length = length;
   transfer.callback = callback;
 
   {
     base::AutoLock lock(lock_);
     transfers_[handle] = transfer;
     libusb_submit_transfer(handle);
   }
 }