Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/{a,b,c,d,e,f,g}*

chrome/browser/after_startup_task_utils_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/after_startup_task_utils.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 87 matching lines @@
   // Hop to the db thread and call PostAfterStartupTask.
   void PostAfterStartupTaskFromDBThread(
       const tracked_objects::Location& from_here,
       const scoped_refptr<base::TaskRunner>& task_runner,
       base::OnceClosure task) {
     RunLoop run_loop;
     db_thread_->real_runner()->PostTaskAndReply(
         FROM_HERE,
         base::BindOnce(&AfterStartupTaskUtils::PostTask, from_here, task_runner,
                        std::move(task)),
-        base::Bind(&RunLoop::Quit, base::Unretained(&run_loop)));
+        base::BindOnce(&RunLoop::Quit, base::Unretained(&run_loop)));
     run_loop.Run();
   }
 
   // Make sure all tasks posted to the DB thread get run.
   void FlushDBThread() {
     RunLoop run_loop;
     db_thread_->real_runner()->PostTaskAndReply(
-        FROM_HERE, base::Bind(&base::DoNothing),
-        base::Bind(&RunLoop::Quit, base::Unretained(&run_loop)));
+        FROM_HERE, base::BindOnce(&base::DoNothing),
+        base::BindOnce(&RunLoop::Quit, base::Unretained(&run_loop)));
     run_loop.Run();
   }
 
   static void VerifyExpectedThread(BrowserThread::ID id) {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(id));
   }
 
  protected:
   scoped_refptr<WrappedTaskRunner> ui_thread_;
   scoped_refptr<WrappedTaskRunner> db_thread_;
@@ skipping 19 matching lines @@
   AfterStartupTaskUtils::SetBrowserStartupIsCompleteForTesting();
   EXPECT_TRUE(AfterStartupTaskUtils::IsBrowserStartupComplete());
   EXPECT_TRUE(GetIsBrowserStartupCompleteFromDBThread());
 }
 
 TEST_F(AfterStartupTaskTest, PostTask) {
   // Nothing should be posted prior to startup completion.
   EXPECT_FALSE(AfterStartupTaskUtils::IsBrowserStartupComplete());
   AfterStartupTaskUtils::PostTask(
       FROM_HERE, ui_thread_,
-      base::Bind(&AfterStartupTaskTest::VerifyExpectedThread,
-                 BrowserThread::UI));
+      base::BindOnce(&AfterStartupTaskTest::VerifyExpectedThread,
+                     BrowserThread::UI));
   AfterStartupTaskUtils::PostTask(
       FROM_HERE, db_thread_,
-      base::Bind(&AfterStartupTaskTest::VerifyExpectedThread,
-                 BrowserThread::DB));
+      base::BindOnce(&AfterStartupTaskTest::VerifyExpectedThread,
+                     BrowserThread::DB));
   PostAfterStartupTaskFromDBThread(
       FROM_HERE, ui_thread_,
-      base::Bind(&AfterStartupTaskTest::VerifyExpectedThread,
-                 BrowserThread::UI));
+      base::BindOnce(&AfterStartupTaskTest::VerifyExpectedThread,
+                     BrowserThread::UI));
   PostAfterStartupTaskFromDBThread(
       FROM_HERE, db_thread_,
-      base::Bind(&AfterStartupTaskTest::VerifyExpectedThread,
-                 BrowserThread::DB));
+      base::BindOnce(&AfterStartupTaskTest::VerifyExpectedThread,
+                     BrowserThread::DB));
   RunLoop().RunUntilIdle();
   EXPECT_EQ(0, db_thread_->total_task_count() + ui_thread_->total_task_count());
 
   // Queued tasks should be posted upon setting the flag.
   AfterStartupTaskUtils::SetBrowserStartupIsCompleteForTesting();
   EXPECT_EQ(2, db_thread_->posted_task_count());
   EXPECT_EQ(2, ui_thread_->posted_task_count());
   FlushDBThread();
   RunLoop().RunUntilIdle();
   EXPECT_EQ(2, db_thread_->ran_task_count());
   EXPECT_EQ(2, ui_thread_->ran_task_count());
 
   db_thread_->reset_task_counts();
   ui_thread_->reset_task_counts();
   EXPECT_EQ(0, db_thread_->total_task_count() + ui_thread_->total_task_count());
 
   // Tasks posted after startup should get posted immediately.
   AfterStartupTaskUtils::PostTask(FROM_HERE, ui_thread_,
-                                  base::Bind(&base::DoNothing));
+                                  base::BindOnce(&base::DoNothing));
   AfterStartupTaskUtils::PostTask(FROM_HERE, db_thread_,
-                                  base::Bind(&base::DoNothing));
+                                  base::BindOnce(&base::DoNothing));
   EXPECT_EQ(1, db_thread_->posted_task_count());
   EXPECT_EQ(1, ui_thread_->posted_task_count());
   PostAfterStartupTaskFromDBThread(FROM_HERE, ui_thread_,
-                                   base::Bind(&base::DoNothing));
+                                   base::BindOnce(&base::DoNothing));
   PostAfterStartupTaskFromDBThread(FROM_HERE, db_thread_,
-                                   base::Bind(&base::DoNothing));
+                                   base::BindOnce(&base::DoNothing));
   EXPECT_EQ(2, db_thread_->posted_task_count());
   EXPECT_EQ(2, ui_thread_->posted_task_count());
   FlushDBThread();
   RunLoop().RunUntilIdle();
   EXPECT_EQ(2, db_thread_->ran_task_count());
   EXPECT_EQ(2, ui_thread_->ran_task_count());
 }
 
 // Verify that posting to an AfterStartupTaskUtils::Runner bound to |db_thread_|
 // results in the same behavior as posting via
 // AfterStartupTaskUtils::PostTask(..., db_thread_, ...).
 TEST_F(AfterStartupTaskTest, AfterStartupTaskUtilsRunner) {
   scoped_refptr<base::TaskRunner> after_startup_runner =
       make_scoped_refptr(new AfterStartupTaskUtils::Runner(db_thread_));
 
   EXPECT_FALSE(AfterStartupTaskUtils::IsBrowserStartupComplete());
   after_startup_runner->PostTask(
-      FROM_HERE, base::Bind(&AfterStartupTaskTest::VerifyExpectedThread,
-                            BrowserThread::DB));
+      FROM_HERE, base::BindOnce(&AfterStartupTaskTest::VerifyExpectedThread,
+                                BrowserThread::DB));
 
   RunLoop().RunUntilIdle();
   EXPECT_FALSE(AfterStartupTaskUtils::IsBrowserStartupComplete());
   EXPECT_EQ(0, db_thread_->total_task_count());
 
   AfterStartupTaskUtils::SetBrowserStartupIsCompleteForTesting();
   EXPECT_EQ(1, db_thread_->posted_task_count());
 
   FlushDBThread();
   RunLoop().RunUntilIdle();
   EXPECT_EQ(1, db_thread_->ran_task_count());
 
   EXPECT_EQ(0, ui_thread_->total_task_count());
 }