Remove remaining calls to deprecated MessageLoop methods on Mac.

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"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_test.h"
 #include "base/pending_task.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 #include "base/message_loop/message_pump_win.h"
@@ skipping 221 matching lines @@
     order->RecordEnd(ENDDIALOG, cookie);
   }
 }
 
 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);
-    MessageLoop::current()->PostTask(
+    ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         Bind(&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);
@@ skipping 580 matching lines @@
   MessageLoop loop(MessageLoop::TYPE_UI);
   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() {
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(&EmptyFunction));
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(&EmptyFunction));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          base::Bind(&EmptyFunction));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          base::Bind(&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.
-    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(&PostMultipleTasks));
+    ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                            base::Bind(&PostMultipleTasks));
     // Next, we post a task that posts a windows message to trigger the second
     // stage of the test.
-    MessageLoop::current()->PostTask(FROM_HERE,
-                                     base::Bind(&PostWindowsMessage, hwnd));
+    ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&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;
-    MessageLoop::current()->PostTask(FROM_HERE,
-                                     base::Bind(&EndTest, &did_run, hwnd));
+    ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&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 72 matching lines @@
 
   {
     std::string kThreadName("bar");
     base::Thread thread(kThreadName);
     ASSERT_TRUE(thread.StartAndWaitForTesting());
     EXPECT_EQ(kThreadName, thread.message_loop()->GetThreadName());
   }
 }
 
 }  // namespace base