Convert extensions tests from base::Closure

This CL converts a pattern in extensions tests where a RunLoop quit
closure is bound to a callback argument. In most of these cases we can
simply convert to a OnceClosure.

printer_provider_apitest has one exception that's a RepeatingClosure
because the API actually may call the callback multiple times. In this
case, the quit closure must be copied so it must be a RepeatingClosure.

Bug: 1152268
Change-Id: I4a201cbd78d818f1793b94a8c106d62bb59ba8f9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2605647
Commit-Queue: David Bokan <bokan@chromium.org>
Reviewed-by: Karan Bhatia <karandeepb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#840314}

extensions/browser/api/lock_screen_data/data_item_unittest.cc

@@ -48,32 +48,32 @@ void ReadCallbackNotCalled(const std::string& message,
   ADD_FAILURE() << "Unexpected callback " << message;
 }
 
-void WriteCallback(const base::Closure& callback,
+void WriteCallback(base::OnceClosure callback,
                    OperationResult* result_out,
                    OperationResult result) {
   *result_out = result;
-  callback.Run();
+  std::move(callback).Run();
 }
 
-void ReadCallback(const base::Closure& callback,
+void ReadCallback(base::OnceClosure callback,
                   OperationResult* result_out,
                   std::unique_ptr<std::vector<char>>* content_out,
                   OperationResult result,
                   std::unique_ptr<std::vector<char>> content) {
   *result_out = result;
   *content_out = std::move(content);
-  callback.Run();
+  std::move(callback).Run();
 }
 
 void GetRegisteredItemsCallback(
-    const base::Closure& callback,
+    base::OnceClosure callback,
     OperationResult* result_out,
     std::unique_ptr<base::DictionaryValue>* value_out,
     OperationResult result,
     std::unique_ptr<base::DictionaryValue> value) {
   *result_out = result;
   *value_out = std::move(value);
-  callback.Run();
+  std::move(callback).Run();
 }
 
 }  // namespace
@@ -558,8 +558,9 @@ TEST_F(DataItemTest, RepeatedWrite) {
   std::vector<char> first_write = {'f', 'i', 'l', 'e', '_', '1'};
   std::vector<char> second_write = {'f', 'i', 'l', 'e', '_', '2'};
 
-  writer->Write(first_write, base::BindOnce(&WriteCallback, base::DoNothing(),
-                                            &write_result));
+  writer->Write(
+      first_write,
+      base::BindOnce(&WriteCallback, base::DoNothing::Once(), &write_result));
   EXPECT_EQ(OperationResult::kSuccess,
             WriteItemAndWaitForResult(writer.get(), second_write));
 

extensions/browser/api/lock_screen_data/lock_screen_value_store_migrator_impl_unittest.cc

@@ -47,32 +47,32 @@ void ExpectNotRun(const std::string& message) {
   ADD_FAILURE() << "Unexpectedly run: " << message;
 }
 
-void WriteCallback(const base::Closure& callback,
+void WriteCallback(base::OnceClosure callback,
                    OperationResult* result_out,
                    OperationResult result) {
   *result_out = result;
-  callback.Run();
+  std::move(callback).Run();
 }
 
-void ReadCallback(const base::Closure& callback,
+void ReadCallback(base::OnceClosure callback,
                   OperationResult* result_out,
                   std::unique_ptr<std::vector<char>>* content_out,
                   OperationResult result,
                   std::unique_ptr<std::vector<char>> content) {
   *result_out = result;
   *content_out = std::move(content);
-  callback.Run();
+  std::move(callback).Run();
 }
 
 void GetRegisteredItemsCallback(
-    const base::Closure& callback,
+    base::OnceClosure callback,
     OperationResult* result_out,
     std::unique_ptr<base::DictionaryValue>* value_out,
     OperationResult result,
     std::unique_ptr<base::DictionaryValue> value) {
   *result_out = result;
   *value_out = std::move(value);
-  callback.Run();
+  std::move(callback).Run();
 }
 
 }  // namespace

extensions/browser/api/media_perception_private/media_perception_api_manager_unittest.cc

@@ -84,11 +84,11 @@ class TestUpstartClient : public chromeos::FakeUpstartClient {
 };
 
 void RecordServiceErrorFromStateAndRunClosure(
-    base::Closure quit_run_loop,
+    base::OnceClosure quit_run_loop,
     media_perception::ServiceError* service_error,
     media_perception::State result_state) {
   *service_error = result_state.service_error;
-  quit_run_loop.Run();
+  std::move(quit_run_loop).Run();
 }
 
 void RecordServiceErrorFromProcessStateAndRunClosure(
@@ -100,11 +100,11 @@ void RecordServiceErrorFromProcessStateAndRunClosure(
 }
 
 void RecordServiceErrorFromDiagnosticsAndRunClosure(
-    base::Closure quit_run_loop,
+    base::OnceClosure quit_run_loop,
     media_perception::ServiceError* service_error,
     media_perception::Diagnostics result_diagnostics) {
   *service_error = result_diagnostics.service_error;
-  quit_run_loop.Run();
+  std::move(quit_run_loop).Run();
 }
 
 media_perception::ServiceError SetStateAndWaitForResponse(

extensions/browser/api/printer_provider/printer_provider_apitest.cc

@@ -37,7 +37,7 @@ namespace {
 // It appends items in |printers| to |*printers_out|. If |done| is set, it runs
 // |callback|.
 void AppendPrintersAndRunCallbackIfDone(base::ListValue* printers_out,
-                                        const base::Closure& callback,
+                                        base::RepeatingClosure callback,
                                         const base::ListValue& printers,
                                         bool done) {
   for (size_t i = 0; i < printers.GetSize(); ++i) {
@@ -48,42 +48,42 @@ void AppendPrintersAndRunCallbackIfDone(base::ListValue* printers_out,
       printers_out->Append(printer->CreateDeepCopy());
   }
   if (done && !callback.is_null())
-    callback.Run();
+    std::move(callback).Run();
 }
 
 // Callback for PrinterProviderAPI::DispatchPrintRequested calls.
 // It fills the out params based on |status| and runs |callback|.
 void RecordPrintResultAndRunCallback(bool* result_success,
                                      std::string* result_status,
-                                     const base::Closure& callback,
+                                     base::OnceClosure callback,
                                      const base::Value& status) {
   bool success = status.is_none();
   std::string status_str = success ? "OK" : status.GetString();
   *result_success = success;
   *result_status = status_str;
-  if (callback)
-    callback.Run();
+  if (!callback.is_null())
+    std::move(callback).Run();
 }
 
 // Callback for PrinterProviderAPI::DispatchGetCapabilityRequested calls.
 // It saves reported |value| as JSON string to |*result| and runs |callback|.
 void RecordDictAndRunCallback(std::string* result,
-                              const base::Closure& callback,
+                              base::OnceClosure callback,
                               const base::DictionaryValue& value) {
   JSONStringValueSerializer serializer(result);
   EXPECT_TRUE(serializer.Serialize(value));
   if (!callback.is_null())
-    callback.Run();
+    std::move(callback).Run();
 }
 
 // Callback for PrinterProvider::DispatchGrantUsbPrinterAccess calls.
 // It expects |value| to equal |expected_value| and runs |callback|.
 void ExpectValueAndRunCallback(const base::Value* expected_value,
-                               const base::Closure& callback,
+                               base::OnceClosure callback,
                                const base::DictionaryValue& value) {
   EXPECT_TRUE(value.Equals(expected_value));
   if (!callback.is_null())
-    callback.Run();
+    std::move(callback).Run();
 }
 
 // Tests for chrome.printerProvider API.

extensions/browser/guest_view/web_view/web_view_apitest.cc

@@ -93,11 +93,10 @@ static std::unique_ptr<net::test_server::HttpResponse> UserAgentResponseHandler(
 class WebContentsHiddenObserver : public content::WebContentsObserver {
  public:
   WebContentsHiddenObserver(content::WebContents* web_contents,
-                            const base::Closure& hidden_callback)
+                            base::RepeatingClosure hidden_callback)
       : WebContentsObserver(web_contents),
-        hidden_callback_(hidden_callback),
-        hidden_observed_(false) {
-  }
+        hidden_callback_(std::move(hidden_callback)),
+        hidden_observed_(false) {}
 
   // WebContentsObserver.
   void OnVisibilityChanged(content::Visibility visibility) override {
@@ -110,7 +109,7 @@ class WebContentsHiddenObserver : public content::WebContentsObserver {
   bool hidden_observed() { return hidden_observed_; }
 
  private:
-  base::Closure hidden_callback_;
+  base::RepeatingClosure hidden_callback_;
   bool hidden_observed_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsHiddenObserver);

extensions/browser/test_image_loader.cc

@@ -11,9 +11,9 @@
 
 namespace extensions {
 
-TestImageLoader::TestImageLoader() : waiting_(false), image_loaded_(false) {}
+TestImageLoader::TestImageLoader() = default;
 
-TestImageLoader::~TestImageLoader() {}
+TestImageLoader::~TestImageLoader() = default;
 
 // static
 SkBitmap TestImageLoader::LoadAndGetExtensionBitmap(
@@ -28,7 +28,7 @@ void TestImageLoader::OnImageLoaded(const gfx::Image& image) {
   image_ = image;
   image_loaded_ = true;
   if (waiting_)
-    loader_message_loop_quit_.Run();
+    std::move(loader_message_loop_quit_).Run();
 }
 
 SkBitmap TestImageLoader::LoadAndGetBitmap(const Extension* extension,

extensions/browser/test_image_loader.h

@@ -33,9 +33,9 @@ class TestImageLoader {
                             int size);
 
   gfx::Image image_;
-  base::Closure loader_message_loop_quit_;
-  bool waiting_;
-  bool image_loaded_;
+  base::OnceClosure loader_message_loop_quit_;
+  bool waiting_ = false;
+  bool image_loaded_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(TestImageLoader);
 };