Convert tools/android away from base::Bind/base::Callback

base::Bind/base::Callback are deprecated in favor of either
base::BindOnce/base::OnceCallback or base::BindRepeating/
base::RepeatingCallback (depending on whether the callback
is invoked once or multiple time).

Convert all uses of base::Bind/base::Callback in tools/android
to the recommended methods/types.

Bug: 1007843
Change-Id: Ia955cfe01bc7e23c73e7deda469d9408aa3c90ca
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1832213
Commit-Queue: David Turner <digit@chromium.org>
Commit-Queue: Andrew Grieve <agrieve@chromium.org>
Auto-Submit: Sylvain Defresne <sdefresne@chromium.org>
Reviewed-by: David Turner <digit@chromium.org>
Reviewed-by: Andrew Grieve <agrieve@chromium.org>
Cr-Commit-Position: refs/heads/master@{#702133}

tools/android/forwarder2/device_controller.cc

@@ -67,9 +67,8 @@ void DeviceController::AcceptHostCommandInternal() {
       LOG(INFO) << "Received exit notification";
     return;
   }
-  base::ScopedClosureRunner accept_next_client(
-      base::Bind(&DeviceController::AcceptHostCommandSoon,
-                 base::Unretained(this)));
+  base::ScopedClosureRunner accept_next_client(base::BindOnce(
+      &DeviceController::AcceptHostCommandSoon, base::Unretained(this)));
   // So that |socket| doesn't block on read if it has notifications.
   socket->AddEventFd(exit_notifier_fd_);
   int port;
@@ -90,8 +89,8 @@ void DeviceController::AcceptHostCommandInternal() {
       }
       std::unique_ptr<DeviceListener> new_listener(DeviceListener::Create(
           std::move(socket), port,
-          base::Bind(&DeviceController::DeleteListenerOnError,
-                     weak_ptr_factory_.GetWeakPtr())));
+          base::BindOnce(&DeviceController::DeleteListenerOnError,
+                         weak_ptr_factory_.GetWeakPtr())));
       if (!new_listener)
         return;
       new_listener->Start();

tools/android/forwarder2/device_listener.cc

@@ -23,7 +23,7 @@ namespace forwarder2 {
 std::unique_ptr<DeviceListener> DeviceListener::Create(
     std::unique_ptr<Socket> host_socket,
     int listener_port,
-    const ErrorCallback& error_callback) {
+    ErrorCallback error_callback) {
   std::unique_ptr<Socket> listener_socket(new Socket());
   std::unique_ptr<DeviceListener> device_listener;
   if (!listener_socket->BindTcp("", listener_port)) {
@@ -36,9 +36,9 @@ std::unique_ptr<DeviceListener> DeviceListener::Create(
   // currently (non-zero) allocated port for this socket.
   listener_port = listener_socket->GetPort();
   SendCommand(command::BIND_SUCCESS, listener_port, host_socket.get());
-  device_listener.reset(new DeviceListener(std::move(listener_socket),
-                                           std::move(host_socket),
-                                           listener_port, error_callback));
+  device_listener.reset(
+      new DeviceListener(std::move(listener_socket), std::move(host_socket),
+                         listener_port, std::move(error_callback)));
   return device_listener;
 }
 
@@ -62,8 +62,8 @@ void DeviceListener::SetAdbDataSocket(std::unique_ptr<Socket> adb_data_socket) {
 DeviceListener::DeviceListener(std::unique_ptr<Socket> listener_socket,
                                std::unique_ptr<Socket> host_socket,
                                int port,
-                               const ErrorCallback& error_callback)
-    : self_deleter_helper_(this, error_callback),
+                               ErrorCallback error_callback)
+    : self_deleter_helper_(this, std::move(error_callback)),
       listener_socket_(std::move(listener_socket)),
       host_socket_(std::move(host_socket)),
       listener_port_(port),

tools/android/forwarder2/device_listener.h

@@ -46,12 +46,13 @@ class DeviceListener {
   // Callback that is used for self-deletion on error to let the device
   // controller perform some additional cleanup work (e.g. removing the device
   // listener instance from its internal map before deleting it).
-  typedef base::Callback<void(std::unique_ptr<DeviceListener>)> ErrorCallback;
+  using ErrorCallback =
+      base::OnceCallback<void(std::unique_ptr<DeviceListener>)>;
 
   static std::unique_ptr<DeviceListener> Create(
       std::unique_ptr<Socket> host_socket,
       int port,
-      const ErrorCallback& error_callback);
+      ErrorCallback error_callback);
 
   ~DeviceListener();
 
@@ -65,7 +66,7 @@ class DeviceListener {
   DeviceListener(std::unique_ptr<Socket> listener_socket,
                  std::unique_ptr<Socket> host_socket,
                  int port,
-                 const ErrorCallback& error_callback);
+                 ErrorCallback error_callback);
 
   // Pushes an AcceptClientOnInternalThread() task to the internal thread's
   // message queue in order to wait for a new client soon.

tools/android/forwarder2/forwarders_manager.cc

@@ -101,8 +101,8 @@ void ForwardersManager::WaitForEventsOnInternalThread() {
     return;
 
   base::ScopedClosureRunner wait_for_events_soon(
-      base::Bind(&ForwardersManager::WaitForEventsOnInternalThreadSoon,
-                 base::Unretained(this)));
+      base::BindOnce(&ForwardersManager::WaitForEventsOnInternalThreadSoon,
+                     base::Unretained(this)));
 
   if (FD_ISSET(wakeup_notifier_.receiver_fd(), &read_fds)) {
     // Note that the events on FDs other than the wakeup notifier one, if any,

tools/android/forwarder2/host_controller.cc

@@ -25,7 +25,7 @@ std::unique_ptr<HostController> HostController::Create(
     int host_port,
     int adb_port,
     int exit_notifier_fd,
-    const ErrorCallback& error_callback) {
+    ErrorCallback error_callback) {
   std::unique_ptr<HostController> host_controller;
   std::unique_ptr<PipeNotifier> delete_controller_notifier(new PipeNotifier());
   std::unique_ptr<Socket> adb_control_socket(new Socket());
@@ -52,8 +52,9 @@ std::unique_ptr<HostController> HostController::Create(
     return host_controller;
   }
   host_controller.reset(new HostController(
-      device_serial, device_port_allocated, host_port, adb_port, error_callback,
-      std::move(adb_control_socket), std::move(delete_controller_notifier)));
+      device_serial, device_port_allocated, host_port, adb_port,
+      std::move(error_callback), std::move(adb_control_socket),
+      std::move(delete_controller_notifier)));
   return host_controller;
 }
 
@@ -72,10 +73,10 @@ HostController::HostController(
     int device_port,
     int host_port,
     int adb_port,
-    const ErrorCallback& error_callback,
+    ErrorCallback error_callback,
     std::unique_ptr<Socket> adb_control_socket,
     std::unique_ptr<PipeNotifier> delete_controller_notifier)
-    : self_deleter_helper_(this, error_callback),
+    : self_deleter_helper_(this, std::move(error_callback)),
       device_serial_(device_serial),
       device_port_(device_port),
       host_port_(host_port),

tools/android/forwarder2/host_controller.h

@@ -34,7 +34,8 @@ class HostController {
  public:
   // Callback used for self-deletion when an error happens so that the client
   // can perform some cleanup work before deleting the HostController instance.
-  typedef base::Callback<void(std::unique_ptr<HostController>)> ErrorCallback;
+  using ErrorCallback =
+      base::OnceCallback<void(std::unique_ptr<HostController>)>;
 
   // If |device_port| is zero then a dynamic port is allocated (and retrievable
   // through device_port() below).
@@ -44,7 +45,7 @@ class HostController {
       int host_port,
       int adb_port,
       int exit_notifier_fd,
-      const ErrorCallback& error_callback);
+      ErrorCallback error_callback);
 
   ~HostController();
 
@@ -60,7 +61,7 @@ class HostController {
                  int device_port,
                  int host_port,
                  int adb_port,
-                 const ErrorCallback& error_callback,
+                 ErrorCallback error_callback,
                  std::unique_ptr<Socket> adb_control_socket,
                  std::unique_ptr<PipeNotifier> delete_controller_notifier);
 

tools/android/forwarder2/host_controllers_manager.cc

@@ -14,7 +14,7 @@
 namespace forwarder2 {
 
 HostControllersManager::HostControllersManager(
-    base::Callback<int()> exit_notifier_fd_callback)
+    base::RepeatingCallback<int()> exit_notifier_fd_callback)
     : controllers_(new HostControllerMap()),
       exit_notifier_fd_callback_(exit_notifier_fd_callback),
       has_failed_(false),
@@ -103,8 +103,8 @@ void HostControllersManager::Map(const std::string& adb_path,
   std::unique_ptr<HostController> host_controller(HostController::Create(
       device_serial, device_port, host_port, adb_port,
       exit_notifier_fd_callback_.Run(),
-      base::Bind(&HostControllersManager::DeleteHostController,
-                 weak_ptr_factory_.GetWeakPtr())));
+      base::BindOnce(&HostControllersManager::DeleteHostController,
+                     weak_ptr_factory_.GetWeakPtr())));
   if (!host_controller.get()) {
     has_failed_ = true;
     SendMessage("ERROR: Connection to device failed.\n", client_socket);

tools/android/forwarder2/host_controllers_manager.h

@@ -29,7 +29,7 @@ enum : int {
 class HostControllersManager {
  public:
   explicit HostControllersManager(
-      base::Callback<int()> exit_notifier_fd_callback);
+      base::RepeatingCallback<int()> exit_notifier_fd_callback);
   ~HostControllersManager();
   void HandleRequest(const std::string& adb_path,
                      const std::string& device_serial,
@@ -107,7 +107,7 @@ class HostControllersManager {
   std::unique_ptr<base::AtExitManager>
       at_exit_manager_;  // Needed by base::Thread.
   std::unique_ptr<base::Thread> thread_;
-  base::Callback<int()> exit_notifier_fd_callback_;
+  base::RepeatingCallback<int()> exit_notifier_fd_callback_;
   bool has_failed_;
   base::WeakPtrFactory<HostControllersManager> weak_ptr_factory_;
 };

tools/android/forwarder2/host_controllers_manager_unittest.cc

@@ -38,7 +38,7 @@ base::FilePath CreateScript(const std::string script_contents) {
 // Ensure that we don't start the adb binary with superfluous file descriptors
 // from the parent process.
 TEST(HostControllersManagerTest, AdbNoExtraFds) {
-  HostControllersManager manager(base::Bind(&UnusedGetExitNotifierFD));
+  HostControllersManager manager(base::BindRepeating(&UnusedGetExitNotifierFD));
   base::FilePath unrelated_file;
   base::ScopedFILE open_unrelated_file(
       CreateAndOpenTemporaryFile(&unrelated_file));
@@ -57,7 +57,7 @@ TEST(HostControllersManagerTest, AdbNoExtraFds) {
 
 // Ensure that we don't mangle the argument order.
 TEST(HostControllersManagerTest, AdbArgumentSequence) {
-  HostControllersManager manager(base::Bind(&UnusedGetExitNotifierFD));
+  HostControllersManager manager(base::BindRepeating(&UnusedGetExitNotifierFD));
   base::FilePath adb_script =
       CreateScript(base::StringPrintf("#! /bin/sh\n"
                                       "echo -n \"$@\"\n"));

tools/android/forwarder2/host_forwarder_main.cc

@@ -69,7 +69,7 @@ class ServerDelegate : public Daemon::ServerDelegate {
   explicit ServerDelegate(const std::string& adb_path)
       : adb_path_(adb_path),
         has_failed_(false),
-        controllers_manager_(base::Bind(&GetExitNotifierFD)) {}
+        controllers_manager_(base::BindRepeating(&GetExitNotifierFD)) {}
 
   bool has_failed() const {
     return has_failed_ || controllers_manager_.has_failed();

tools/android/forwarder2/self_deleter_helper.h

@@ -44,10 +44,10 @@ namespace forwarder2 {
 // Usage example:
 // class Object {
 //  public:
-//   typedef base::Callback<void (std::unique_ptr<Object>)> ErrorCallback;
+//   using ErrorCallback = base::OnceCallback<void (std::unique_ptr<Object>)>;
 //
-//   Object(const ErrorCallback& error_callback)
-//       : self_deleter_helper_(this, error_callback) {
+//   Object(ErrorCallback error_callback)
+//       : self_deleter_helper_(this, std::move(error_callback)) {
 //   }
 //
 //   void StartWork() {
@@ -68,8 +68,8 @@ namespace forwarder2 {
 // class ObjectOwner {
 //  public:
 //   ObjectOwner()
-//      : object_(new Object(base::Bind(&ObjectOwner::DeleteObjectOnError,
-//                                      base::Unretained(this))) {
+//      : object_(new Object(base::BindOnce(&ObjectOwner::DeleteObjectOnError,
+//                                          base::Unretained(this))) {
 //      // To keep this example simple base::Unretained(this) is used above but
 //      // note that in a real world scenario the client would have to make sure
 //      // that the ObjectOwner instance is still alive when
@@ -97,13 +97,12 @@ namespace forwarder2 {
 template <typename T>
 class SelfDeleterHelper {
  public:
-  typedef base::Callback<void(std::unique_ptr<T>)> DeletionCallback;
+  using DeletionCallback = base::OnceCallback<void(std::unique_ptr<T>)>;
 
-  SelfDeleterHelper(T* self_deleting_object,
-                    const DeletionCallback& deletion_callback)
+  SelfDeleterHelper(T* self_deleting_object, DeletionCallback deletion_callback)
       : construction_runner_(base::ThreadTaskRunnerHandle::Get()),
         self_deleting_object_(self_deleting_object),
-        deletion_callback_(deletion_callback) {}
+        deletion_callback_(std::move(deletion_callback)) {}
 
   ~SelfDeleterHelper() {
     DCHECK(construction_runner_->RunsTasksInCurrentSequence());
@@ -119,14 +118,14 @@ class SelfDeleterHelper {
  private:
   void SelfDelete() {
     DCHECK(construction_runner_->RunsTasksInCurrentSequence());
-    deletion_callback_.Run(base::WrapUnique(self_deleting_object_));
+    std::move(deletion_callback_).Run(base::WrapUnique(self_deleting_object_));
   }
 
   const scoped_refptr<base::SingleThreadTaskRunner> construction_runner_;
   T* const self_deleting_object_;
-  const DeletionCallback deletion_callback_;
+  DeletionCallback deletion_callback_;
 
-  //WeakPtrFactory's documentation says:
+  // WeakPtrFactory's documentation says:
   // Member variables should appear before the WeakPtrFactory, to ensure
   // that any WeakPtrs to Controller are invalidated before its members
   // variable's destructors are executed, rendering them invalid.

tools/android/memdump/memdump.cc

@@ -511,7 +511,7 @@ int main(int argc, char** argv) {
     }
 
     base::ScopedClosureRunner auto_resume_processes(
-        base::Bind(&KillAll, pids, SIGCONT));
+        base::BindOnce(&KillAll, pids, SIGCONT));
     KillAll(pids, SIGSTOP);
     for (std::vector<pid_t>::const_iterator it = pids.begin(); it != pids.end();
          ++it) {