Remove uses of base::Bind/Callback from extensions/browser/api/a*

Bug: 1007786
Change-Id: Idd730b35e0cead74b10ff758c1339f18c5a6e754
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2105187
Commit-Queue: Alan Cutter <alancutter@chromium.org>
Reviewed-by: Reilly Grant <reillyg@chromium.org>
Cr-Commit-Position: refs/heads/master@{#751609}

extensions/browser/api/alarms/alarm_manager.cc

@@ -441,8 +441,8 @@ void AlarmManager::OnExtensionLoaded(content::BrowserContext* browser_context,
     ready_actions_.insert(ReadyMap::value_type(extension->id(), ReadyQueue()));
     storage->GetExtensionValue(
         extension->id(), kRegisteredAlarms,
-        base::Bind(&AlarmManager::ReadFromStorage, AsWeakPtr(), extension->id(),
-                   is_unpacked));
+        base::BindOnce(&AlarmManager::ReadFromStorage, AsWeakPtr(),
+                       extension->id(), is_unpacked));
   }
 }
 
@@ -450,7 +450,8 @@ void AlarmManager::OnExtensionUninstalled(
     content::BrowserContext* browser_context,
     const Extension* extension,
     extensions::UninstallReason reason) {
-  RemoveAllAlarms(extension->id(), base::Bind(RemoveAllOnUninstallCallback));
+  RemoveAllAlarms(extension->id(),
+                  base::BindOnce(RemoveAllOnUninstallCallback));
 }
 
 // AlarmManager::Alarm

extensions/browser/api/alarms/alarms_api_unittest.cc

@@ -134,7 +134,7 @@ void ExtensionAlarmsTestGetAlarmCallback(ExtensionAlarmsTest* test,
   // Ensure the alarm is gone.
   test->alarm_manager_->GetAllAlarms(
       test->extension()->id(),
-      base::Bind(ExtensionAlarmsTestGetAllAlarmsCallback));
+      base::BindOnce(ExtensionAlarmsTestGetAllAlarmsCallback));
 }
 
 TEST_F(ExtensionAlarmsTest, Create) {
@@ -144,7 +144,7 @@ TEST_F(ExtensionAlarmsTest, Create) {
 
   alarm_manager_->GetAlarm(
       extension()->id(), std::string(),
-      base::Bind(ExtensionAlarmsTestGetAlarmCallback, this));
+      base::BindOnce(ExtensionAlarmsTestGetAlarmCallback, this));
 }
 
 void ExtensionAlarmsTestCreateRepeatingGetAlarmCallback(
@@ -178,7 +178,7 @@ TEST_F(ExtensionAlarmsTest, CreateRepeating) {
 
   alarm_manager_->GetAlarm(
       extension()->id(), std::string(),
-      base::Bind(ExtensionAlarmsTestCreateRepeatingGetAlarmCallback, this));
+      base::BindOnce(ExtensionAlarmsTestCreateRepeatingGetAlarmCallback, this));
 }
 
 void ExtensionAlarmsTestCreateAbsoluteGetAlarm2Callback(
@@ -205,7 +205,7 @@ void ExtensionAlarmsTestCreateAbsoluteGetAlarm1Callback(
 
   test->alarm_manager_->GetAlarm(
       test->extension()->id(), std::string(),
-      base::Bind(ExtensionAlarmsTestCreateAbsoluteGetAlarm2Callback, test));
+      base::BindOnce(ExtensionAlarmsTestCreateAbsoluteGetAlarm2Callback, test));
 }
 
 TEST_F(ExtensionAlarmsTest, CreateAbsolute) {
@@ -214,7 +214,7 @@ TEST_F(ExtensionAlarmsTest, CreateAbsolute) {
 
   alarm_manager_->GetAlarm(
       extension()->id(), std::string(),
-      base::Bind(ExtensionAlarmsTestCreateAbsoluteGetAlarm1Callback, this));
+      base::BindOnce(ExtensionAlarmsTestCreateAbsoluteGetAlarm1Callback, this));
 }
 
 void ExtensionAlarmsTestCreateRepeatingWithQuickFirstCallGetAlarm3Callback(
@@ -235,7 +235,7 @@ void ExtensionAlarmsTestCreateRepeatingWithQuickFirstCallGetAlarm2Callback(
 
   test->alarm_manager_->GetAlarm(
       test->extension()->id(), std::string(),
-      base::Bind(
+      base::BindOnce(
           ExtensionAlarmsTestCreateRepeatingWithQuickFirstCallGetAlarm3Callback,
           test));
 }
@@ -256,7 +256,7 @@ void ExtensionAlarmsTestCreateRepeatingWithQuickFirstCallGetAlarm1Callback(
 
   test->alarm_manager_->GetAlarm(
       test->extension()->id(), std::string(),
-      base::Bind(
+      base::BindOnce(
           ExtensionAlarmsTestCreateRepeatingWithQuickFirstCallGetAlarm2Callback,
           test));
 }
@@ -267,7 +267,7 @@ TEST_F(ExtensionAlarmsTest, CreateRepeatingWithQuickFirstCall) {
 
   alarm_manager_->GetAlarm(
       extension()->id(), std::string(),
-      base::Bind(
+      base::BindOnce(
           ExtensionAlarmsTestCreateRepeatingWithQuickFirstCallGetAlarm1Callback,
           this));
 }
@@ -288,7 +288,7 @@ TEST_F(ExtensionAlarmsTest, CreateDupe) {
 
   alarm_manager_->GetAllAlarms(
       extension()->id(),
-      base::Bind(ExtensionAlarmsTestCreateDupeGetAllAlarmsCallback));
+      base::BindOnce(ExtensionAlarmsTestCreateDupeGetAllAlarmsCallback));
 }
 
 class ConsoleLogMessageLocalFrame : public content::FakeLocalFrame {
@@ -424,7 +424,7 @@ void ExtensionAlarmsTestClearGetAllAlarms1Callback(
   // Ensure the 0.001-minute alarm is still there, since it's repeating.
   test->alarm_manager_->GetAllAlarms(
       test->extension()->id(),
-      base::Bind(ExtensionAlarmsTestClearGetAllAlarms2Callback));
+      base::BindOnce(ExtensionAlarmsTestClearGetAllAlarms2Callback));
 }
 
 TEST_F(ExtensionAlarmsTest, Clear) {
@@ -458,7 +458,7 @@ TEST_F(ExtensionAlarmsTest, Clear) {
 
   alarm_manager_->GetAllAlarms(
       extension()->id(),
-      base::Bind(ExtensionAlarmsTestClearGetAllAlarms1Callback, this));
+      base::BindOnce(ExtensionAlarmsTestClearGetAllAlarms1Callback, this));
 }
 
 void ExtensionAlarmsTestClearAllGetAllAlarms2Callback(
@@ -476,7 +476,7 @@ void ExtensionAlarmsTestClearAllGetAllAlarms1Callback(
   test->RunFunction(new AlarmsClearAllFunction(), "[]");
   test->alarm_manager_->GetAllAlarms(
       test->extension()->id(),
-      base::Bind(ExtensionAlarmsTestClearAllGetAllAlarms2Callback));
+      base::BindOnce(ExtensionAlarmsTestClearAllGetAllAlarms2Callback));
 }
 
 TEST_F(ExtensionAlarmsTest, ClearAll) {
@@ -493,7 +493,7 @@ TEST_F(ExtensionAlarmsTest, ClearAll) {
   CreateAlarms(3);
   alarm_manager_->GetAllAlarms(
       extension()->id(),
-      base::Bind(ExtensionAlarmsTestClearAllGetAllAlarms1Callback, this));
+      base::BindOnce(ExtensionAlarmsTestClearAllGetAllAlarms1Callback, this));
 }
 
 class ExtensionAlarmsSchedulingTest : public ExtensionAlarmsTest {
@@ -512,20 +512,21 @@ class ExtensionAlarmsSchedulingTest : public ExtensionAlarmsTest {
   void VerifyScheduledTime(const std::string& alarm_name) {
     alarm_manager_->GetAlarm(
         extension()->id(), alarm_name,
-        base::Bind(&ExtensionAlarmsSchedulingTest::GetAlarmCallback,
+        base::BindOnce(&ExtensionAlarmsSchedulingTest::GetAlarmCallback,
                        base::Unretained(this)));
   }
 
   void RemoveAlarm(const std::string& name) {
     alarm_manager_->RemoveAlarm(
         extension()->id(), name,
-        base::Bind(&ExtensionAlarmsSchedulingTest::RemoveAlarmCallback));
+        base::BindOnce(&ExtensionAlarmsSchedulingTest::RemoveAlarmCallback));
   }
 
   void RemoveAllAlarms() {
     alarm_manager_->RemoveAllAlarms(
         extension()->id(),
-        base::Bind(&ExtensionAlarmsSchedulingTest::RemoveAllAlarmsCallback));
+        base::BindOnce(
+            &ExtensionAlarmsSchedulingTest::RemoveAllAlarmsCallback));
   }
 };
 
@@ -705,8 +706,9 @@ TEST_F(ExtensionAlarmsSchedulingTest, PollFrequencyFromStoredAlarm) {
                                     std::move(value));
 
     // Let the alarm fire once, we will verify the next polling time afterwards.
-    alarm_manager_->GetAlarm(extension()->id(), "hello",
-                             base::Bind(FrequencyTestGetAlarmsCallback, this));
+    alarm_manager_->GetAlarm(
+        extension()->id(), "hello",
+        base::BindOnce(FrequencyTestGetAlarmsCallback, this));
 
     // The stored alarm's "periodInMinutes" is much smaller than allowed minimum
     // in this test (alarms_api_constants::kDevDelayMinimum or

extensions/browser/api/app_window/app_window_api.cc

@@ -424,8 +424,8 @@ ExtensionFunction::ResponseAction AppWindowCreateFunction::Run() {
           ->HadDevToolsAttached(app_window->web_contents())) {
     AppWindowClient::Get()->OpenDevToolsWindow(
         app_window->web_contents(),
-        base::Bind(&AppWindowCreateFunction::Respond, this,
-                   base::Passed(&result_arg)));
+        base::BindOnce(&AppWindowCreateFunction::Respond, this,
+                       std::move(result_arg)));
     // OpenDevToolsWindow might have already responded.
     return did_respond() ? AlreadyResponded() : RespondLater();
   }

extensions/browser/api/automation_internal/automation_internal_api.cc

@@ -69,11 +69,10 @@ class QuerySelectorHandler : public content::WebContentsObserver {
       int request_id,
       int acc_obj_id,
       const base::string16& query,
-      const extensions::AutomationInternalQuerySelectorFunction::Callback&
-          callback)
+      extensions::AutomationInternalQuerySelectorFunction::Callback callback)
       : content::WebContentsObserver(web_contents),
         request_id_(request_id),
-        callback_(callback) {
+        callback_(std::move(callback)) {
     content::RenderFrameHost* rfh = web_contents->GetMainFrame();
 
     rfh->Send(new ExtensionMsg_AutomationQuerySelector(
@@ -104,7 +103,7 @@ class QuerySelectorHandler : public content::WebContentsObserver {
   }
 
   void WebContentsDestroyed() override {
-    callback_.Run(kRendererDestroyed, 0);
+    std::move(callback_).Run(kRendererDestroyed, 0);
     delete this;
   }
 
@@ -123,12 +122,12 @@ class QuerySelectorHandler : public content::WebContentsObserver {
         error_string = kNodeDestroyed;
         break;
     }
-    callback_.Run(error_string, result_acc_obj_id);
+    std::move(callback_).Run(error_string, result_acc_obj_id);
     delete this;
   }
 
   int request_id_;
-  const extensions::AutomationInternalQuerySelectorFunction::Callback callback_;
+  extensions::AutomationInternalQuerySelectorFunction::Callback callback_;
 };
 
 }  // namespace
@@ -624,7 +623,8 @@ AutomationInternalQuerySelectorFunction::Run() {
   // QuerySelectorHandler handles IPCs and deletes itself on completion.
   new QuerySelectorHandler(
       contents, request_id, params->args.automation_node_id, selector,
-      base::Bind(&AutomationInternalQuerySelectorFunction::OnResponse, this));
+      base::BindOnce(&AutomationInternalQuerySelectorFunction::OnResponse,
+                     this));
 
   return RespondLater();
 }

extensions/browser/api/automation_internal/automation_internal_api.h

@@ -77,8 +77,8 @@ class AutomationInternalQuerySelectorFunction : public ExtensionFunction {
                              AUTOMATIONINTERNAL_QUERYSELECTOR)
 
  public:
-  typedef base::Callback<void(const std::string& error, int result_acc_obj_id)>
-      Callback;
+  using Callback =
+      base::OnceCallback<void(const std::string& error, int result_acc_obj_id)>;
 
  protected:
   ~AutomationInternalQuerySelectorFunction() override = default;

extensions/browser/state_store.cc

@@ -41,7 +41,7 @@ class StateStore::DelayedTaskQueue {
 
   // Queues up a task for invoking once we're ready. Invokes immediately if
   // we're already ready.
-  void InvokeWhenReady(const base::Closure& task);
+  void InvokeWhenReady(base::OnceClosure task);
 
   // Marks us ready, and invokes all pending tasks.
   void SetReady();
@@ -51,22 +51,22 @@ class StateStore::DelayedTaskQueue {
 
  private:
   bool ready_;
-  std::vector<base::Closure> pending_tasks_;
+  std::vector<base::OnceClosure> pending_tasks_;
 };
 
-void StateStore::DelayedTaskQueue::InvokeWhenReady(const base::Closure& task) {
+void StateStore::DelayedTaskQueue::InvokeWhenReady(base::OnceClosure task) {
   if (ready_) {
-    task.Run();
+    std::move(task).Run();
   } else {
-    pending_tasks_.push_back(task);
+    pending_tasks_.push_back(std::move(task));
   }
 }
 
 void StateStore::DelayedTaskQueue::SetReady() {
   ready_ = true;
 
-  for (size_t i = 0; i < pending_tasks_.size(); ++i)
-    pending_tasks_[i].Run();
+  for (base::OnceClosure& task : pending_tasks_)
+    std::move(task).Run();
   pending_tasks_.clear();
 }
 
@@ -105,8 +105,8 @@ void StateStore::GetExtensionValue(const std::string& extension_id,
                                    const std::string& key,
                                    ReadCallback callback) {
   task_queue_->InvokeWhenReady(
-      base::Bind(&ValueStoreFrontend::Get, base::Unretained(store_.get()),
-                 GetFullKey(extension_id, key), callback));
+      base::BindOnce(&ValueStoreFrontend::Get, base::Unretained(store_.get()),
+                     GetFullKey(extension_id, key), std::move(callback)));
 }
 
 void StateStore::SetExtensionValue(const std::string& extension_id,
@@ -116,13 +116,13 @@ void StateStore::SetExtensionValue(const std::string& extension_id,
     observer.WillSetExtensionValue(extension_id, key);
 
   task_queue_->InvokeWhenReady(
-      base::Bind(&ValueStoreFrontend::Set, base::Unretained(store_.get()),
-                 GetFullKey(extension_id, key), base::Passed(&value)));
+      base::BindOnce(&ValueStoreFrontend::Set, base::Unretained(store_.get()),
+                     GetFullKey(extension_id, key), std::move(value)));
 }
 
 void StateStore::RemoveExtensionValue(const std::string& extension_id,
                                       const std::string& key) {
-  task_queue_->InvokeWhenReady(base::Bind(&ValueStoreFrontend::Remove,
+  task_queue_->InvokeWhenReady(base::BindOnce(&ValueStoreFrontend::Remove,
                                               base::Unretained(store_.get()),
                                               GetFullKey(extension_id, key)));
 }
@@ -186,8 +186,8 @@ void StateStore::InitAfterDelay() {
 void StateStore::RemoveKeysForExtension(const std::string& extension_id) {
   for (auto key = registered_keys_.begin(); key != registered_keys_.end();
        ++key) {
-    task_queue_->InvokeWhenReady(base::Bind(&ValueStoreFrontend::Remove,
-                                            base::Unretained(store_.get()),
+    task_queue_->InvokeWhenReady(base::BindOnce(
+        &ValueStoreFrontend::Remove, base::Unretained(store_.get()),
         GetFullKey(extension_id, *key)));
   }
 }

extensions/browser/value_store/value_store_frontend.cc

@@ -30,8 +30,7 @@ class ValueStoreFrontend::Backend : public base::RefCountedThreadSafe<Backend> {
           BackendType backend_type)
       : store_factory_(store_factory), backend_type_(backend_type) {}
 
-  void Get(const std::string& key,
-           const ValueStoreFrontend::ReadCallback& callback) {
+  void Get(const std::string& key, ValueStoreFrontend::ReadCallback callback) {
     DCHECK(IsOnBackendSequence());
     LazyInit();
     ValueStore::ReadResult result = storage_->Get(key);
@@ -48,7 +47,7 @@ class ValueStoreFrontend::Backend : public base::RefCountedThreadSafe<Backend> {
 
     base::PostTask(FROM_HERE, {BrowserThread::UI},
                    base::BindOnce(&ValueStoreFrontend::Backend::RunCallback,
-                                  this, callback, std::move(value)));
+                                  this, std::move(callback), std::move(value)));
   }
 
   void Set(const std::string& key, std::unique_ptr<base::Value> value) {
@@ -91,10 +90,10 @@ class ValueStoreFrontend::Backend : public base::RefCountedThreadSafe<Backend> {
     }
   }
 
-  void RunCallback(const ValueStoreFrontend::ReadCallback& callback,
+  void RunCallback(ValueStoreFrontend::ReadCallback callback,
                    std::unique_ptr<base::Value> value) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
-    callback.Run(std::move(value));
+    std::move(callback).Run(std::move(value));
   }
 
   // The factory which will be used to lazily create the ValueStore when needed.
@@ -122,13 +121,12 @@ ValueStoreFrontend::~ValueStoreFrontend() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
-void ValueStoreFrontend::Get(const std::string& key,
-                             const ReadCallback& callback) {
+void ValueStoreFrontend::Get(const std::string& key, ReadCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   GetBackendTaskRunner()->PostTask(
       FROM_HERE, base::BindOnce(&ValueStoreFrontend::Backend::Get, backend_,
-                                key, callback));
+                                key, std::move(callback)));
 }
 
 void ValueStoreFrontend::Set(const std::string& key,

extensions/browser/value_store/value_store_frontend.h

@@ -24,7 +24,7 @@ class ValueStoreFrontend {
   // The kind of extensions data stored in a backend.
   enum class BackendType { RULES, STATE };
 
-  typedef base::Callback<void(std::unique_ptr<base::Value>)> ReadCallback;
+  using ReadCallback = base::OnceCallback<void(std::unique_ptr<base::Value>)>;
 
   ValueStoreFrontend(
       const scoped_refptr<extensions::ValueStoreFactory>& store_factory,
@@ -33,7 +33,7 @@ class ValueStoreFrontend {
 
   // Retrieves a value from the database asynchronously, passing a copy to
   // |callback| when ready. NULL is passed if no matching entry is found.
-  void Get(const std::string& key, const ReadCallback& callback);
+  void Get(const std::string& key, ReadCallback callback);
 
   // Sets a value with the given key.
   void Set(const std::string& key, std::unique_ptr<base::Value> value);