chrome: Use base::MessageLoop. (Part 3)

chrome/browser/devtools/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 52 matching lines @@
  public:
   explicit BrowserClosedObserver(Browser* browser) {
     registrar_.Add(this, chrome::NOTIFICATION_BROWSER_CLOSED,
                    content::Source<Browser>(browser));
     content::RunMessageLoop();
   }
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE {
-    MessageLoopForUI::current()->Quit();
+    base::MessageLoopForUI::current()->Quit();
   }
 
  private:
   content::NotificationRegistrar registrar_;
   DISALLOW_COPY_AND_ASSIGN(BrowserClosedObserver);
 };
 
 // The delay waited in some cases where we don't have a notifications for an
 // action we take.
 const int kActionDelayMs = 500;
@@ skipping 80 matching lines @@
     if (browser)
       BrowserClosedObserver close_observer(browser);
   }
 
   DevToolsWindow* window_;
   RenderViewHost* inspected_rvh_;
 };
 
 void TimeoutCallback(const std::string& timeout_message) {
   FAIL() << timeout_message;
-  MessageLoop::current()->Quit();
+  base::MessageLoop::current()->Quit();
 }
 
 // Base class for DevTools tests that test devtools functionality for
 // extensions and content scripts.
 class DevToolsExtensionTest : public DevToolsSanityTest,
                               public content::NotificationObserver {
  public:
   DevToolsExtensionTest() : DevToolsSanityTest() {
     PathService::Get(chrome::DIR_TEST_DATA, &test_extensions_dir_);
     test_extensions_dir_ = test_extensions_dir_.AppendASCII("devtools");
@@ skipping 11 matching lines @@
   bool LoadExtensionFromPath(const base::FilePath& path) {
     ExtensionService* service = extensions::ExtensionSystem::Get(
         browser()->profile())->extension_service();
     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(
+      base::MessageLoop::current()->PostDelayedTask(
           FROM_HERE, timeout.callback(), base::TimeDelta::FromSeconds(4));
       extensions::UnpackedInstaller::Create(service)->Load(path);
       content::RunMessageLoop();
       timeout.Cancel();
     }
     size_t num_after = service->extensions()->size();
     if (num_after != (num_before + 1))
       return false;
 
     return WaitForExtensionViewsToLoad();
   }
 
   bool WaitForExtensionViewsToLoad() {
     // Wait for all the extension render views that exist to finish loading.
     // NOTE: This assumes that the extension views list is not changing while
     // this method is running.
 
     content::NotificationRegistrar registrar;
     registrar.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
                   content::NotificationService::AllSources());
     base::CancelableClosure timeout(
         base::Bind(&TimeoutCallback, "Extension host load timed out."));
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE, timeout.callback(), base::TimeDelta::FromSeconds(4));
 
     ExtensionProcessManager* manager =
         extensions::ExtensionSystem::Get(browser()->profile())->
             process_manager();
     ExtensionProcessManager::ViewSet all_views = manager->GetAllViews();
     for (ExtensionProcessManager::ViewSet::const_iterator iter =
              all_views.begin();
          iter != all_views.end();) {
       if (!(*iter)->IsLoading())
         ++iter;
       else
         content::RunMessageLoop();
     }
 
     timeout.Cancel();
     return true;
   }
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE {
     switch (type) {
       case chrome::NOTIFICATION_EXTENSION_LOADED:
       case chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING:
-        MessageLoopForUI::current()->Quit();
+        base::MessageLoopForUI::current()->Quit();
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
   base::FilePath test_extensions_dir_;
 };
 
@@ skipping 31 matching lines @@
 
     virtual void WorkerCreated (
         const GURL& url,
         const string16& name,
         int process_id,
         int route_id) OVERRIDE {
       worker_data_->worker_process_id = process_id;
       worker_data_->worker_route_id = route_id;
       WorkerService::GetInstance()->RemoveObserver(this);
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-          MessageLoop::QuitClosure());
+          base::MessageLoop::QuitClosure());
       delete this;
     }
     scoped_refptr<WorkerData> worker_data_;
   };
 
   class WorkerTerminationObserver : public WorkerServiceObserver {
    public:
     explicit WorkerTerminationObserver(WorkerData* worker_data)
         : worker_data_(worker_data) {
     }
 
    private:
     virtual ~WorkerTerminationObserver() {}
 
     virtual void WorkerDestroyed(int process_id, int route_id) OVERRIDE {
       ASSERT_EQ(worker_data_->worker_process_id, process_id);
       ASSERT_EQ(worker_data_->worker_route_id, route_id);
       WorkerService::GetInstance()->RemoveObserver(this);
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-          MessageLoop::QuitClosure());
+          base::MessageLoop::QuitClosure());
       delete this;
     }
     scoped_refptr<WorkerData> worker_data_;
   };
 
   void RunTest(const char* test_name, const char* test_page) {
     ASSERT_TRUE(test_server()->Start());
     GURL url = test_server()->GetURL(test_page);
     ui_test_utils::NavigateToURL(browser(), url);
 
@@ skipping 21 matching lines @@
   }
 
   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());
+          base::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(
@@ skipping 262 matching lines @@
     PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir_);
     test_data_dir_ = test_data_dir_.AppendASCII("devtools");
   }
 };
 
 IN_PROC_BROWSER_TEST_F(RemoteDebuggingTest, RemoteDebugger) {
   ASSERT_TRUE(RunExtensionTest("target_list")) << message_;
 }
 
 }  // namespace