Rewrite base::Bind into base::BindOnce on trivial cases in base

base/message_loop/message_pump_glib_unittest.cc

 // Copyright (c) 2012 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 "base/message_loop/message_pump_glib.h"
 
 #include <glib.h>
 #include <math.h>
 
 #include <algorithm>
@@ skipping 219 matching lines @@
   RunLoop().Run();
   EXPECT_EQ(4, injector()->processed_events());
 }
 
 TEST_F(MessagePumpGLibTest, TestWorkWhileWaitingForEvents) {
   int task_count = 0;
   // Tests that we process tasks while waiting for new events.
   // The event queue is empty at first.
   for (int i = 0; i < 10; ++i) {
     loop()->task_runner()->PostTask(FROM_HERE,
-                                    Bind(&IncrementInt, &task_count));
+                                    BindOnce(&IncrementInt, &task_count));
   }
   // After all the previous tasks have executed, enqueue an event that will
   // quit.
   loop()->task_runner()->PostTask(
-      FROM_HERE, Bind(&EventInjector::AddEvent, Unretained(injector()), 0,
-                      MessageLoop::QuitWhenIdleClosure()));
+      FROM_HERE, BindOnce(&EventInjector::AddEvent, Unretained(injector()), 0,
+                          MessageLoop::QuitWhenIdleClosure()));
   RunLoop().Run();
   ASSERT_EQ(10, task_count);
   EXPECT_EQ(1, injector()->processed_events());
 
   // Tests that we process delayed tasks while waiting for new events.
   injector()->Reset();
   task_count = 0;
   for (int i = 0; i < 10; ++i) {
     loop()->task_runner()->PostDelayedTask(FROM_HERE,
-                                           Bind(&IncrementInt, &task_count),
+                                           BindOnce(&IncrementInt, &task_count),
                                            TimeDelta::FromMilliseconds(10 * i));
   }
   // After all the previous tasks have executed, enqueue an event that will
   // quit.
   // This relies on the fact that delayed tasks are executed in delay order.
   // That is verified in message_loop_unittest.cc.
   loop()->task_runner()->PostDelayedTask(
-      FROM_HERE, Bind(&EventInjector::AddEvent, Unretained(injector()), 10,
-                      MessageLoop::QuitWhenIdleClosure()),
+      FROM_HERE,
+      BindOnce(&EventInjector::AddEvent, Unretained(injector()), 10,
+               MessageLoop::QuitWhenIdleClosure()),
       TimeDelta::FromMilliseconds(150));
   RunLoop().Run();
   ASSERT_EQ(10, task_count);
   EXPECT_EQ(1, injector()->processed_events());
 }
 
 TEST_F(MessagePumpGLibTest, TestEventsWhileWaitingForWork) {
   // Tests that we process events while waiting for work.
   // The event queue is empty at first.
   for (int i = 0; i < 10; ++i) {
@@ skipping 29 matching lines @@
   }
 
   void FromTask() {
     if (task_count_ > 0) {
       --task_count_;
     }
     if (task_count_ == 0 && event_count_ == 0) {
         MessageLoop::current()->QuitWhenIdle();
     } else {
       ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, Bind(&ConcurrentHelper::FromTask, this));
+          FROM_HERE, BindOnce(&ConcurrentHelper::FromTask, this));
     }
   }
 
   void FromEvent() {
     if (event_count_ > 0) {
       --event_count_;
     }
     if (task_count_ == 0 && event_count_ == 0) {
         MessageLoop::current()->QuitWhenIdle();
     } else {
@@ skipping 30 matching lines @@
 
   // Add 2 events to the queue to make sure it is always full (when we remove
   // the event before processing it).
   injector()->AddEventAsTask(
       0, Bind(&ConcurrentHelper::FromEvent, helper));
   injector()->AddEventAsTask(
       0, Bind(&ConcurrentHelper::FromEvent, helper));
 
   // Similarly post 2 tasks.
   loop()->task_runner()->PostTask(
-      FROM_HERE, Bind(&ConcurrentHelper::FromTask, helper));
+      FROM_HERE, BindOnce(&ConcurrentHelper::FromTask, helper));
   loop()->task_runner()->PostTask(
-      FROM_HERE, Bind(&ConcurrentHelper::FromTask, helper));
+      FROM_HERE, BindOnce(&ConcurrentHelper::FromTask, helper));
 
   RunLoop().Run();
   EXPECT_EQ(0, helper->event_count());
   EXPECT_EQ(0, helper->task_count());
 }
 
 namespace {
 
 void AddEventsAndDrainGLib(EventInjector* injector) {
   // Add a couple of dummy events
   injector->AddDummyEvent(0);
   injector->AddDummyEvent(0);
   // Then add an event that will quit the main loop.
   injector->AddEvent(0, MessageLoop::QuitWhenIdleClosure());
 
   // Post a couple of dummy tasks
-  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, Bind(&DoNothing));
-  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, Bind(&DoNothing));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, BindOnce(&DoNothing));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, BindOnce(&DoNothing));
 
   // Drain the events
   while (g_main_context_pending(NULL)) {
     g_main_context_iteration(NULL, FALSE);
   }
 }
 
 }  // namespace
 
 TEST_F(MessagePumpGLibTest, TestDrainingGLib) {
   // Tests that draining events using GLib works.
   loop()->task_runner()->PostTask(
-      FROM_HERE, Bind(&AddEventsAndDrainGLib, Unretained(injector())));
+      FROM_HERE, BindOnce(&AddEventsAndDrainGLib, Unretained(injector())));
   RunLoop().Run();
 
   EXPECT_EQ(3, injector()->processed_events());
 }
 
 namespace {
 
 // Helper class that lets us run the GLib message loop.
 class GLibLoopRunner : public RefCounted<GLibLoopRunner> {
  public:
@@ skipping 31 matching lines @@
   // Allow tasks to be processed from 'native' event loops.
   MessageLoop::current()->SetNestableTasksAllowed(true);
   scoped_refptr<GLibLoopRunner> runner = new GLibLoopRunner();
 
   int task_count = 0;
   // Add a couple of dummy events
   injector->AddDummyEvent(0);
   injector->AddDummyEvent(0);
   // Post a couple of dummy tasks
   ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                          Bind(&IncrementInt, &task_count));
+                                          BindOnce(&IncrementInt, &task_count));
   ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                          Bind(&IncrementInt, &task_count));
+                                          BindOnce(&IncrementInt, &task_count));
   // Delayed events
   injector->AddDummyEvent(10);
   injector->AddDummyEvent(10);
   // Delayed work
   ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, Bind(&IncrementInt, &task_count),
+      FROM_HERE, BindOnce(&IncrementInt, &task_count),
       TimeDelta::FromMilliseconds(30));
   ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, Bind(&GLibLoopRunner::Quit, runner),
+      FROM_HERE, BindOnce(&GLibLoopRunner::Quit, runner),
       TimeDelta::FromMilliseconds(40));
 
   // Run a nested, straight GLib message loop.
   runner->RunGLib();
 
   ASSERT_EQ(3, task_count);
   EXPECT_EQ(4, injector->processed_events());
   MessageLoop::current()->QuitWhenIdle();
 }
 
 void TestGtkLoopInternal(EventInjector* injector) {
   // Allow tasks to be processed from 'native' event loops.
   MessageLoop::current()->SetNestableTasksAllowed(true);
   scoped_refptr<GLibLoopRunner> runner = new GLibLoopRunner();
 
   int task_count = 0;
   // Add a couple of dummy events
   injector->AddDummyEvent(0);
   injector->AddDummyEvent(0);
   // Post a couple of dummy tasks
   ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                          Bind(&IncrementInt, &task_count));
+                                          BindOnce(&IncrementInt, &task_count));
   ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                          Bind(&IncrementInt, &task_count));
+                                          BindOnce(&IncrementInt, &task_count));
   // Delayed events
   injector->AddDummyEvent(10);
   injector->AddDummyEvent(10);
   // Delayed work
   ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, Bind(&IncrementInt, &task_count),
+      FROM_HERE, BindOnce(&IncrementInt, &task_count),
       TimeDelta::FromMilliseconds(30));
   ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, Bind(&GLibLoopRunner::Quit, runner),
+      FROM_HERE, BindOnce(&GLibLoopRunner::Quit, runner),
       TimeDelta::FromMilliseconds(40));
 
   // Run a nested, straight Gtk message loop.
   runner->RunLoop();
 
   ASSERT_EQ(3, task_count);
   EXPECT_EQ(4, injector->processed_events());
   MessageLoop::current()->QuitWhenIdle();
 }
 
 }  // namespace
 
 TEST_F(MessagePumpGLibTest, TestGLibLoop) {
   // Tests that events and posted tasks are correctly executed if the message
   // loop is not run by MessageLoop::Run() but by a straight GLib loop.
   // Note that in this case we don't make strong guarantees about niceness
   // between events and posted tasks.
   loop()->task_runner()->PostTask(
-      FROM_HERE, Bind(&TestGLibLoopInternal, Unretained(injector())));
+      FROM_HERE, BindOnce(&TestGLibLoopInternal, Unretained(injector())));
   RunLoop().Run();
 }
 
 TEST_F(MessagePumpGLibTest, TestGtkLoop) {
   // Tests that events and posted tasks are correctly executed if the message
   // loop is not run by MessageLoop::Run() but by a straight Gtk loop.
   // Note that in this case we don't make strong guarantees about niceness
   // between events and posted tasks.
   loop()->task_runner()->PostTask(
-      FROM_HERE, Bind(&TestGtkLoopInternal, Unretained(injector())));
+      FROM_HERE, BindOnce(&TestGtkLoopInternal, Unretained(injector())));
   RunLoop().Run();
 }
 
 }  // namespace base