Remove remaining calls to deprecated MessageLoop methods on Mac.

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/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).
 class EventInjector {
  public:
@@ skipping 115 matching lines @@
 }
 
 // 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,
                          const Closure& task) {
-  MessageLoop::current()->PostTask(from_here, task);
+  ThreadTaskRunnerHandle::Get()->PostTask(from_here, task);
 }
 
 // Test fixture.
 class MessagePumpGLibTest : public testing::Test {
  public:
   MessagePumpGLibTest() : loop_(NULL), injector_(NULL) { }
 
   // Overridden from testing::Test:
   void SetUp() override {
     loop_ = new MessageLoop(MessageLoop::TYPE_UI);
@@ skipping 137 matching lines @@
         task_count_(kStartingTaskCount) {
   }
 
   void FromTask() {
     if (task_count_ > 0) {
       --task_count_;
     }
     if (task_count_ == 0 && event_count_ == 0) {
         MessageLoop::current()->QuitWhenIdle();
     } else {
-      MessageLoop::current()->PostTask(
+      ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, Bind(&ConcurrentHelper::FromTask, this));
     }
   }
 
   void FromEvent() {
     if (event_count_ > 0) {
       --event_count_;
     }
     if (task_count_ == 0 && event_count_ == 0) {
         MessageLoop::current()->QuitWhenIdle();
@@ skipping 50 matching lines @@
 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
-  MessageLoop::current()->PostTask(FROM_HERE, Bind(&DoNothing));
-  MessageLoop::current()->PostTask(FROM_HERE, Bind(&DoNothing));
+  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) {
@@ skipping 44 matching lines @@
 void TestGLibLoopInternal(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, Bind(&IncrementInt, &task_count));
-  MessageLoop::current()->PostTask(
-      FROM_HERE, Bind(&IncrementInt, &task_count));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&IncrementInt, &task_count));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&IncrementInt, &task_count));
   // Delayed events
   injector->AddDummyEvent(10);
   injector->AddDummyEvent(10);
   // Delayed work
-  MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      Bind(&IncrementInt, &task_count),
+  ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, Bind(&IncrementInt, &task_count),
       TimeDelta::FromMilliseconds(30));
-  MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      Bind(&GLibLoopRunner::Quit, runner.get()),
+  ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, Bind(&GLibLoopRunner::Quit, runner.get()),
       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
-  MessageLoop::current()->PostTask(
-      FROM_HERE, Bind(&IncrementInt, &task_count));
-  MessageLoop::current()->PostTask(
-      FROM_HERE, Bind(&IncrementInt, &task_count));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&IncrementInt, &task_count));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&IncrementInt, &task_count));
   // Delayed events
   injector->AddDummyEvent(10);
   injector->AddDummyEvent(10);
   // Delayed work
-  MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      Bind(&IncrementInt, &task_count),
+  ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, Bind(&IncrementInt, &task_count),
       TimeDelta::FromMilliseconds(30));
-  MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      Bind(&GLibLoopRunner::Quit, runner.get()),
+  ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, Bind(&GLibLoopRunner::Quit, runner.get()),
       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();
 }
 
@@ skipping 15 matching lines @@
   // 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();
 }
 
 }  // namespace base