content: Use base::MessageLoop.

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.h"
 #include "base/run_loop.h"
 #include "base/utf_string_conversions.h"
@@ skipping 16 matching lines @@
 // 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 {
-    MessageLoop::current()->PostTask(FROM_HERE,
+    base::MessageLoop::current()->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);
 }
 
 // Class used handle result callbacks for ExecuteScriptAndGetValue.
 class ScriptCallback {
  public:
   ScriptCallback() { }
   virtual ~ScriptCallback() { }
   void ResultCallback(const base::Value* result);
 
   scoped_ptr<base::Value> result() { return result_.Pass(); }
 
  private:
   scoped_ptr<base::Value> result_;
 
   DISALLOW_COPY_AND_ASSIGN(ScriptCallback);
 };
 
 void ScriptCallback::ResultCallback(const base::Value* result) {
   if (result)
     result_.reset(result->DeepCopy());
-  MessageLoop::current()->Quit();
+  base::MessageLoop::current()->Quit();
 }
 
 }  // namespace
 
 void RunMessageLoop() {
   base::RunLoop run_loop;
   RunThisRunLoop(&run_loop);
 }
 
 void RunThisRunLoop(base::RunLoop* run_loop) {
-  MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
+  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;
 #if !defined(OS_IOS)
   delegate = GetCurrentTestLauncherDelegate();
 #endif
   if (delegate)
     delegate->PreRunMessageLoop(run_loop);
   run_loop->Run();
   if (delegate)
     delegate->PostRunMessageLoop();
 }
 
 void RunAllPendingInMessageLoop() {
-  MessageLoop::current()->PostTask(FROM_HERE,
-                                   MessageLoop::QuitWhenIdleClosure());
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
   RunMessageLoop();
 }
 
 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 15 matching lines @@
 
 scoped_ptr<base::Value> ExecuteScriptAndGetValue(
     RenderViewHost* render_view_host,
     const std::string& script) {
   ScriptCallback observer;
 
   render_view_host->ExecuteJavascriptInWebFrameCallbackResult(
       string16(),  // frame_xpath,
       UTF8ToUTF16(script),
       base::Bind(&ScriptCallback::ResultCallback, base::Unretained(&observer)));
-  MessageLoop* loop = MessageLoop::current();
+  base::MessageLoop* loop = base::MessageLoop::current();
   loop->Run();
   return observer.result().Pass();
 }
 
 MessageLoopRunner::MessageLoopRunner()
     : loop_running_(false),
       quit_closure_called_(false) {
 }
 
 MessageLoopRunner::~MessageLoopRunner() {
@@ skipping 53 matching lines @@
   details_ = details;
   seen_ = true;
   if (!running_)
     return;
 
   message_loop_runner_->Quit();
   running_ = false;
 }
 
 }  // namespace content