Migrate Bind to BindOnce or BindRepeating in //base/message_loop

base/message_loop/message_loop_unittest.cc

 // Copyright 2013 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 <stddef.h>
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 93 matching lines @@
         android::JavaHandlerThreadForTesting::CreateJavaFirst(&test_done_event);
   } else {
     java_thread = android::JavaHandlerThreadForTesting::Create(
         "JavaHandlerThreadForTesting from AbortDontRunMoreTasks",
         &test_done_event);
   }
   java_thread->Start();
 
   if (delayed) {
     java_thread->message_loop()->task_runner()->PostDelayedTask(
-        FROM_HERE, Bind(&AbortMessagePump), TimeDelta::FromMilliseconds(10));
+        FROM_HERE, BindOnce(&AbortMessagePump),
+        TimeDelta::FromMilliseconds(10));
   } else {
     java_thread->message_loop()->task_runner()->PostTask(
-        FROM_HERE, Bind(&AbortMessagePump));
+        FROM_HERE, BindOnce(&AbortMessagePump));
   }
 
   // Wait to ensure we catch the correct exception (and don't crash)
   test_done_event.Wait();
 
   java_thread->Stop();
   java_thread.reset();
 }
 
 TEST(MessageLoopTest, JavaExceptionAbort) {
@@ skipping 47 matching lines @@
   MessageLoop message_loop(MessageLoop::TYPE_UI);
 
   // Test that the interval of the timer, used to run the next delayed task, is
   // set to a value corresponding to when the next delayed task should run.
 
   // By setting num_tasks to 1, we ensure that the first task to run causes the
   // run loop to exit.
   int num_tasks = 1;
   Time run_time;
 
-  message_loop.task_runner()->PostTask(FROM_HERE, Bind(&SubPumpFunc));
+  message_loop.task_runner()->PostTask(FROM_HERE, BindOnce(&SubPumpFunc));
 
   // This very delayed task should never run.
   message_loop.task_runner()->PostDelayedTask(
-      FROM_HERE, Bind(&RecordRunTimeFunc, &run_time, &num_tasks),
+      FROM_HERE, BindOnce(&RecordRunTimeFunc, &run_time, &num_tasks),
       TimeDelta::FromSeconds(1000));
 
   // This slightly delayed task should run from within SubPumpFunc.
-  message_loop.task_runner()->PostDelayedTask(
-      FROM_HERE, Bind(&PostQuitMessage, 0), TimeDelta::FromMilliseconds(10));
+  message_loop.task_runner()->PostDelayedTask(FROM_HERE,
+                                              BindOnce(&PostQuitMessage, 0),
+                                              TimeDelta::FromMilliseconds(10));
 
   Time start_time = Time::Now();
 
   RunLoop().Run();
   EXPECT_EQ(1, num_tasks);
 
   // Ensure that we ran in far less time than the slower timer.
   TimeDelta total_time = Time::Now() - start_time;
   EXPECT_GT(5000, total_time.InMilliseconds());
 
@@ skipping 112 matching lines @@
 }
 
 void RecursiveFunc(TaskList* order, int cookie, int depth,
                    bool is_reentrant) {
   order->RecordStart(RECURSIVE, cookie);
   if (depth > 0) {
     if (is_reentrant)
       MessageLoop::current()->SetNestableTasksAllowed(true);
     ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
-        Bind(&RecursiveFunc, order, cookie, depth - 1, is_reentrant));
+        BindOnce(&RecursiveFunc, order, cookie, depth - 1, is_reentrant));
   }
   order->RecordEnd(RECURSIVE, cookie);
 }
 
 void QuitFunc(TaskList* order, int cookie) {
   order->RecordStart(QUITMESSAGELOOP, cookie);
   MessageLoop::current()->QuitWhenIdle();
   order->RecordEnd(QUITMESSAGELOOP, cookie);
 }
 
 void RecursiveFuncWin(scoped_refptr<SingleThreadTaskRunner> task_runner,
                       HANDLE event,
                       bool expect_window,
                       TaskList* order,
                       bool is_reentrant) {
   task_runner->PostTask(FROM_HERE,
-                        Bind(&RecursiveFunc, order, 1, 2, is_reentrant));
+                        BindOnce(&RecursiveFunc, order, 1, 2, is_reentrant));
   task_runner->PostTask(FROM_HERE,
-                        Bind(&MessageBoxFunc, order, 2, is_reentrant));
+                        BindOnce(&MessageBoxFunc, order, 2, is_reentrant));
   task_runner->PostTask(FROM_HERE,
-                        Bind(&RecursiveFunc, order, 3, 2, is_reentrant));
+                        BindOnce(&RecursiveFunc, order, 3, 2, is_reentrant));
   // The trick here is that for recursive task processing, this task will be
   // ran _inside_ the MessageBox message loop, dismissing the MessageBox
   // without a chance.
   // For non-recursive task processing, this will be executed _after_ the
   // MessageBox will have been dismissed by the code below, where
   // expect_window_ is true.
-  task_runner->PostTask(FROM_HERE, Bind(&EndDialogFunc, order, 4));
-  task_runner->PostTask(FROM_HERE, Bind(&QuitFunc, order, 5));
+  task_runner->PostTask(FROM_HERE, BindOnce(&EndDialogFunc, order, 4));
+  task_runner->PostTask(FROM_HERE, BindOnce(&QuitFunc, order, 5));
 
   // Enforce that every tasks are sent before starting to run the main thread
   // message loop.
   ASSERT_TRUE(SetEvent(event));
 
   // Poll for the MessageBox. Don't do this at home! At the speed we do it,
   // you will never realize one MessageBox was shown.
   for (; expect_window;) {
     HWND window = FindWindow(L"#32770", kMessageBoxTitle);
     if (window) {
@@ skipping 18 matching lines @@
 void RunTest_RecursiveDenial2(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   Thread worker("RecursiveDenial2_worker");
   Thread::Options options;
   options.message_loop_type = message_loop_type;
   ASSERT_EQ(true, worker.StartWithOptions(options));
   TaskList order;
   win::ScopedHandle event(CreateEvent(NULL, FALSE, FALSE, NULL));
   worker.task_runner()->PostTask(
-      FROM_HERE, Bind(&RecursiveFuncWin, ThreadTaskRunnerHandle::Get(),
-                      event.Get(), true, &order, false));
+      FROM_HERE, BindOnce(&RecursiveFuncWin, ThreadTaskRunnerHandle::Get(),
+                          event.Get(), true, &order, false));
   // Let the other thread execute.
   WaitForSingleObject(event.Get(), INFINITE);
   RunLoop().Run();
 
   ASSERT_EQ(17u, order.Size());
   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(2), TaskItem(MESSAGEBOX, 2, true));
   EXPECT_EQ(order.Get(3), TaskItem(MESSAGEBOX, 2, false));
   EXPECT_EQ(order.Get(4), TaskItem(RECURSIVE, 3, true));
@@ skipping 18 matching lines @@
 void RunTest_RecursiveSupport2(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   Thread worker("RecursiveSupport2_worker");
   Thread::Options options;
   options.message_loop_type = message_loop_type;
   ASSERT_EQ(true, worker.StartWithOptions(options));
   TaskList order;
   win::ScopedHandle event(CreateEvent(NULL, FALSE, FALSE, NULL));
   worker.task_runner()->PostTask(
-      FROM_HERE, Bind(&RecursiveFuncWin, ThreadTaskRunnerHandle::Get(),
-                      event.Get(), false, &order, true));
+      FROM_HERE, BindOnce(&RecursiveFuncWin, ThreadTaskRunnerHandle::Get(),
+                          event.Get(), false, &order, true));
   // Let the other thread execute.
   WaitForSingleObject(event.Get(), INFINITE);
   RunLoop().Run();
 
   ASSERT_EQ(18u, order.Size());
   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(2), TaskItem(MESSAGEBOX, 2, true));
   // Note that this executes in the MessageBox modal loop.
   EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 3, true));
   EXPECT_EQ(order.Get(4), TaskItem(RECURSIVE, 3, false));
   EXPECT_EQ(order.Get(5), TaskItem(ENDDIALOG, 4, true));
   EXPECT_EQ(order.Get(6), TaskItem(ENDDIALOG, 4, false));
   EXPECT_EQ(order.Get(7), TaskItem(MESSAGEBOX, 2, false));
   /* The order can subtly change here. The reason is that when RecursiveFunc(1)
      is called in the main thread, if it is faster than getting to the
-     PostTask(FROM_HERE, Bind(&QuitFunc) execution, the order of task
+     PostTask(FROM_HERE, BindOnce(&QuitFunc) execution, the order of task
      execution can change. We don't care anyway that the order isn't correct.
   EXPECT_EQ(order.Get(8), TaskItem(QUITMESSAGELOOP, 5, true));
   EXPECT_EQ(order.Get(9), TaskItem(QUITMESSAGELOOP, 5, false));
   EXPECT_EQ(order.Get(10), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(11), TaskItem(RECURSIVE, 1, false));
   */
   EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 3, true));
   EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 3, false));
   EXPECT_EQ(order.Get(14), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(15), TaskItem(RECURSIVE, 1, false));
@@ skipping 74 matching lines @@
       CreateNamedPipe(kPipeName, PIPE_ACCESS_OUTBOUND, 0, 1, 0, 0, 0, NULL));
   ASSERT_TRUE(server.IsValid());
 
   Thread thread("IOHandler test");
   Thread::Options options;
   options.message_loop_type = MessageLoop::TYPE_IO;
   ASSERT_TRUE(thread.StartWithOptions(options));
 
   TestIOHandler handler(kPipeName, callback_called.Get(), false);
   thread.task_runner()->PostTask(
-      FROM_HERE, Bind(&TestIOHandler::Init, Unretained(&handler)));
+      FROM_HERE, BindOnce(&TestIOHandler::Init, Unretained(&handler)));
   // Make sure the thread runs and sleeps for lack of work.
   PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
 
   const char buffer[] = "Hello there!";
   DWORD written;
   EXPECT_TRUE(WriteFile(server.Get(), buffer, sizeof(buffer), &written, NULL));
 
   DWORD result = WaitForSingleObject(callback_called.Get(), 1000);
   EXPECT_EQ(WAIT_OBJECT_0, result);
 
@@ skipping 18 matching lines @@
   ASSERT_TRUE(server2.IsValid());
 
   Thread thread("IOHandler test");
   Thread::Options options;
   options.message_loop_type = MessageLoop::TYPE_IO;
   ASSERT_TRUE(thread.StartWithOptions(options));
 
   TestIOHandler handler1(kPipeName1, callback1_called.Get(), false);
   TestIOHandler handler2(kPipeName2, callback2_called.Get(), true);
   thread.task_runner()->PostTask(
-      FROM_HERE, Bind(&TestIOHandler::Init, Unretained(&handler1)));
+      FROM_HERE, BindOnce(&TestIOHandler::Init, Unretained(&handler1)));
   // TODO(ajwong): Do we really need such long Sleeps in this function?
   // Make sure the thread runs and sleeps for lack of work.
   TimeDelta delay = TimeDelta::FromMilliseconds(100);
   PlatformThread::Sleep(delay);
   thread.task_runner()->PostTask(
-      FROM_HERE, Bind(&TestIOHandler::Init, Unretained(&handler2)));
+      FROM_HERE, BindOnce(&TestIOHandler::Init, Unretained(&handler2)));
   PlatformThread::Sleep(delay);
 
   // At this time handler1 is waiting to be called, and the thread is waiting
   // on the Init method of handler2, filtering only handler2 callbacks.
 
   const char buffer[] = "Hello there!";
   DWORD written;
   EXPECT_TRUE(WriteFile(server1.Get(), buffer, sizeof(buffer), &written, NULL));
   PlatformThread::Sleep(2 * delay);
   EXPECT_EQ(static_cast<DWORD>(WAIT_TIMEOUT),
@@ skipping 99 matching lines @@
 TEST(MessageLoopTest, HighResolutionTimer) {
   MessageLoop message_loop;
   Time::EnableHighResolutionTimer(true);
 
   const TimeDelta kFastTimer = TimeDelta::FromMilliseconds(5);
   const TimeDelta kSlowTimer = TimeDelta::FromMilliseconds(100);
 
   EXPECT_FALSE(message_loop.HasHighResolutionTasks());
   // Post a fast task to enable the high resolution timers.
   message_loop.task_runner()->PostDelayedTask(
-      FROM_HERE, Bind(&PostNTasksThenQuit, 1), kFastTimer);
+      FROM_HERE, BindOnce(&PostNTasksThenQuit, 1), kFastTimer);
   EXPECT_TRUE(message_loop.HasHighResolutionTasks());
   RunLoop().Run();
   EXPECT_FALSE(message_loop.HasHighResolutionTasks());
   EXPECT_FALSE(Time::IsHighResolutionTimerInUse());
   // Check that a slow task does not trigger the high resolution logic.
   message_loop.task_runner()->PostDelayedTask(
-      FROM_HERE, Bind(&PostNTasksThenQuit, 1), kSlowTimer);
+      FROM_HERE, BindOnce(&PostNTasksThenQuit, 1), kSlowTimer);
   EXPECT_FALSE(message_loop.HasHighResolutionTasks());
   RunLoop().Run();
   EXPECT_FALSE(message_loop.HasHighResolutionTasks());
   Time::EnableHighResolutionTimer(false);
 }
 
 #endif  // defined(OS_WIN)
 
 #if defined(OS_POSIX) && !defined(OS_NACL)
 
@@ skipping 169 matching lines @@
   EXPECT_TRUE(loop.IsType(MessageLoop::TYPE_UI));
   EXPECT_FALSE(loop.IsType(MessageLoop::TYPE_IO));
   EXPECT_FALSE(loop.IsType(MessageLoop::TYPE_DEFAULT));
 }
 
 #if defined(OS_WIN)
 void EmptyFunction() {}
 
 void PostMultipleTasks() {
   ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                          base::Bind(&EmptyFunction));
+                                          base::BindOnce(&EmptyFunction));
   ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                          base::Bind(&EmptyFunction));
+                                          base::BindOnce(&EmptyFunction));
 }
 
 static const int kSignalMsg = WM_USER + 2;
 
 void PostWindowsMessage(HWND message_hwnd) {
   PostMessage(message_hwnd, kSignalMsg, 0, 2);
 }
 
 void EndTest(bool* did_run, HWND hwnd) {
   *did_run = true;
   PostMessage(hwnd, WM_CLOSE, 0, 0);
 }
 
 int kMyMessageFilterCode = 0x5002;
 
 LRESULT CALLBACK TestWndProcThunk(HWND hwnd, UINT message,
                                   WPARAM wparam, LPARAM lparam) {
   if (message == WM_CLOSE)
     EXPECT_TRUE(DestroyWindow(hwnd));
   if (message != kSignalMsg)
     return DefWindowProc(hwnd, message, wparam, lparam);
 
   switch (lparam) {
   case 1:
     // First, we post a task that will post multiple no-op tasks to make sure
     // that the pump's incoming task queue does not become empty during the
     // test.
     ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                            base::Bind(&PostMultipleTasks));
+                                            base::BindOnce(&PostMultipleTasks));
     // Next, we post a task that posts a windows message to trigger the second
     // stage of the test.
     ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(&PostWindowsMessage, hwnd));
+        FROM_HERE, base::BindOnce(&PostWindowsMessage, hwnd));
     break;
   case 2:
     // Since we're about to enter a modal loop, tell the message loop that we
     // intend to nest tasks.
     MessageLoop::current()->SetNestableTasksAllowed(true);
     bool did_run = false;
     ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(&EndTest, &did_run, hwnd));
+        FROM_HERE, base::BindOnce(&EndTest, &did_run, hwnd));
     // Run a nested windows-style message loop and verify that our task runs. If
     // it doesn't, then we'll loop here until the test times out.
     MSG msg;
     while (GetMessage(&msg, 0, 0, 0)) {
       if (!CallMsgFilter(&msg, kMyMessageFilterCode))
         DispatchMessage(&msg);
       // If this message is a WM_CLOSE, explicitly exit the modal loop. Posting
       // a WM_QUIT should handle this, but unfortunately MessagePumpWin eats
       // WM_QUIT messages even when running inside a modal loop.
       if (msg.message == WM_CLOSE)
@@ skipping 71 matching lines @@
 
   {
     std::string kThreadName("bar");
     base::Thread thread(kThreadName);
     ASSERT_TRUE(thread.StartAndWaitForTesting());
     EXPECT_EQ(kThreadName, thread.message_loop()->GetThreadName());
   }
 }
 
 }  // namespace base