content: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

content/public/test/test_utils.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 "content/public/test/test_utils.h"
 
 #include "base/bind.h"
-#include "base/message_loop/message_loop.h"
+#include "base/location.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "content/public/browser/browser_child_process_host_iterator.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/process_type.h"
 #include "content/public/test/test_launcher.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 
 // Number of times to repost a Quit task so that the MessageLoop finishes up
 // pending tasks and tasks posted by those pending tasks without risking the
 // potential hang behavior of MessageLoop::QuitWhenIdle.
 // The criteria for choosing this number: it should be high enough to make the
 // quit act like QuitWhenIdle, while taking into account that any page which is
 // animating may be rendering another frame for each quit deferral. For an
 // animating page, the potential delay to quitting the RunLoop would be
 // kNumQuitDeferrals * frame_render_time. Some perf tests run slow, such as
 // 200ms/frame.
 static const int kNumQuitDeferrals = 10;
 
 static void DeferredQuitRunLoop(const base::Closure& quit_task,
                                 int num_quit_deferrals) {
   if (num_quit_deferrals <= 0) {
     quit_task.Run();
   } else {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&DeferredQuitRunLoop, quit_task, num_quit_deferrals - 1));
   }
 }
 
 void RunAllPendingMessageAndSendQuit(BrowserThread::ID thread_id,
                                      const base::Closure& quit_task) {
   RunAllPendingInMessageLoop();
   BrowserThread::PostTask(thread_id, FROM_HERE, quit_task);
 }
@@ skipping 69 matching lines @@
 #endif
   if (delegate)
     delegate->PreRunMessageLoop(run_loop);
   run_loop->Run();
   if (delegate)
     delegate->PostRunMessageLoop();
 }
 
 void RunAllPendingInMessageLoop() {
   base::RunLoop run_loop;
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE,  GetQuitTaskForRunLoop(&run_loop));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, GetQuitTaskForRunLoop(&run_loop));
   RunThisRunLoop(&run_loop);
 }
 
 void RunAllPendingInMessageLoop(BrowserThread::ID thread_id) {
   if (BrowserThread::CurrentlyOn(thread_id)) {
     RunAllPendingInMessageLoop();
     return;
   }
   BrowserThread::ID current_thread_id;
   if (!BrowserThread::GetCurrentThreadIdentifier(&current_thread_id)) {
@@ skipping 161 matching lines @@
 void InProcessUtilityThreadHelper::BrowserChildProcessHostDisconnected(
     const ChildProcessData& data) {
   if (--child_thread_count_)
     return;
 
   if (runner_.get())
     runner_->Quit();
 }
 
 }  // namespace content