Remove callbacks on USB manipulation methods.

chrome/browser/devtools/adb/android_usb_device.cc

 // Copyright (c) 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/devtools/adb/android_usb_device.h"
 
 #include <set>
 
 #include "base/base64.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/devtools/adb/android_rsa.h"
 #include "chrome/browser/devtools/adb/android_usb_socket.h"
 #include "chrome/browser/usb/usb_interface.h"
 #include "chrome/browser/usb/usb_service.h"
 #include "chrome/browser/usb/usb_service_factory.h"
 #include "crypto/rsa_private_key.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/socket/stream_socket.h"
 
 namespace {
 
-void Noop() {}
-void BoolNoop(bool success) {}
-
 const size_t kHeaderSize = 24;
 
 const int kAdbClass = 0xff;
 const int kAdbSubclass = 0x42;
 const int kAdbProtocol = 0x1;
 
 const int kUsbTimeout = 0;
 
 const uint32 kMaxPayload = 4096;
 const uint32 kVersion = 0x01000000;
@@ skipping 48 matching lines @@
         int j;
         for (j = 1; j < res; ++j)
           serial[j - 1] = buffer[j];
         serial[j - 1] = '\0';
         return std::string(serial, j);
     }
   }
   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,
     const UsbInterface* interface,
     AndroidUsbDevices* devices) {
   if (interface->GetNumAltSettings() == 0)
     return;
 
   scoped_refptr<const UsbInterfaceDescriptor> idesc =
       interface->GetAltSetting(0).get();
@@ skipping 17 matching lines @@
     if (edesc->GetDirection() == USB_DIRECTION_INBOUND)
       inbound_address = edesc->GetAddress();
     else
       outbound_address = edesc->GetAddress();
     zero_mask = edesc->GetMaximumPacketSize() - 1;
   }
 
   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));
-}
+  if (!usb_device->ClaimInterface(1))
+    return;
 
-static void InterfacesListed(
-    crypto::RSAPrivateKey* rsa_key,
-    scoped_refptr<UsbDeviceHandle> usb_device,
-    scoped_refptr<UsbConfigDescriptor> config,
-    AndroidUsbDevices* devices,
-    bool success) {
-  if (!success)
-    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) {
   unsigned char* x = (unsigned char*)data.data();
   int count = data.length();
   uint32 sum = 0;
   while (count-- > 0)
     sum += *x++;
   return sum;
 }
@@ skipping 72 matching lines @@
       ++it;
   }
 
   // Add new devices.
   for (UsbDevices::iterator it = usb_devices.begin(); it != usb_devices.end();
        ++it) {
     scoped_refptr<UsbDeviceHandle> usb_device = *it;
     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());
 }
 
 AndroidUsbDevice::AndroidUsbDevice(crypto::RSAPrivateKey* rsa_key,
                                    scoped_refptr<UsbDeviceHandle> usb_device,
                                    const std::string& serial,
                                    int inbound_address,
                                    int outbound_address,
                                    int zero_mask)
@@ skipping 252 matching lines @@
 
   terminated_ = true;
 
   // Iterate over copy.
   AndroidUsbSockets sockets(sockets_);
   for (AndroidUsbSockets::iterator it = sockets.begin();
        it != sockets.end(); ++it) {
     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) {
   sockets_.erase(socket_id);
 }