Move ui_test_utils::RunMessageLoop to test_utils so that it can be reused by content_browsertests.

chrome/browser/debugger/devtools_sanity_browsertest.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/bind.h"
 #include "base/cancelable_callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
@@ skipping 38 matching lines @@
 using content::WorkerServiceObserver;
 
 namespace {
 
 // Used to block until a dev tools client window's browser is closed.
 class BrowserClosedObserver : public content::NotificationObserver {
  public:
   explicit BrowserClosedObserver(Browser* browser) {
     registrar_.Add(this, chrome::NOTIFICATION_BROWSER_CLOSED,
                    content::Source<Browser>(browser));
-    ui_test_utils::RunMessageLoop();
+    content::RunMessageLoop();
   }
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) {
     MessageLoopForUI::current()->Quit();
   }
 
  private:
   content::NotificationRegistrar registrar_;
@@ skipping 127 matching lines @@
     size_t num_before = service->extensions()->size();
     {
       content::NotificationRegistrar registrar;
       registrar.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                     content::NotificationService::AllSources());
       base::CancelableClosure timeout(
           base::Bind(&TimeoutCallback, "Extension load timed out."));
       MessageLoop::current()->PostDelayedTask(
           FROM_HERE, timeout.callback(), base::TimeDelta::FromSeconds(4));
       extensions::UnpackedInstaller::Create(service)->Load(path);
-      ui_test_utils::RunMessageLoop();
+      content::RunMessageLoop();
       timeout.Cancel();
     }
     size_t num_after = service->extensions()->size();
     if (num_after != (num_before + 1))
       return false;
 
     return WaitForExtensionViewsToLoad();
   }
 
   bool WaitForExtensionViewsToLoad() {
@@ skipping 11 matching lines @@
 
     ExtensionProcessManager* manager =
           browser()->profile()->GetExtensionProcessManager();
     ExtensionProcessManager::ViewSet all_views = manager->GetAllViews();
     for (ExtensionProcessManager::ViewSet::const_iterator iter =
              all_views.begin();
          iter != all_views.end();) {
       if (!(*iter)->IsLoading())
         ++iter;
       else
-        ui_test_utils::RunMessageLoop();
+        content::RunMessageLoop();
     }
 
     timeout.Cancel();
     return true;
   }
 
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) {
     switch (type) {
@@ skipping 95 matching lines @@
           new WorkerTerminationObserver(worker_data));
       return;
     }
     FAIL() << "Failed to terminate worker.\n";
   }
 
   static void TerminateWorker(scoped_refptr<WorkerData> worker_data) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&TerminateWorkerOnIOThread, worker_data));
-    ui_test_utils::RunMessageLoop();
+    content::RunMessageLoop();
   }
 
   static void WaitForFirstSharedWorkerOnIOThread(
       scoped_refptr<WorkerData> worker_data) {
     std::vector<WorkerService::WorkerInfo> worker_info =
         WorkerService::GetInstance()->GetWorkers();
     if (!worker_info.empty()) {
       worker_data->worker_process_id = worker_info[0].process_id;
       worker_data->worker_route_id = worker_info[0].route_id;
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
           MessageLoop::QuitClosure());
       return;
     }
 
     WorkerService::GetInstance()->AddObserver(
         new WorkerCreationObserver(worker_data.get()));
   }
 
   static scoped_refptr<WorkerData> WaitForFirstSharedWorker() {
     scoped_refptr<WorkerData> worker_data(new WorkerData());
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&WaitForFirstSharedWorkerOnIOThread, worker_data));
-    ui_test_utils::RunMessageLoop();
+    content::RunMessageLoop();
     return worker_data;
   }
 
   void OpenDevToolsWindowForSharedWorker(WorkerData* worker_data) {
     Profile* profile = browser()->profile();
     window_ = DevToolsWindow::CreateDevToolsWindowForWorker(profile);
     window_->Show(DEVTOOLS_TOGGLE_ACTION_NONE);
     DevToolsAgentHost* agent_host =
         DevToolsAgentHostRegistry::GetDevToolsAgentHostForWorker(
             worker_data->worker_process_id,
@@ skipping 213 matching lines @@
                                         content::CONSOLE_MESSAGE_LEVEL_LOG,
                                         "log");
   devtools_manager->AddMessageToConsole(agent_host,
                                         content::CONSOLE_MESSAGE_LEVEL_ERROR,
                                         "error");
   RunTestFunction(window_, "checkLogAndErrorMessages");
   CloseDevToolsWindow();
 }
 
 }  // namespace