Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/{i,l,m,n,p,r}*

chrome/browser/process_singleton_posix_unittest.cc

 // Copyright 2014 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/process_singleton.h"
 
 #include <fcntl.h>
 #include <limits.h>
 #include <signal.h>
 #include <stddef.h>
@@ skipping 87 matching lines @@
   void TearDown() override {
     scoped_refptr<base::ThreadTestHelper> io_helper(new base::ThreadTestHelper(
         BrowserThread::GetTaskRunnerForThread(BrowserThread::IO).get()));
     ASSERT_TRUE(io_helper->Run());
 
     // Destruct the ProcessSingleton object before the IO thread so that its
     // internals are destructed properly.
     if (process_singleton_on_thread_) {
       worker_thread_->task_runner()->PostTask(
           FROM_HERE,
-          base::Bind(&ProcessSingletonPosixTest::DestructProcessSingleton,
-                     base::Unretained(this)));
+          base::BindOnce(&ProcessSingletonPosixTest::DestructProcessSingleton,
+                         base::Unretained(this)));
 
       scoped_refptr<base::ThreadTestHelper> helper(
           new base::ThreadTestHelper(worker_thread_->task_runner().get()));
       ASSERT_TRUE(helper->Run());
     }
 
     io_thread_.Stop();
     testing::Test::TearDown();
   }
 
   void CreateProcessSingletonOnThread() {
     ASSERT_EQ(NULL, worker_thread_.get());
     worker_thread_.reset(new base::Thread("BlockingThread"));
     worker_thread_->Start();
 
     worker_thread_->task_runner()->PostTask(
         FROM_HERE,
-        base::Bind(&ProcessSingletonPosixTest::CreateProcessSingletonInternal,
-                   base::Unretained(this)));
+        base::BindOnce(
+            &ProcessSingletonPosixTest::CreateProcessSingletonInternal,
+            base::Unretained(this)));
 
     scoped_refptr<base::ThreadTestHelper> helper(
         new base::ThreadTestHelper(worker_thread_->task_runner().get()));
     ASSERT_TRUE(helper->Run());
   }
 
   TestableProcessSingleton* CreateProcessSingleton() {
     return new TestableProcessSingleton(user_data_path_);
   }
 
@@ skipping 68 matching lines @@
         found = true;
         break;
       }
     }
     ASSERT_TRUE(found);
     ASSERT_EQ(0, kill_callbacks_);
   }
 
   void BlockWorkerThread() {
     worker_thread_->task_runner()->PostTask(
-        FROM_HERE, base::Bind(&ProcessSingletonPosixTest::BlockThread,
-                              base::Unretained(this)));
+        FROM_HERE, base::BindOnce(&ProcessSingletonPosixTest::BlockThread,
+                                  base::Unretained(this)));
   }
 
   void UnblockWorkerThread() {
     wait_event_.Signal();  // Unblock the worker thread for shutdown.
     signal_event_.Wait();  // Ensure thread unblocks before continuing.
   }
 
   void BlockThread() {
     wait_event_.Wait();
     signal_event_.Signal();
@@ skipping 216 matching lines @@
 // Test that if there is an existing lock file, and it's not locked, we replace
 // it.
 TEST_F(ProcessSingletonPosixTest, CreateReplacesOldMacLock) {
   std::unique_ptr<TestableProcessSingleton> process_singleton(
       CreateProcessSingleton());
   EXPECT_EQ(0, base::WriteFile(lock_path_, "", 0));
   EXPECT_TRUE(process_singleton->Create());
   VerifyFiles();
 }
 #endif  // defined(OS_MACOSX)