base::Bind: Remove NewRunnableFunction.

base/message_pump_glib_unittest.cc

 // Copyright (c) 2011 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_pump_glib.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <vector>
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(TOOLKIT_USES_GTK)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 29 matching lines @@
       return false;
     return events_[0].time <= base::Time::NowFromSystemTime();
   }
 
   void HandleDispatch() {
     if (events_.empty())
       return;
     Event event = events_[0];
     events_.erase(events_.begin());
     ++processed_events_;
-    if (!event.callback.is_null()) {
+    if (!event.callback.is_null())
       event.callback.Run();
-    } else if (event.task) {
-      event.task->Run();
-      delete event.task;
-    }
+    else if (!event.task.is_null())
+      event.task.Run();
   }
 
   // Adds an event to the queue. When "handled", executes |callback|.
   // delay_ms is relative to the last event if any, or to Now() otherwise.
   void AddEvent(int delay_ms, const base::Closure& callback) {
-    AddEventHelper(delay_ms, callback, NULL);
+    AddEventHelper(delay_ms, callback, base::Closure());
   }
 
   void AddDummyEvent(int delay_ms) {
-    AddEventHelper(delay_ms, base::Closure(), NULL);
+    AddEventHelper(delay_ms, base::Closure(), base::Closure());
   }
 
-  void AddEventAsTask(int delay_ms, Task* task) {
+  void AddEventAsTask(int delay_ms, const base::Closure& task) {
     AddEventHelper(delay_ms, base::Closure(), task);
   }
 
   void Reset() {
     processed_events_ = 0;
     events_.clear();
   }
 
   int processed_events() const { return processed_events_; }
 
  private:
   struct Event {
     base::Time time;
     base::Closure callback;
-    Task* task;
+    base::Closure task;
   };
 
   struct Source : public GSource {
     EventInjector* injector;
   };
 
-  void AddEventHelper(int delay_ms, const base::Closure& callback, Task* task) {
+  void AddEventHelper(
+      int delay_ms, const base::Closure& callback, const base::Closure& task) {
     base::Time last_time;
-    if (!events_.empty()) {
+    if (!events_.empty())
       last_time = (events_.end()-1)->time;
-    } else {
+    else
       last_time = base::Time::NowFromSystemTime();
-    }
+
     base::Time future = last_time + base::TimeDelta::FromMilliseconds(delay_ms);
-    EventInjector::Event event = { future, callback, task };
+    EventInjector::Event event = {future, callback, task};
     events_.push_back(event);
   }
 
   static gboolean Prepare(GSource* source, gint* timeout_ms) {
     *timeout_ms = static_cast<Source*>(source)->injector->HandlePrepare();
     return FALSE;
   }
 
   static gboolean Check(GSource* source) {
     return static_cast<Source*>(source)->injector->HandleCheck();
@@ skipping 28 matching lines @@
   ++*value;
 }
 
 // Checks how many events have been processed by the injector.
 void ExpectProcessedEvents(EventInjector* injector, int count) {
   EXPECT_EQ(injector->processed_events(), count);
 }
 
 // Posts a task on the current message loop.
 void PostMessageLoopTask(const tracked_objects::Location& from_here,
-                         Task* task) {
+                         const base::Closure& task) {
   MessageLoop::current()->PostTask(from_here, task);
 }
 
 // Test fixture.
 class MessagePumpGLibTest : public testing::Test {
  public:
   MessagePumpGLibTest() : loop_(NULL), injector_(NULL) { }
 
   virtual void SetUp() {
     loop_ = new MessageLoop(MessageLoop::TYPE_UI);
@@ skipping 37 matching lines @@
 }
 
 TEST_F(MessagePumpGLibTest, TestEventTaskInterleave) {
   // Checks that tasks posted by events are executed before the next event if
   // the posted task queue is empty.
   // MessageLoop doesn't make strong guarantees that it is the case, but the
   // current implementation ensures it and the tests below rely on it.
   // If changes cause this test to fail, it is reasonable to change it, but
   // TestWorkWhileWaitingForEvents and TestEventsWhileWaitingForWork have to be
   // changed accordingly, otherwise they can become flaky.
-  injector()->AddEventAsTask(0, NewRunnableFunction(DoNothing));
-  Task* check_task = NewRunnableFunction(ExpectProcessedEvents, injector(), 2);
-  Task* posted_task = NewRunnableFunction(PostMessageLoopTask,
-                                          FROM_HERE, check_task);
+  injector()->AddEventAsTask(0, base::Bind(&DoNothing));
+  base::Closure check_task =
+      base::Bind(&ExpectProcessedEvents, base::Unretained(injector()), 2);
+  base::Closure posted_task =
+      base::Bind(&PostMessageLoopTask, FROM_HERE, check_task);
   injector()->AddEventAsTask(0, posted_task);
-  injector()->AddEventAsTask(0, NewRunnableFunction(DoNothing));
+  injector()->AddEventAsTask(0, base::Bind(&DoNothing));
   injector()->AddEvent(0, MessageLoop::QuitClosure());
   loop()->Run();
   EXPECT_EQ(4, injector()->processed_events());
 
   injector()->Reset();
-  injector()->AddEventAsTask(0, NewRunnableFunction(DoNothing));
-  check_task = NewRunnableFunction(ExpectProcessedEvents, injector(), 2);
-  posted_task = NewRunnableFunction(PostMessageLoopTask, FROM_HERE, check_task);
+  injector()->AddEventAsTask(0, base::Bind(&DoNothing));
+  check_task =
+      base::Bind(&ExpectProcessedEvents, base::Unretained(injector()), 2);
+  posted_task = base::Bind(&PostMessageLoopTask, FROM_HERE, check_task);
   injector()->AddEventAsTask(0, posted_task);
-  injector()->AddEventAsTask(10, NewRunnableFunction(DoNothing));
+  injector()->AddEventAsTask(10, base::Bind(&DoNothing));
   injector()->AddEvent(0, MessageLoop::QuitClosure());
   loop()->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()->PostTask(FROM_HERE, NewRunnableFunction(IncrementInt, &task_count));
+    loop()->PostTask(FROM_HERE, base::Bind(&IncrementInt, &task_count));
   }
   // After all the previous tasks have executed, enqueue an event that will
   // quit.
   loop()->PostTask(
-      FROM_HERE, NewRunnableMethod(injector(), &EventInjector::AddEvent,
-                                   0, MessageLoop::QuitClosure()));
+      FROM_HERE,
+      base::Bind(&EventInjector::AddEvent, base::Unretained(injector()), 0,
+                 MessageLoop::QuitClosure()));
   loop()->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()->PostDelayedTask(
-        FROM_HERE, NewRunnableFunction(IncrementInt, &task_count), 10*i);
+        FROM_HERE, base::Bind(&IncrementInt, &task_count), 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()->PostDelayedTask(
-      FROM_HERE, NewRunnableMethod(injector(), &EventInjector::AddEvent,
-                                   10, MessageLoop::QuitClosure()), 150);
+      FROM_HERE,
+      base::Bind(&EventInjector::AddEvent, base::Unretained(injector()), 10,
+                 MessageLoop::QuitClosure()), 150);
   loop()->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) {
     injector()->AddDummyEvent(0);
   }
   // After all the events have been processed, post a task that will check that
   // the events have been processed (note: the task executes after the event
   // that posted it has been handled, so we expect 11 at that point).
-  Task* check_task = NewRunnableFunction(ExpectProcessedEvents, injector(), 11);
-  Task* posted_task = NewRunnableFunction(PostMessageLoopTask,
-                                          FROM_HERE, check_task);
+  base::Closure check_task =
+      base::Bind(&ExpectProcessedEvents, base::Unretained(injector()), 11);
+  base::Closure posted_task =
+      base::Bind(&PostMessageLoopTask, FROM_HERE, check_task);
   injector()->AddEventAsTask(10, posted_task);
 
   // And then quit (relies on the condition tested by TestEventTaskInterleave).
   injector()->AddEvent(10, MessageLoop::QuitClosure());
   loop()->Run();
 
   EXPECT_EQ(12, injector()->processed_events());
 }
 
 namespace {
@@ skipping 10 matching lines @@
   }
 
   void FromTask() {
     if (task_count_ > 0) {
       --task_count_;
     }
     if (task_count_ == 0 && event_count_ == 0) {
         MessageLoop::current()->Quit();
     } else {
       MessageLoop::current()->PostTask(
-          FROM_HERE, NewRunnableMethod(this, &ConcurrentHelper::FromTask));
+          FROM_HERE, base::Bind(&ConcurrentHelper::FromTask, this));
     }
   }
 
   void FromEvent() {
     if (event_count_ > 0) {
       --event_count_;
     }
     if (task_count_ == 0 && event_count_ == 0) {
         MessageLoop::current()->Quit();
     } else {
       injector_->AddEventAsTask(
-          0, NewRunnableMethod(this, &ConcurrentHelper::FromEvent));
+          0, base::Bind(&ConcurrentHelper::FromEvent, this));
     }
   }
 
   int event_count() const { return event_count_; }
   int task_count() const { return task_count_; }
 
  private:
   friend class base::RefCounted<ConcurrentHelper>;
 
   ~ConcurrentHelper() {}
@@ skipping 12 matching lines @@
   // Tests that posted tasks don't starve events, nor the opposite.
   // We use the helper class above. We keep both event and posted task queues
   // full, the helper verifies that both tasks and events get processed.
   // If that is not the case, either event_count_ or task_count_ will not get
   // to 0, and MessageLoop::Quit() will never be called.
   scoped_refptr<ConcurrentHelper> helper = new ConcurrentHelper(injector());
 
   // Add 2 events to the queue to make sure it is always full (when we remove
   // the event before processing it).
   injector()->AddEventAsTask(
-      0, NewRunnableMethod(helper.get(), &ConcurrentHelper::FromEvent));
+      0, base::Bind(&ConcurrentHelper::FromEvent, helper.get()));
   injector()->AddEventAsTask(
-      0, NewRunnableMethod(helper.get(), &ConcurrentHelper::FromEvent));
+      0, base::Bind(&ConcurrentHelper::FromEvent, helper.get()));
 
   // Similarly post 2 tasks.
   loop()->PostTask(
-      FROM_HERE, NewRunnableMethod(helper.get(), &ConcurrentHelper::FromTask));
+      FROM_HERE, base::Bind(&ConcurrentHelper::FromTask, helper.get()));
   loop()->PostTask(
-      FROM_HERE, NewRunnableMethod(helper.get(), &ConcurrentHelper::FromTask));
+      FROM_HERE, base::Bind(&ConcurrentHelper::FromTask, helper.get()));
 
   loop()->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::QuitClosure());
 
   // Post a couple of dummy tasks
-  MessageLoop::current()->PostTask(FROM_HERE, NewRunnableFunction(DoNothing));
-  MessageLoop::current()->PostTask(FROM_HERE, NewRunnableFunction(DoNothing));
+  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(&DoNothing));
+  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(&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()->PostTask(
-      FROM_HERE, NewRunnableFunction(AddEventsAndDrainGLib, injector()));
+      FROM_HERE,
+      base::Bind(&AddEventsAndDrainGLib, base::Unretained(injector())));
   loop()->Run();
 
   EXPECT_EQ(3, injector()->processed_events());
 }
 
 
 namespace {
 
 #if defined(TOOLKIT_USES_GTK)
 void AddEventsAndDrainGtk(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::QuitClosure());
 
   // Post a couple of dummy tasks
-  MessageLoop::current()->PostTask(FROM_HERE, NewRunnableFunction(DoNothing));
-  MessageLoop::current()->PostTask(FROM_HERE, NewRunnableFunction(DoNothing));
+  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(&DoNothing));
+  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(&DoNothing));
 
   // Drain the events
   while (gtk_events_pending()) {
     gtk_main_iteration();
   }
 }
 #endif
 
 }  // namespace
 
 #if defined(TOOLKIT_USES_GTK)
 TEST_F(MessagePumpGLibTest, TestDrainingGtk) {
   // Tests that draining events using Gtk works.
   loop()->PostTask(
-      FROM_HERE, NewRunnableFunction(AddEventsAndDrainGtk, injector()));
+      FROM_HERE,
+      base::Bind(&AddEventsAndDrainGtk, base::Unretained(injector())));
   loop()->Run();
 
   EXPECT_EQ(3, injector()->processed_events());
 }
 #endif
 
 namespace {
 
 // Helper class that lets us run the GLib message loop.
 class GLibLoopRunner : public base::RefCounted<GLibLoopRunner> {
@@ skipping 38 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
   MessageLoop::current()->PostTask(
-      FROM_HERE, NewRunnableFunction(IncrementInt, &task_count));
+      FROM_HERE, base::Bind(&IncrementInt, &task_count));
   MessageLoop::current()->PostTask(
-      FROM_HERE, NewRunnableFunction(IncrementInt, &task_count));
+      FROM_HERE, base::Bind(&IncrementInt, &task_count));
   // Delayed events
   injector->AddDummyEvent(10);
   injector->AddDummyEvent(10);
   // Delayed work
   MessageLoop::current()->PostDelayedTask(
-      FROM_HERE, NewRunnableFunction(IncrementInt, &task_count), 30);
+      FROM_HERE, base::Bind(&IncrementInt, &task_count), 30);
   MessageLoop::current()->PostDelayedTask(
-      FROM_HERE, NewRunnableMethod(runner.get(), &GLibLoopRunner::Quit), 40);
+      FROM_HERE, base::Bind(&GLibLoopRunner::Quit, runner.get()), 40);
 
   // Run a nested, straight GLib message loop.
   runner->RunGLib();
 
   ASSERT_EQ(3, task_count);
   EXPECT_EQ(4, injector->processed_events());
   MessageLoop::current()->Quit();
 }
 
 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
   MessageLoop::current()->PostTask(
-      FROM_HERE, NewRunnableFunction(IncrementInt, &task_count));
+      FROM_HERE, base::Bind(&IncrementInt, &task_count));
   MessageLoop::current()->PostTask(
-      FROM_HERE, NewRunnableFunction(IncrementInt, &task_count));
+      FROM_HERE, base::Bind(&IncrementInt, &task_count));
   // Delayed events
   injector->AddDummyEvent(10);
   injector->AddDummyEvent(10);
   // Delayed work
   MessageLoop::current()->PostDelayedTask(
-      FROM_HERE, NewRunnableFunction(IncrementInt, &task_count), 30);
+      FROM_HERE, base::Bind(&IncrementInt, &task_count), 30);
   MessageLoop::current()->PostDelayedTask(
-      FROM_HERE, NewRunnableMethod(runner.get(), &GLibLoopRunner::Quit), 40);
+      FROM_HERE, base::Bind(&GLibLoopRunner::Quit, runner.get()), 40);
 
   // Run a nested, straight Gtk message loop.
   runner->RunLoop();
 
   ASSERT_EQ(3, task_count);
   EXPECT_EQ(4, injector->processed_events());
   MessageLoop::current()->Quit();
 }
 
 }  // namespace
 
 TEST_F(MessagePumpGLibTest, TestGLibLoop) {
-  // Tests that events and posted tasks are correctly exectuted if the message
+  // 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()->PostTask(FROM_HERE,
-                   NewRunnableFunction(TestGLibLoopInternal, injector()));
+  loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&TestGLibLoopInternal, base::Unretained(injector())));
   loop()->Run();
 }
 
 TEST_F(MessagePumpGLibTest, TestGtkLoop) {
-  // Tests that events and posted tasks are correctly exectuted if the message
+  // 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()->PostTask(FROM_HERE,
-                   NewRunnableFunction(TestGtkLoopInternal, injector()));
+  loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&TestGtkLoopInternal, base::Unretained(injector())));
   loop()->Run();
 }