Remove calls to deprecated MessageLoop methods on Windows and Linux.

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>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace {
 
 // This class injects dummy "events" into the GLib loop. When "handled" these
 // events can run tasks. This is intended to mock gtk events (the corresponding
 // GLib source runs at the same priority).
@@ skipping 158 matching lines @@
 TEST_F(MessagePumpGLibTest, TestQuit) {
   // Checks that Quit works and that the basic infrastructure is working.
 
   // Quit from a task
   RunLoop().RunUntilIdle();
   EXPECT_EQ(0, injector()->processed_events());
 
   injector()->Reset();
   // Quit from an event
   injector()->AddEvent(0, MessageLoop::QuitWhenIdleClosure());
-  loop()->Run();
+  RunLoop().Run();
   EXPECT_EQ(1, injector()->processed_events());
 }
 
 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, Bind(&DoNothing));
   Closure check_task =
       Bind(&ExpectProcessedEvents, Unretained(injector()), 2);
   Closure posted_task =
       Bind(&PostMessageLoopTask, FROM_HERE, check_task);
   injector()->AddEventAsTask(0, posted_task);
   injector()->AddEventAsTask(0, Bind(&DoNothing));
   injector()->AddEvent(0, MessageLoop::QuitWhenIdleClosure());
-  loop()->Run();
+  RunLoop().Run();
   EXPECT_EQ(4, injector()->processed_events());
 
   injector()->Reset();
   injector()->AddEventAsTask(0, Bind(&DoNothing));
   check_task =
       Bind(&ExpectProcessedEvents, Unretained(injector()), 2);
   posted_task = Bind(&PostMessageLoopTask, FROM_HERE, check_task);
   injector()->AddEventAsTask(0, posted_task);
   injector()->AddEventAsTask(10, Bind(&DoNothing));
   injector()->AddEvent(0, MessageLoop::QuitWhenIdleClosure());
-  loop()->Run();
+  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()->PostTask(FROM_HERE, Bind(&IncrementInt, &task_count));
+    loop()->task_runner()->PostTask(FROM_HERE,
+                                    Bind(&IncrementInt, &task_count));
   }
   // After all the previous tasks have executed, enqueue an event that will
   // quit.
-  loop()->PostTask(
-      FROM_HERE,
-      Bind(&EventInjector::AddEvent, Unretained(injector()), 0,
-                 MessageLoop::QuitWhenIdleClosure()));
-  loop()->Run();
+  loop()->task_runner()->PostTask(
+      FROM_HERE, Bind(&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()->PostDelayedTask(
-        FROM_HERE,
-        Bind(&IncrementInt, &task_count),
-        TimeDelta::FromMilliseconds(10*i));
+    loop()->task_runner()->PostDelayedTask(FROM_HERE,
+                                           Bind(&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()->PostDelayedTask(
-      FROM_HERE,
-      Bind(&EventInjector::AddEvent, Unretained(injector()), 10,
-                 MessageLoop::QuitWhenIdleClosure()),
+  loop()->task_runner()->PostDelayedTask(
+      FROM_HERE, Bind(&EventInjector::AddEvent, Unretained(injector()), 10,
+                      MessageLoop::QuitWhenIdleClosure()),
       TimeDelta::FromMilliseconds(150));
-  loop()->Run();
+  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) {
     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).
   Closure check_task =
       Bind(&ExpectProcessedEvents, Unretained(injector()), 11);
   Closure posted_task =
       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::QuitWhenIdleClosure());
-  loop()->Run();
+  RunLoop().Run();
 
   EXPECT_EQ(12, injector()->processed_events());
 }
 
 namespace {
 
 // This class is a helper for the concurrent events / posted tasks test below.
 // It will quit the main loop once enough tasks and events have been processed,
 // while making sure there is always work to do and events in the queue.
 class ConcurrentHelper : public RefCounted<ConcurrentHelper>  {
@@ skipping 55 matching lines @@
   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, Bind(&ConcurrentHelper::FromEvent, helper.get()));
   injector()->AddEventAsTask(
       0, Bind(&ConcurrentHelper::FromEvent, helper.get()));
 
   // Similarly post 2 tasks.
-  loop()->PostTask(
+  loop()->task_runner()->PostTask(
       FROM_HERE, Bind(&ConcurrentHelper::FromTask, helper.get()));
-  loop()->PostTask(
+  loop()->task_runner()->PostTask(
       FROM_HERE, Bind(&ConcurrentHelper::FromTask, helper.get()));
 
-  loop()->Run();
+  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));
 
   // 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,
-      Bind(&AddEventsAndDrainGLib, Unretained(injector())));
-  loop()->Run();
+  loop()->task_runner()->PostTask(
+      FROM_HERE, Bind(&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:
   GLibLoopRunner() : quit_(false) { }
@@ skipping 92 matching lines @@
   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()->PostTask(
-      FROM_HERE,
-      Bind(&TestGLibLoopInternal, Unretained(injector())));
-  loop()->Run();
+  loop()->task_runner()->PostTask(
+      FROM_HERE, Bind(&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()->PostTask(
-      FROM_HERE,
-      Bind(&TestGtkLoopInternal, Unretained(injector())));
-  loop()->Run();
+  loop()->task_runner()->PostTask(
+      FROM_HERE, Bind(&TestGtkLoopInternal, Unretained(injector())));
+  RunLoop().Run();
 }
 
 }  // namespace base