CodeHealth: Convert base::Bind in chrome/browser/devtools/device.

This CL is part of the Code Health Rotation, and converts
base::Bind, base::Callback, and base::Closure to Once/Repeating as the
code context dictates. It also replaces 'typedef' with 'using' in
several places adjacent to other changes.

Bug: 1007635
Change-Id: Id5cb1bf95d408dfb67cc92ea2cc636598d0b5262
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2626767Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Commit-Queue: Cammie Smith Barnes <cammie@chromium.org>
Cr-Commit-Position: refs/heads/master@{#844204}

chrome/browser/devtools/device/adb/adb_client_socket.cc

@@ -126,8 +126,9 @@ class AdbQuerySocket : AdbClientSocket {
       return;
     }
     bool is_void = current_query_ < queries_.size() - 1;
-    SendCommand(query, is_void,
-        base::Bind(&AdbQuerySocket::OnResponse, base::Unretained(this)));
+    SendCommand(
+        query, is_void,
+        base::BindOnce(&AdbQuerySocket::OnResponse, base::Unretained(this)));
   }
 
   void OnResponse(int result, const std::string& response) {

chrome/browser/devtools/device/adb/adb_client_socket.h

@@ -14,10 +14,9 @@
 
 class AdbClientSocket {
  public:
-  typedef base::OnceCallback<void(int, const std::string&)> CommandCallback;
-  typedef base::OnceCallback<void(int result,
-                                  std::unique_ptr<net::StreamSocket>)>
-      SocketCallback;
+  using CommandCallback = base::OnceCallback<void(int, const std::string&)>;
+  using SocketCallback =
+      base::OnceCallback<void(int result, std::unique_ptr<net::StreamSocket>)>;
 
   static void AdbQuery(int port,
                        const std::string& query,

chrome/browser/devtools/device/adb/adb_device_provider.cc

@@ -53,9 +53,9 @@ void AdbDeviceProvider::QueryDevices(SerialsCallback callback) {
 }
 
 void AdbDeviceProvider::QueryDeviceInfo(const std::string& serial,
-                                        const DeviceInfoCallback& callback) {
+                                        DeviceInfoCallback callback) {
   AndroidDeviceManager::QueryDeviceInfo(base::BindOnce(&RunCommand, serial),
-                                        callback);
+                                        std::move(callback));
 }
 
 void AdbDeviceProvider::OpenSocket(const std::string& serial,

chrome/browser/devtools/device/adb/adb_device_provider.h

@@ -12,7 +12,7 @@ class AdbDeviceProvider : public AndroidDeviceManager::DeviceProvider {
   void QueryDevices(SerialsCallback callback) override;
 
   void QueryDeviceInfo(const std::string& serial,
-                       const DeviceInfoCallback& callback) override;
+                       DeviceInfoCallback callback) override;
 
   void OpenSocket(const std::string& serial,
                   const std::string& socket_name,

chrome/browser/devtools/device/adb/mock_adb_server.h

@@ -31,7 +31,7 @@ class MockAndroidConnection {
     virtual void Close() {}
     virtual ~Delegate() {}
   };
-  using Callback = base::Callback<void(const std::string&)>;
+
   MockAndroidConnection(Delegate* delegate,
                         const std::string& serial,
                         const std::string& command);

chrome/browser/devtools/device/android_device_info_query.cc

@@ -270,18 +270,18 @@ GetBrowserType(const std::string& socket) {
   return AndroidDeviceManager::BrowserInfo::kTypeOther;
 }
 
-void ReceivedResponse(const AndroidDeviceManager::DeviceInfoCallback& callback,
+void ReceivedResponse(AndroidDeviceManager::DeviceInfoCallback callback,
                       int result,
                       const std::string& response) {
   AndroidDeviceManager::DeviceInfo device_info;
   if (result < 0) {
-    callback.Run(device_info);
+    std::move(callback).Run(device_info);
     return;
   }
   std::vector<std::string> outputs = base::SplitStringUsingSubstr(
       response, kSeparator, base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (outputs.size() != 5) {
-    callback.Run(device_info);
+    std::move(callback).Run(device_info);
     return;
   }
   device_info.connected = true;
@@ -329,7 +329,7 @@ void ReceivedResponse(const AndroidDeviceManager::DeviceInfoCallback& callback,
   std::sort(device_info.browser_info.begin(),
             device_info.browser_info.end(),
             &BrowserCompare);
-  callback.Run(device_info);
+  std::move(callback).Run(device_info);
 }
 
 }  // namespace
@@ -357,7 +357,8 @@ std::string AndroidDeviceManager::GetBrowserName(const std::string& socket,
 
 // static
 void AndroidDeviceManager::QueryDeviceInfo(RunCommandCallback command_callback,
-                                           const DeviceInfoCallback& callback) {
+                                           DeviceInfoCallback callback) {
   std::move(command_callback)
-      .Run(kAllCommands, base::BindOnce(&ReceivedResponse, callback));
+      .Run(kAllCommands,
+           base::BindOnce(&ReceivedResponse, std::move(callback)));
 }

chrome/browser/devtools/device/android_device_manager.cc

@@ -66,10 +66,10 @@ net::NetworkTrafficAnnotationTag kAndroidDeviceManagerTrafficAnnotation =
 
 static void PostDeviceInfoCallback(
     scoped_refptr<base::SingleThreadTaskRunner> response_task_runner,
-    const AndroidDeviceManager::DeviceInfoCallback& callback,
+    AndroidDeviceManager::DeviceInfoCallback callback,
     const AndroidDeviceManager::DeviceInfo& device_info) {
-  response_task_runner->PostTask(FROM_HERE,
-                                 base::BindOnce(callback, device_info));
+  response_task_runner->PostTask(
+      FROM_HERE, base::BindOnce(std::move(callback), device_info));
 }
 
 static void PostCommandCallback(
@@ -329,43 +329,44 @@ class HttpRequest {
 
 class DevicesRequest : public base::RefCountedThreadSafe<DevicesRequest> {
  public:
-  typedef AndroidDeviceManager::DeviceInfo DeviceInfo;
-  typedef AndroidDeviceManager::DeviceProvider DeviceProvider;
-  typedef AndroidDeviceManager::DeviceProviders DeviceProviders;
-  typedef AndroidDeviceManager::DeviceDescriptors DeviceDescriptors;
-  typedef base::Callback<void(std::unique_ptr<DeviceDescriptors>)>
-      DescriptorsCallback;
+  using DeviceInfo = AndroidDeviceManager::DeviceInfo;
+  using DeviceProvider = AndroidDeviceManager::DeviceProvider;
+  using DeviceProviders = AndroidDeviceManager::DeviceProviders;
+  using DeviceDescriptors = AndroidDeviceManager::DeviceDescriptors;
+  using DescriptorsCallback =
+      base::OnceCallback<void(std::unique_ptr<DeviceDescriptors>)>;
 
   static void Start(
       scoped_refptr<base::SingleThreadTaskRunner> device_task_runner,
       const DeviceProviders& providers,
-      const DescriptorsCallback& callback) {
+      DescriptorsCallback callback) {
     // Don't keep counted reference on calling thread;
     scoped_refptr<DevicesRequest> request =
-        base::WrapRefCounted(new DevicesRequest(callback));
-    for (auto it = providers.begin(); it != providers.end(); ++it) {
+        base::WrapRefCounted(new DevicesRequest(std::move(callback)));
+    for (const auto& provider : providers) {
       device_task_runner->PostTask(
           FROM_HERE,
-          base::BindOnce(
-              &DeviceProvider::QueryDevices, *it,
-              base::BindOnce(&DevicesRequest::ProcessSerials, request, *it)));
+          base::BindOnce(&DeviceProvider::QueryDevices, provider,
+                         base::BindOnce(&DevicesRequest::ProcessSerials,
+                                        request, provider)));
     }
     device_task_runner->ReleaseSoon(FROM_HERE, std::move(request));
   }
 
  private:
-  explicit DevicesRequest(const DescriptorsCallback& callback)
+  explicit DevicesRequest(DescriptorsCallback callback)
       : response_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-        callback_(callback),
+        callback_(std::move(callback)),
         descriptors_(new DeviceDescriptors()) {}
 
   friend class base::RefCountedThreadSafe<DevicesRequest>;
   ~DevicesRequest() {
     response_task_runner_->PostTask(
-        FROM_HERE, base::BindOnce(callback_, std::move(descriptors_)));
+        FROM_HERE,
+        base::BindOnce(std::move(callback_), std::move(descriptors_)));
   }
 
-  typedef std::vector<std::string> Serials;
+  using Serials = std::vector<std::string>;
 
   void ProcessSerials(scoped_refptr<DeviceProvider> provider, Serials serials) {
     for (auto it = serials.begin(); it != serials.end(); ++it) {
@@ -380,10 +381,9 @@ class DevicesRequest : public base::RefCountedThreadSafe<DevicesRequest> {
   std::unique_ptr<DeviceDescriptors> descriptors_;
 };
 
-void OnCountDevices(const base::Callback<void(int)>& callback,
-                    int device_count) {
+void OnCountDevices(base::OnceCallback<void(int)> callback, int device_count) {
   content::GetUIThreadTaskRunner({})->PostTask(
-      FROM_HERE, base::BindOnce(callback, device_count));
+      FROM_HERE, base::BindOnce(std::move(callback), device_count));
 }
 
 }  // namespace
@@ -445,13 +445,13 @@ AndroidDeviceManager::DeviceProvider::~DeviceProvider() {
 }
 
 void AndroidDeviceManager::Device::QueryDeviceInfo(
-    const DeviceInfoCallback& callback) {
+    DeviceInfoCallback callback) {
   task_runner_->PostTask(
       FROM_HERE,
-      base::BindOnce(
-          &DeviceProvider::QueryDeviceInfo, provider_, serial_,
-          base::Bind(&PostDeviceInfoCallback,
-                     base::ThreadTaskRunnerHandle::Get(), callback)));
+      base::BindOnce(&DeviceProvider::QueryDeviceInfo, provider_, serial_,
+                     base::BindOnce(&PostDeviceInfoCallback,
+                                    base::ThreadTaskRunnerHandle::Get(),
+                                    std::move(callback))));
 }
 
 void AndroidDeviceManager::Device::OpenSocket(const std::string& socket_name,
@@ -562,18 +562,20 @@ void AndroidDeviceManager::SetDeviceProviders(
   providers_ = providers;
 }
 
-void AndroidDeviceManager::QueryDevices(const DevicesCallback& callback) {
-  DevicesRequest::Start(handler_thread_->message_loop(), providers_,
-                        base::Bind(&AndroidDeviceManager::UpdateDevices,
-                                   weak_factory_.GetWeakPtr(), callback));
+void AndroidDeviceManager::QueryDevices(DevicesCallback callback) {
+  DevicesRequest::Start(
+      handler_thread_->message_loop(), providers_,
+      base::BindOnce(&AndroidDeviceManager::UpdateDevices,
+                     weak_factory_.GetWeakPtr(), std::move(callback)));
 }
 
 void AndroidDeviceManager::CountDevices(
-    const base::Callback<void(int)>& callback) {
+    base::OnceCallback<void(int)> callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   handler_thread_->message_loop()->PostTask(
-      FROM_HERE, base::BindOnce(&UsbDeviceManagerHelper::CountDevices,
-                                base::BindOnce(&OnCountDevices, callback)));
+      FROM_HERE,
+      base::BindOnce(&UsbDeviceManagerHelper::CountDevices,
+                     base::BindOnce(&OnCountDevices, std::move(callback))));
 }
 
 void AndroidDeviceManager::set_usb_device_manager_for_test(
@@ -594,7 +596,7 @@ AndroidDeviceManager::~AndroidDeviceManager() {
 }
 
 void AndroidDeviceManager::UpdateDevices(
-    const DevicesCallback& callback,
+    DevicesCallback callback,
     std::unique_ptr<DeviceDescriptors> descriptors) {
   Devices response;
   DeviceWeakMap new_devices;
@@ -614,5 +616,5 @@ void AndroidDeviceManager::UpdateDevices(
     new_devices[it->serial] = device->weak_factory_.GetWeakPtr();
   }
   devices_.swap(new_devices);
-  callback.Run(response);
+  std::move(callback).Run(response);
 }

chrome/browser/devtools/device/android_device_manager.h

@@ -67,7 +67,7 @@ class AndroidDeviceManager {
     std::vector<BrowserInfo> browser_info;
   };
 
-  typedef base::Callback<void(const DeviceInfo&)> DeviceInfoCallback;
+  using DeviceInfoCallback = base::OnceCallback<void(const DeviceInfo&)>;
   class Device;
 
   class AndroidWebSocket {
@@ -113,7 +113,7 @@ class AndroidDeviceManager {
 
   class Device final : public base::RefCountedDeleteOnSequence<Device> {
    public:
-    void QueryDeviceInfo(const DeviceInfoCallback& callback);
+    void QueryDeviceInfo(DeviceInfoCallback callback);
 
     void OpenSocket(const std::string& socket_name, SocketCallback callback);
 
@@ -152,20 +152,20 @@ class AndroidDeviceManager {
     DISALLOW_COPY_AND_ASSIGN(Device);
   };
 
-  typedef std::vector<scoped_refptr<Device> > Devices;
-  typedef base::Callback<void(const Devices&)> DevicesCallback;
+  using Devices = std::vector<scoped_refptr<Device>>;
+  using DevicesCallback = base::OnceCallback<void(const Devices&)>;
 
   class DeviceProvider : public base::RefCountedThreadSafe<DeviceProvider> {
    public:
-    typedef AndroidDeviceManager::SerialsCallback SerialsCallback;
-    typedef AndroidDeviceManager::DeviceInfoCallback DeviceInfoCallback;
-    typedef AndroidDeviceManager::SocketCallback SocketCallback;
-    typedef AndroidDeviceManager::CommandCallback CommandCallback;
+    using SerialsCallback = AndroidDeviceManager::SerialsCallback;
+    using DeviceInfoCallback = AndroidDeviceManager::DeviceInfoCallback;
+    using SocketCallback = AndroidDeviceManager::SocketCallback;
+    using CommandCallback = AndroidDeviceManager::CommandCallback;
 
     virtual void QueryDevices(SerialsCallback callback) = 0;
 
     virtual void QueryDeviceInfo(const std::string& serial,
-                                 const DeviceInfoCallback& callback) = 0;
+                                 DeviceInfoCallback callback) = 0;
 
     virtual void OpenSocket(const std::string& serial,
                             const std::string& socket_name,
@@ -198,8 +198,8 @@ class AndroidDeviceManager {
 
   void SetDeviceProviders(const DeviceProviders& providers);
 
-  void QueryDevices(const DevicesCallback& callback);
-  void CountDevices(const base::Callback<void(int)>& callback);
+  void QueryDevices(DevicesCallback callback);
+  void CountDevices(base::OnceCallback<void(int)> callback);
 
   void set_usb_device_manager_for_test(
       mojo::PendingRemote<device::mojom::UsbDeviceManager> fake_usb_manager);
@@ -210,7 +210,7 @@ class AndroidDeviceManager {
       base::OnceCallback<void(const std::string&, CommandCallback)>;
 
   static void QueryDeviceInfo(RunCommandCallback command_callback,
-                              const DeviceInfoCallback& callback);
+                              DeviceInfoCallback callback);
 
   struct DeviceDescriptor {
     DeviceDescriptor();
@@ -241,7 +241,7 @@ class AndroidDeviceManager {
 
   AndroidDeviceManager();
 
-  void UpdateDevices(const DevicesCallback& callback,
+  void UpdateDevices(DevicesCallback callback,
                      std::unique_ptr<DeviceDescriptors> descriptors);
 
   typedef std::map<std::string, base::WeakPtr<Device> > DeviceWeakMap;

chrome/browser/devtools/device/android_web_socket.cc

@@ -200,7 +200,7 @@ AndroidDeviceManager::AndroidWebSocket::AndroidWebSocket(
   DCHECK(device_);
   device_->HttpUpgrade(
       socket_name, path, net::WebSocketEncoder::kClientExtensions,
-      base::Bind(&AndroidWebSocket::Connected, weak_factory_.GetWeakPtr()));
+      base::BindOnce(&AndroidWebSocket::Connected, weak_factory_.GetWeakPtr()));
 }
 
 AndroidDeviceManager::AndroidWebSocket::~AndroidWebSocket() = default;

chrome/browser/devtools/device/cast_device_provider.cc

@@ -167,11 +167,11 @@ void CastDeviceProvider::QueryDevices(SerialsCallback callback) {
 }
 
 void CastDeviceProvider::QueryDeviceInfo(const std::string& serial,
-                                         const DeviceInfoCallback& callback) {
+                                         DeviceInfoCallback callback) {
   auto it_device = device_info_map_.find(serial);
   if (it_device == device_info_map_.end())
     return;
-  callback.Run(it_device->second);
+  std::move(callback).Run(it_device->second);
 }
 
 void CastDeviceProvider::OpenSocket(const std::string& serial,

chrome/browser/devtools/device/cast_device_provider.h

@@ -28,7 +28,7 @@ class CastDeviceProvider
   // DeviceProvider implementation:
   void QueryDevices(SerialsCallback callback) override;
   void QueryDeviceInfo(const std::string& serial,
-                       const DeviceInfoCallback& callback) override;
+                       DeviceInfoCallback callback) override;
   void OpenSocket(const std::string& serial,
                   const std::string& socket_name,
                   SocketCallback callback) override;

chrome/browser/devtools/device/cast_device_provider_unittest.cc

@@ -70,7 +70,7 @@ TEST(CastDeviceProviderTest, ServiceDiscovery) {
   // Callback should be run, and the queried service should match the expected.
   device_provider_->QueryDeviceInfo(
       cast_service.address.host(),
-      base::Bind(&CompareDeviceInfo, &was_run, expected));
+      base::BindOnce(&CompareDeviceInfo, &was_run, expected));
   ASSERT_TRUE(was_run);
   was_run = false;
 
@@ -90,7 +90,7 @@ TEST(CastDeviceProviderTest, ServiceDiscovery) {
 
   // Callback should not be run, since this service is not yet discovered.
   device_provider_->QueryDeviceInfo(other_service.address.host(),
-                                    base::Bind(&DummyCallback, &was_run));
+                                    base::BindOnce(&DummyCallback, &was_run));
   ASSERT_FALSE(was_run);
 
   device_provider_->OnDeviceChanged(cast_service_type, true, other_service);
@@ -98,7 +98,7 @@ TEST(CastDeviceProviderTest, ServiceDiscovery) {
   // Callback should not be run, since non-cast services are not discovered by
   // this device provider.
   device_provider_->QueryDeviceInfo(other_service.address.host(),
-                                    base::Bind(&DummyCallback, &was_run));
+                                    base::BindOnce(&DummyCallback, &was_run));
   ASSERT_FALSE(was_run);
 
   // Remove the cast service.
@@ -107,6 +107,6 @@ TEST(CastDeviceProviderTest, ServiceDiscovery) {
 
   // Callback should not be run, since the cast service has been removed.
   device_provider_->QueryDeviceInfo(cast_service.address.host(),
-                                    base::Bind(&DummyCallback, &was_run));
+                                    base::BindOnce(&DummyCallback, &was_run));
   ASSERT_FALSE(was_run);
 }

chrome/browser/devtools/device/devtools_android_bridge.cc

@@ -7,6 +7,7 @@
 #include <stddef.h>
 #include <algorithm>
 #include <map>
+#include <memory>
 #include <set>
 #include <utility>
 #include <vector>
@@ -155,15 +156,18 @@ DevToolsAndroidBridge::DevToolsAndroidBridge(Profile* profile)
       port_forwarding_controller_(new PortForwardingController(profile)) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   pref_change_registrar_.Init(profile_->GetPrefs());
-  pref_change_registrar_.Add(prefs::kDevToolsDiscoverUsbDevicesEnabled,
-      base::Bind(&DevToolsAndroidBridge::CreateDeviceProviders,
-                 base::Unretained(this)));
-  pref_change_registrar_.Add(prefs::kDevToolsTCPDiscoveryConfig,
-      base::Bind(&DevToolsAndroidBridge::CreateDeviceProviders,
-                 base::Unretained(this)));
-  pref_change_registrar_.Add(prefs::kDevToolsDiscoverTCPTargetsEnabled,
-      base::Bind(&DevToolsAndroidBridge::CreateDeviceProviders,
-                 base::Unretained(this)));
+  pref_change_registrar_.Add(
+      prefs::kDevToolsDiscoverUsbDevicesEnabled,
+      base::BindRepeating(&DevToolsAndroidBridge::CreateDeviceProviders,
+                          base::Unretained(this)));
+  pref_change_registrar_.Add(
+      prefs::kDevToolsTCPDiscoveryConfig,
+      base::BindRepeating(&DevToolsAndroidBridge::CreateDeviceProviders,
+                          base::Unretained(this)));
+  pref_change_registrar_.Add(
+      prefs::kDevToolsDiscoverTCPTargetsEnabled,
+      base::BindRepeating(&DevToolsAndroidBridge::CreateDeviceProviders,
+                          base::Unretained(this)));
   base::Value target_discovery(base::Value::Type::LIST);
   target_discovery.Append(kChromeDiscoveryURL);
   target_discovery.Append(kNodeDiscoveryURL);
@@ -236,9 +240,10 @@ DevToolsAndroidBridge::~DevToolsAndroidBridge() {
 }
 
 void DevToolsAndroidBridge::StartDeviceListPolling() {
-  device_discovery_.reset(new DevToolsDeviceDiscovery(device_manager_.get(),
-      base::Bind(&DevToolsAndroidBridge::ReceivedDeviceList,
-                 base::Unretained(this))));
+  device_discovery_ = std::make_unique<DevToolsDeviceDiscovery>(
+      device_manager_.get(),
+      base::BindRepeating(&DevToolsAndroidBridge::ReceivedDeviceList,
+                          base::Unretained(this)));
   if (!task_scheduler_.is_null())
     device_discovery_->SetScheduler(task_scheduler_);
 }
@@ -278,8 +283,8 @@ void DevToolsAndroidBridge::ReceivedDeviceList(
 }
 
 void DevToolsAndroidBridge::StartDeviceCountPolling() {
-  device_count_callback_.Reset(
-      base::Bind(&DevToolsAndroidBridge::ReceivedDeviceCount, AsWeakPtr()));
+  device_count_callback_.Reset(base::BindRepeating(
+      &DevToolsAndroidBridge::ReceivedDeviceCount, AsWeakPtr()));
   RequestDeviceCount(device_count_callback_.callback());
 }
 
@@ -288,13 +293,13 @@ void DevToolsAndroidBridge::StopDeviceCountPolling() {
 }
 
 void DevToolsAndroidBridge::RequestDeviceCount(
-    const base::Callback<void(int)>& callback) {
+    base::RepeatingCallback<void(int)> callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (device_count_listeners_.empty() || callback.IsCancelled())
     return;
 
-  device_manager_->CountDevices(callback);
+  device_manager_->CountDevices(std::move(callback));
 }
 
 void DevToolsAndroidBridge::ReceivedDeviceCount(int count) {
@@ -394,7 +399,7 @@ void DevToolsAndroidBridge::CreateDeviceProviders() {
 
 void DevToolsAndroidBridge::set_tcp_provider_callback_for_test(
     TCPProviderCallback callback) {
-  tcp_provider_callback_ = callback;
+  tcp_provider_callback_ = std::move(callback);
   CreateDeviceProviders();
 }
 

chrome/browser/devtools/device/devtools_android_bridge.h

@@ -121,7 +121,6 @@ class DevToolsAndroidBridge : public KeyedService {
     task_scheduler_ = scheduler;
   }
 
-  using RemotePageCallback = base::Callback<void(scoped_refptr<RemotePage>)>;
   void OpenRemotePage(scoped_refptr<RemoteBrowser> browser,
                       const std::string& url);
 
@@ -133,7 +132,7 @@ class DevToolsAndroidBridge : public KeyedService {
                        JsonRequestCallback callback);
 
   using TCPProviderCallback =
-      base::Callback<void(scoped_refptr<TCPDeviceProvider>)>;
+      base::RepeatingCallback<void(scoped_refptr<TCPDeviceProvider>)>;
   void set_tcp_provider_callback_for_test(TCPProviderCallback callback);
   void set_usb_device_manager_for_test(
       mojo::PendingRemote<device::mojom::UsbDeviceManager> fake_usb_manager);
@@ -155,7 +154,7 @@ class DevToolsAndroidBridge : public KeyedService {
 
   void StartDeviceCountPolling();
   void StopDeviceCountPolling();
-  void RequestDeviceCount(const base::Callback<void(int)>& callback);
+  void RequestDeviceCount(base::RepeatingCallback<void(int)> callback);
   void ReceivedDeviceCount(int count);
 
   void CreateDeviceProviders();
@@ -176,7 +175,7 @@ class DevToolsAndroidBridge : public KeyedService {
 
   using DeviceCountListeners = std::vector<DeviceCountListener*>;
   DeviceCountListeners device_count_listeners_;
-  base::CancelableCallback<void(int)> device_count_callback_;
+  base::CancelableRepeatingCallback<void(int)> device_count_callback_;
   base::RepeatingCallback<void(base::OnceClosure)> task_scheduler_;
 
   using PortForwardingListeners = std::vector<PortForwardingListener*>;

chrome/browser/devtools/device/devtools_android_bridge_browsertest.cc

@@ -56,7 +56,7 @@ IN_PROC_BROWSER_TEST_F(DevToolsAndroidBridgeTest, DiscoveryListChanges) {
   scoped_refptr<TCPDeviceProvider> provider;
   int called = 0;
   bridge->set_tcp_provider_callback_for_test(
-      base::Bind(assign_from_callback, &provider, &called));
+      base::BindRepeating(assign_from_callback, &provider, &called));
 
   EXPECT_LT(0, called);
   EXPECT_NE(nullptr, provider);
@@ -130,7 +130,7 @@ IN_PROC_BROWSER_TEST_F(DevToolsAndroidBridgeTest, TCPEnableChange) {
   scoped_refptr<TCPDeviceProvider> provider;
   int called = 0;
   bridge->set_tcp_provider_callback_for_test(
-      base::Bind(assign_from_callback, &provider, &called));
+      base::BindRepeating(assign_from_callback, &provider, &called));
 
   EXPECT_NE(nullptr, provider);
 

chrome/browser/devtools/device/devtools_device_discovery.cc

@@ -405,7 +405,7 @@ void DevToolsDeviceDiscovery::DiscoveryRequest::Start(
   auto request =
       base::WrapRefCounted(new DiscoveryRequest(std::move(callback)));
   device_manager->QueryDevices(
-      base::Bind(&DiscoveryRequest::ReceivedDevices, request));
+      base::BindOnce(&DiscoveryRequest::ReceivedDevices, request));
 }
 
 DevToolsDeviceDiscovery::DiscoveryRequest::DiscoveryRequest(
@@ -424,7 +424,7 @@ void DevToolsDeviceDiscovery::DiscoveryRequest::ReceivedDevices(
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   for (const auto& device : devices) {
     device->QueryDeviceInfo(
-        base::Bind(&DiscoveryRequest::ReceivedDeviceInfo, this, device));
+        base::BindOnce(&DiscoveryRequest::ReceivedDeviceInfo, this, device));
   }
 }
 
@@ -439,7 +439,7 @@ void DevToolsDeviceDiscovery::DiscoveryRequest::ReceivedDeviceInfo(
        it != remote_device->browsers().end(); ++it) {
     device->SendJsonRequest(
         (*it)->socket(), kVersionRequest,
-        base::Bind(&DiscoveryRequest::ReceivedVersion, this, device, *it));
+        base::BindOnce(&DiscoveryRequest::ReceivedVersion, this, device, *it));
   }
 }
 
@@ -452,7 +452,7 @@ void DevToolsDeviceDiscovery::DiscoveryRequest::ReceivedVersion(
 
   device->SendJsonRequest(
       browser->socket(), kPageListRequest,
-      base::Bind(&DiscoveryRequest::ReceivedPages, this, device, browser));
+      base::BindOnce(&DiscoveryRequest::ReceivedPages, this, device, browser));
 
   if (result < 0)
     return;

chrome/browser/devtools/device/port_forwarding_controller.cc

@@ -398,9 +398,9 @@ class PortForwardingController::Connection
       content::BrowserThread::UI>;
   friend class base::DeleteHelper<Connection>;
 
-  typedef std::map<int, std::string> ForwardingMap;
-  typedef base::Callback<void(PortStatus)> CommandCallback;
-  typedef std::map<int, CommandCallback> CommandCallbackMap;
+  using ForwardingMap = std::map<int, std::string>;
+  using CommandCallback = base::OnceCallback<void(PortStatus)>;
+  using CommandCallbackMap = std::map<int, CommandCallback>;
 
   void SerializeChanges(const std::string& method,
                         const ForwardingMap& old_map,
@@ -491,9 +491,8 @@ void PortForwardingController::Connection::SendCommand(
   int id = ++command_id_;
 
   if (method == kBindMethod) {
-    pending_responses_[id] =
-        base::Bind(&Connection::ProcessBindResponse,
-                   base::Unretained(this), port);
+    pending_responses_[id] = base::BindOnce(&Connection::ProcessBindResponse,
+                                            base::Unretained(this), port);
   } else {
     auto it = port_status_.find(port);
     if (it != port_status_.end() && it->second == kStatusError) {
@@ -502,9 +501,8 @@ void PortForwardingController::Connection::SendCommand(
       return;
     }
 
-    pending_responses_[id] =
-        base::Bind(&Connection::ProcessUnbindResponse,
-                   base::Unretained(this), port);
+    pending_responses_[id] = base::BindOnce(&Connection::ProcessUnbindResponse,
+                                            base::Unretained(this), port);
   }
 
   web_socket_->SendFrame(SerializeCommand(id, method, std::move(params)));
@@ -521,7 +519,7 @@ bool PortForwardingController::Connection::ProcessResponse(
   if (it == pending_responses_.end())
     return false;
 
-  it->second.Run(error_code ? kStatusError : kStatusOK);
+  std::move(it->second).Run(error_code ? kStatusError : kStatusOK);
   pending_responses_.erase(it);
   return true;
 }
@@ -592,14 +590,14 @@ void PortForwardingController::Connection::OnFrameRead(
   std::string destination_host = tokens[0];
 
   device_->OpenSocket(*connection_id,
-                      base::Bind(&SocketTunnel::StartTunnel, profile_,
-                                 destination_host, destination_port));
+                      base::BindOnce(&SocketTunnel::StartTunnel, profile_,
+                                     destination_host, destination_port));
 }
 
 PortForwardingController::PortForwardingController(Profile* profile)
     : profile_(profile), pref_service_(profile->GetPrefs()) {
   pref_change_registrar_.Init(pref_service_);
-  base::Closure callback = base::Bind(
+  base::RepeatingClosure callback = base::BindRepeating(
       &PortForwardingController::OnPrefsChange, base::Unretained(this));
   pref_change_registrar_.Add(prefs::kDevToolsPortForwardingEnabled, callback);
   pref_change_registrar_.Add(prefs::kDevToolsPortForwardingConfig, callback);

chrome/browser/devtools/device/tcp_device_provider.cc

@@ -120,7 +120,7 @@ void TCPDeviceProvider::QueryDevices(SerialsCallback callback) {
 }
 
 void TCPDeviceProvider::QueryDeviceInfo(const std::string& serial,
-                                        const DeviceInfoCallback& callback) {
+                                        DeviceInfoCallback callback) {
   AndroidDeviceManager::DeviceInfo device_info;
   device_info.model = kDeviceModel;
   device_info.connected = true;
@@ -137,7 +137,7 @@ void TCPDeviceProvider::QueryDeviceInfo(const std::string& serial,
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::BindOnce(callback, device_info));
+      FROM_HERE, base::BindOnce(std::move(callback), device_info));
 }
 
 void TCPDeviceProvider::OpenSocket(const std::string& serial,

chrome/browser/devtools/device/tcp_device_provider.h

@@ -25,7 +25,7 @@ class TCPDeviceProvider : public AndroidDeviceManager::DeviceProvider {
   void QueryDevices(SerialsCallback callback) override;
 
   void QueryDeviceInfo(const std::string& serial,
-                       const DeviceInfoCallback& callback) override;
+                       DeviceInfoCallback callback) override;
 
   void OpenSocket(const std::string& serial,
                   const std::string& socket_name,

chrome/browser/devtools/device/usb/usb_device_provider.cc

@@ -99,15 +99,15 @@ void UsbDeviceProvider::QueryDevices(SerialsCallback callback) {
 }
 
 void UsbDeviceProvider::QueryDeviceInfo(const std::string& serial,
-                                        const DeviceInfoCallback& callback) {
+                                        DeviceInfoCallback callback) {
   auto it = device_map_.find(serial);
   if (it == device_map_.end() || !it->second->is_connected()) {
     AndroidDeviceManager::DeviceInfo offline_info;
-    callback.Run(offline_info);
+    std::move(callback).Run(offline_info);
     return;
   }
   AndroidDeviceManager::QueryDeviceInfo(base::BindOnce(&RunCommand, it->second),
-                                        callback);
+                                        std::move(callback));
 }
 
 void UsbDeviceProvider::OpenSocket(const std::string& serial,

chrome/browser/devtools/device/usb/usb_device_provider.h

@@ -26,7 +26,7 @@ class UsbDeviceProvider : public AndroidDeviceManager::DeviceProvider {
   void QueryDevices(SerialsCallback callback) override;
 
   void QueryDeviceInfo(const std::string& serial,
-                       const DeviceInfoCallback& callback) override;
+                       DeviceInfoCallback callback) override;
 
   void OpenSocket(const std::string& serial,
                   const std::string& socket_name,