[Code health] Convert DevToolsDeviceDiscovery::DeviceListCallback

to OnceCallback.

The deleted declarations in DevToolsAndroidBridge were left over from a
refactor in r426186

Bug: 1152274
Change-Id: I5f9b9663fc417baa650f563877441b0b459051b1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2582732
Commit-Queue: Leonard Grey <lgrey@chromium.org>
Reviewed-by: Yang Guo <yangguo@chromium.org>
Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Cr-Commit-Position: refs/heads/master@{#836152}

chrome/browser/devtools/device/devtools_android_bridge.cc

@@ -308,9 +308,9 @@ void DevToolsAndroidBridge::ReceivedDeviceCount(int count) {
   if (device_count_listeners_.empty())
      return;
 
-  task_scheduler_.Run(
-      base::Bind(&DevToolsAndroidBridge::RequestDeviceCount,
-                 AsWeakPtr(), device_count_callback_.callback()));
+  task_scheduler_.Run(base::BindOnce(&DevToolsAndroidBridge::RequestDeviceCount,
+                                     AsWeakPtr(),
+                                     device_count_callback_.callback()));
 }
 
 static std::set<net::HostPortPair> ParseTargetDiscoveryPreferenceValue(

chrome/browser/devtools/device/devtools_android_bridge.h

@@ -68,7 +68,6 @@ class DevToolsAndroidBridge : public KeyedService {
   using RemoteDevices = DevToolsDeviceDiscovery::RemoteDevices;
   using CompleteDevice = DevToolsDeviceDiscovery::CompleteDevice;
   using CompleteDevices = DevToolsDeviceDiscovery::CompleteDevices;
-  using DeviceListCallback = DevToolsDeviceDiscovery::DeviceListCallback;
 
   using JsonRequestCallback = base::Callback<void(int, const std::string&)>;
 
@@ -118,7 +117,7 @@ class DevToolsAndroidBridge : public KeyedService {
   }
 
   void set_task_scheduler_for_test(
-      base::Callback<void(const base::Closure&)> scheduler) {
+      base::RepeatingCallback<void(base::OnceClosure)> scheduler) {
     task_scheduler_ = scheduler;
   }
 
@@ -152,7 +151,6 @@ class DevToolsAndroidBridge : public KeyedService {
   void StopDeviceListPolling();
   bool NeedsDeviceListPolling();
 
-  void RequestDeviceList(const DeviceListCallback& callback);
   void ReceivedDeviceList(const CompleteDevices& complete_devices);
 
   void StartDeviceCountPolling();
@@ -160,8 +158,6 @@ class DevToolsAndroidBridge : public KeyedService {
   void RequestDeviceCount(const base::Callback<void(int)>& callback);
   void ReceivedDeviceCount(int count);
 
-  static void ScheduleTaskDefault(const base::Closure& task);
-
   void CreateDeviceProviders();
 
   base::WeakPtr<DevToolsAndroidBridge> AsWeakPtr() {
@@ -181,7 +177,7 @@ class DevToolsAndroidBridge : public KeyedService {
   using DeviceCountListeners = std::vector<DeviceCountListener*>;
   DeviceCountListeners device_count_listeners_;
   base::CancelableCallback<void(int)> device_count_callback_;
-  base::Callback<void(const base::Closure&)> task_scheduler_;
+  base::RepeatingCallback<void(base::OnceClosure)> task_scheduler_;
 
   using PortForwardingListeners = std::vector<PortForwardingListener*>;
   PortForwardingListeners port_forwarding_listeners_;

chrome/browser/devtools/device/devtools_device_discovery.cc

@@ -44,9 +44,10 @@ const char kPageReloadCommand[] = "{'method': 'Page.reload', id: 1}";
 
 const char kWebViewSocketPrefix[] = "webview_devtools_remote";
 
-static void ScheduleTaskDefault(const base::Closure& task) {
+static void ScheduleTaskDefault(base::OnceClosure task) {
   content::GetUIThreadTaskRunner({})->PostDelayedTask(
-      FROM_HERE, task, base::TimeDelta::FromMilliseconds(kPollingIntervalMs));
+      FROM_HERE, std::move(task),
+      base::TimeDelta::FromMilliseconds(kPollingIntervalMs));
 }
 
 // ProtocolCommand ------------------------------------------------------------
@@ -370,15 +371,14 @@ class DevToolsDeviceDiscovery::DiscoveryRequest
     : public base::RefCountedThreadSafe<DiscoveryRequest,
                                         BrowserThread::DeleteOnUIThread> {
  public:
-  static void Start(
-      AndroidDeviceManager* device_manager,
-      const DevToolsDeviceDiscovery::DeviceListCallback& callback);
+  static void Start(AndroidDeviceManager* device_manager,
+                    base::OnceCallback<void(const CompleteDevices&)> callback);
 
  private:
   friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
   friend class base::DeleteHelper<DiscoveryRequest>;
   explicit DiscoveryRequest(
-      const DevToolsDeviceDiscovery::DeviceListCallback& callback);
+      base::OnceCallback<void(const CompleteDevices&)> callback);
   virtual ~DiscoveryRequest();
 
   void ReceivedDevices(const AndroidDeviceManager::Devices& devices);
@@ -393,29 +393,30 @@ class DevToolsDeviceDiscovery::DiscoveryRequest
                      int result,
                      const std::string& response);
 
-  DevToolsDeviceDiscovery::DeviceListCallback callback_;
+  base::OnceCallback<void(const CompleteDevices&)> callback_;
   DevToolsDeviceDiscovery::CompleteDevices complete_devices_;
 };
 
 // static
 void DevToolsDeviceDiscovery::DiscoveryRequest::Start(
     AndroidDeviceManager* device_manager,
-    const DevToolsDeviceDiscovery::DeviceListCallback& callback) {
+    base::OnceCallback<void(const CompleteDevices&)> callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  auto request = base::WrapRefCounted(new DiscoveryRequest(callback));
+  auto request =
+      base::WrapRefCounted(new DiscoveryRequest(std::move(callback)));
   device_manager->QueryDevices(
       base::Bind(&DiscoveryRequest::ReceivedDevices, request));
 }
 
 DevToolsDeviceDiscovery::DiscoveryRequest::DiscoveryRequest(
-    const DevToolsDeviceDiscovery::DeviceListCallback& callback)
-    : callback_(callback) {
+    base::OnceCallback<void(const CompleteDevices&)> callback)
+    : callback_(std::move(callback)) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 DevToolsDeviceDiscovery::DiscoveryRequest::~DiscoveryRequest() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  callback_.Run(complete_devices_);
+  std::move(callback_).Run(complete_devices_);
 }
 
 void DevToolsDeviceDiscovery::DiscoveryRequest::ReceivedDevices(
@@ -587,10 +588,10 @@ DevToolsDeviceDiscovery::RemoteDevice::~RemoteDevice() {
 
 DevToolsDeviceDiscovery::DevToolsDeviceDiscovery(
     AndroidDeviceManager* device_manager,
-    const DeviceListCallback& callback)
+    DeviceListCallback callback)
     : device_manager_(device_manager),
-      callback_(callback),
-      task_scheduler_(base::Bind(&ScheduleTaskDefault)) {
+      callback_(std::move(callback)),
+      task_scheduler_(base::BindRepeating(&ScheduleTaskDefault)) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RequestDeviceList();
 }
@@ -600,9 +601,9 @@ DevToolsDeviceDiscovery::~DevToolsDeviceDiscovery() {
 }
 
 void DevToolsDeviceDiscovery::SetScheduler(
-    base::Callback<void(const base::Closure&)> scheduler) {
+    base::RepeatingCallback<void(base::OnceClosure)> scheduler) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  task_scheduler_ = scheduler;
+  task_scheduler_ = std::move(scheduler);
 }
 
 // static
@@ -619,15 +620,16 @@ DevToolsDeviceDiscovery::CreateBrowserAgentHost(
 void DevToolsDeviceDiscovery::RequestDeviceList() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DiscoveryRequest::Start(
-      device_manager_, base::Bind(&DevToolsDeviceDiscovery::ReceivedDeviceList,
+      device_manager_,
+      base::BindOnce(&DevToolsDeviceDiscovery::ReceivedDeviceList,
                      weak_factory_.GetWeakPtr()));
 }
 
 void DevToolsDeviceDiscovery::ReceivedDeviceList(
     const CompleteDevices& complete_devices) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  task_scheduler_.Run(base::Bind(&DevToolsDeviceDiscovery::RequestDeviceList,
-                                 weak_factory_.GetWeakPtr()));
+  task_scheduler_.Run(base::BindOnce(
+      &DevToolsDeviceDiscovery::RequestDeviceList, weak_factory_.GetWeakPtr()));
   // |callback_| should be run last as it may destroy |this|.
   callback_.Run(complete_devices);
 }

chrome/browser/devtools/device/devtools_device_discovery.h

@@ -120,14 +120,14 @@ class DevToolsDeviceDiscovery {
       std::pair<scoped_refptr<AndroidDeviceManager::Device>,
                 scoped_refptr<RemoteDevice>>;
   using CompleteDevices = std::vector<CompleteDevice>;
-  using DeviceListCallback = base::Callback<void(const CompleteDevices&)>;
+  using DeviceListCallback =
+      base::RepeatingCallback<void(const CompleteDevices&)>;
 
-  DevToolsDeviceDiscovery(
-      AndroidDeviceManager* device_manager,
-      const DeviceListCallback& callback);
+  DevToolsDeviceDiscovery(AndroidDeviceManager* device_manager,
+                          DeviceListCallback callback);
   ~DevToolsDeviceDiscovery();
 
-  void SetScheduler(base::Callback<void(const base::Closure&)> scheduler);
+  void SetScheduler(base::RepeatingCallback<void(base::OnceClosure)> scheduler);
 
   static scoped_refptr<content::DevToolsAgentHost> CreateBrowserAgentHost(
       scoped_refptr<AndroidDeviceManager::Device> device,
@@ -141,7 +141,7 @@ class DevToolsDeviceDiscovery {
 
   AndroidDeviceManager* device_manager_;
   const DeviceListCallback callback_;
-  base::Callback<void(const base::Closure&)> task_scheduler_;
+  base::RepeatingCallback<void(base::OnceClosure)> task_scheduler_;
   base::WeakPtrFactory<DevToolsDeviceDiscovery> weak_factory_{this};
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsDeviceDiscovery);

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

@@ -499,11 +499,10 @@ class AndroidUsbDiscoveryTest : public InProcessBrowserTest {
     adb_bridge_ =
         DevToolsAndroidBridge::Factory::GetForProfile(browser()->profile());
     DCHECK(adb_bridge_);
-    adb_bridge_->set_task_scheduler_for_test(base::Bind(
+    adb_bridge_->set_task_scheduler_for_test(base::BindRepeating(
         &AndroidUsbDiscoveryTest::ScheduleDeviceCountRequest,
         base::Unretained(this)));
 
-
     AndroidDeviceManager::DeviceProviders providers;
     providers.push_back(
         base::MakeRefCounted<UsbDeviceProvider>(browser()->profile()));
@@ -518,10 +517,10 @@ class AndroidUsbDiscoveryTest : public InProcessBrowserTest {
     adb_bridge_->set_usb_device_manager_for_test(std::move(manager));
   }
 
-  void ScheduleDeviceCountRequest(const base::Closure& request) {
+  void ScheduleDeviceCountRequest(base::OnceClosure request) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     scheduler_invoked_++;
-    content::GetUIThreadTaskRunner({})->PostTask(FROM_HERE, request);
+    content::GetUIThreadTaskRunner({})->PostTask(FROM_HERE, std::move(request));
   }
 
   virtual std::unique_ptr<FakeUsbDeviceManager> CreateFakeUsbManager() {