Add thread checking to RunLoop, deprecate MessageLoopRunner.

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 <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 102 matching lines @@
 }  // namespace
 
 void RunMessageLoop() {
   base::RunLoop run_loop;
   RunThisRunLoop(&run_loop);
 }
 
 void RunThisRunLoop(base::RunLoop* run_loop) {
   base::MessageLoop::ScopedNestableTaskAllower allow(
       base::MessageLoop::current());
-
-  // If we're running inside a browser test, we might need to allow the test
-  // launcher to do extra work before/after running a nested message loop.
-  TestLauncherDelegate* delegate = NULL;
-  delegate = GetCurrentTestLauncherDelegate();
-  if (delegate)
-    delegate->PreRunMessageLoop(run_loop);
   run_loop->Run();
-  if (delegate)
-    delegate->PostRunMessageLoop();
 }
 
 void RunAllPendingInMessageLoop() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::RunLoop run_loop;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, GetQuitTaskForRunLoop(&run_loop));
+      FROM_HERE, GetDeferredQuitTaskForRunLoop(&run_loop));
   RunThisRunLoop(&run_loop);
 }
 
 void RunAllPendingInMessageLoop(BrowserThread::ID thread_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (thread_id == BrowserThread::UI) {
     RunAllPendingInMessageLoop();
     return;
   }
 
@@ skipping 18 matching lines @@
     TaskObserver task_observer;
     base::MessageLoop::current()->AddTaskObserver(&task_observer);
     base::RunLoop().RunUntilIdle();
     base::MessageLoop::current()->RemoveTaskObserver(&task_observer);
 
     if (!task_observer.processed())
       break;
   }
 }
 
-base::Closure GetQuitTaskForRunLoop(base::RunLoop* run_loop) {
+base::Closure GetDeferredQuitTaskForRunLoop(base::RunLoop* run_loop) {
   return base::Bind(&DeferredQuitRunLoop, run_loop->QuitClosure(),
                     kNumQuitDeferrals);
 }
 
 std::unique_ptr<base::Value> ExecuteScriptAndGetValue(
     RenderFrameHost* render_frame_host,
     const std::string& script) {
   ScriptCallback observer;
 
   render_frame_host->ExecuteJavaScriptForTests(
@@ skipping 44 matching lines @@
 
 void MessageLoopRunner::Quit() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   quit_closure_called_ = true;
 
   // Only run the quit task if we are running the message loop.
   if (loop_running_) {
     switch (quit_mode_) {
       case QuitMode::DEFERRED:
-        GetQuitTaskForRunLoop(&run_loop_).Run();
+        GetDeferredQuitTaskForRunLoop(&run_loop_).Run();
         break;
       case QuitMode::IMMEDIATE:
         run_loop_.Quit();
         break;
     }
     loop_running_ = false;
   }
 }
 
 WindowedNotificationObserver::WindowedNotificationObserver(
@@ skipping 134 matching lines @@
 
 void WebContentsDestroyedWatcher::Wait() {
   message_loop_runner_->Run();
 }
 
 void WebContentsDestroyedWatcher::WebContentsDestroyed() {
   message_loop_runner_->Quit();
 }
 
 }  // namespace content