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

chrome/browser/policy/policy_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 <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 174 matching lines @@
     const std::string& scheme) {
   return new content::URLRequestFailedJob(
       request, network_delegate, net::ERR_CONNECTION_RESET);
 }
 
 // While |MakeRequestFail| is in scope URLRequests to |host| will fail.
 class MakeRequestFail {
  public:
   // Sets up the filter on IO thread such that requests to |host| fail.
   explicit MakeRequestFail(const std::string& host) : host_(host) {
-    BrowserThread::PostTaskAndReply(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(MakeRequestFailOnIO, host_),
-        MessageLoop::QuitClosure());
+    BrowserThread::PostTaskAndReply(BrowserThread::IO,
+                                    FROM_HERE,
+                                    base::Bind(MakeRequestFailOnIO, host_),
+                                    base::MessageLoop::QuitClosure());
     content::RunMessageLoop();
   }
   ~MakeRequestFail() {
-    BrowserThread::PostTaskAndReply(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(UndoMakeRequestFailOnIO, host_),
-        MessageLoop::QuitClosure());
+    BrowserThread::PostTaskAndReply(BrowserThread::IO,
+                                    FROM_HERE,
+                                    base::Bind(UndoMakeRequestFailOnIO, host_),
+                                    base::MessageLoop::QuitClosure());
     content::RunMessageLoop();
   }
 
  private:
   // Filters requests to the |host| such that they fail. Run on IO thread.
   static void MakeRequestFailOnIO(const std::string& host) {
     net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
     filter->AddHostnameHandler("http", host, &FailedJobFactory);
     filter->AddHostnameHandler("https", host, &FailedJobFactory);
   }
@@ skipping 96 matching lines @@
       contents->GetRenderViewHost(), "123");
   int result = 0;
   if (!value->GetAsInteger(&result))
     EXPECT_EQ(base::Value::TYPE_NULL, value->GetType());
   return result == 123;
 }
 
 void CopyPluginListAndQuit(std::vector<webkit::WebPluginInfo>* out,
                            const std::vector<webkit::WebPluginInfo>& in) {
   *out = in;
-  MessageLoop::current()->QuitWhenIdle();
+  base::MessageLoop::current()->QuitWhenIdle();
 }
 
 template<typename T>
 void CopyValueAndQuit(T* out, T in) {
   *out = in;
-  MessageLoop::current()->QuitWhenIdle();
+  base::MessageLoop::current()->QuitWhenIdle();
 }
 
 void GetPluginList(std::vector<webkit::WebPluginInfo>* plugins) {
   content::PluginService* service = content::PluginService::GetInstance();
   service->GetPlugins(base::Bind(CopyPluginListAndQuit, plugins));
   content::RunMessageLoop();
 }
 
 const webkit::WebPluginInfo* GetFlashPlugin(
     const std::vector<webkit::WebPluginInfo>& plugins) {
@@ skipping 99 matching lines @@
         BrowserThread::IO, FROM_HERE,
         base::Bind(chrome_browser_net::SetUrlRequestMocksEnabled, true));
   }
 
   // Makes URLRequestMockHTTPJobs serve data from content::DIR_TEST_DATA
   // instead of chrome::DIR_TEST_DATA.
   void ServeContentTestData() {
     base::FilePath root_http;
     PathService::Get(content::DIR_TEST_DATA, &root_http);
     BrowserThread::PostTaskAndReply(
-        BrowserThread::IO, FROM_HERE,
+        BrowserThread::IO,
+        FROM_HERE,
         base::Bind(URLRequestMockHTTPJob::AddUrlHandler, root_http),
-        MessageLoop::current()->QuitWhenIdleClosure());
+        base::MessageLoop::current()->QuitWhenIdleClosure());
     content::RunMessageLoop();
   }
 
   void SetScreenshotPolicy(bool enabled) {
     PolicyMap policies;
     policies.Set(key::kDisableScreenshots, POLICY_LEVEL_MANDATORY,
                  POLICY_SCOPE_USER, base::Value::CreateBooleanValue(!enabled));
     UpdateProviderPolicy(policies);
   }
 
@@ skipping 44 matching lines @@
     web_contents->Close();
   }
 
 #if defined(OS_CHROMEOS)
   void TestScreenshotFile(bool enabled) {
     SetScreenshotPolicy(enabled);
     ash::Shell::GetInstance()->accelerator_controller()->PerformAction(
         ash::TAKE_SCREENSHOT, ui::Accelerator());
 
     // TAKE_SCREENSHOT handler posts write file task on success, wait for it.
-    BrowserThread::PostTaskAndReply(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(base::DoNothing),
-        MessageLoop::QuitClosure());
+    BrowserThread::PostTaskAndReply(BrowserThread::IO,
+                                    FROM_HERE,
+                                    base::Bind(base::DoNothing),
+                                    base::MessageLoop::QuitClosure());
     content::RunMessageLoop();
   }
 #endif
 
   ExtensionService* extension_service() {
     extensions::ExtensionSystem* system =
         extensions::ExtensionSystem::Get(browser()->profile());
     return system->extension_service();
   }
 
@@ skipping 20 matching lines @@
     content::WindowedNotificationObserver observer(
         expect_success ? chrome::NOTIFICATION_EXTENSION_UNINSTALLED
                        : chrome::NOTIFICATION_EXTENSION_UNINSTALL_NOT_ALLOWED,
         content::NotificationService::AllSources());
     extension_service()->UninstallExtension(id, false, NULL);
     observer.Wait();
   }
 
   void UpdateProviderPolicy(const PolicyMap& policy) {
     provider_.UpdateChromePolicy(policy);
-    DCHECK(MessageLoop::current());
+    DCHECK(base::MessageLoop::current());
     base::RunLoop loop;
     loop.RunUntilIdle();
   }
 
   // Sends a mouse click at the given coordinates to the current renderer.
   void PerformClick(int x, int y) {
     content::WebContents* contents =
         browser()->tab_strip_model()->GetActiveWebContents();
     WebKit::WebMouseEvent click_event;
     click_event.type = WebKit::WebInputEvent::MouseDown;
@@ skipping 1401 matching lines @@
     TabSpecificContentSettings* content_settings =
         TabSpecificContentSettings::FromWebContents(
             browser()->tab_strip_model()->GetActiveWebContents());
     MediaStreamDevicesController controller(
         browser()->profile(),
         content_settings,
         request,
         base::Bind(&MediaStreamDevicesControllerBrowserTest::Accept, this));
     controller.DismissInfoBarAndTakeActionOnSettings();
 
-    MessageLoop::current()->QuitWhenIdle();
+    base::MessageLoop::current()->QuitWhenIdle();
   }
 
   void FinishVideoTest() {
     content::MediaStreamRequest request(0, 0, GURL(),
                                         content::MEDIA_OPEN_DEVICE, "fake_dev",
                                         content::MEDIA_NO_SERVICE,
                                         content::MEDIA_DEVICE_VIDEO_CAPTURE);
     TabSpecificContentSettings* content_settings =
         TabSpecificContentSettings::FromWebContents(
             browser()->tab_strip_model()->GetActiveWebContents());
     MediaStreamDevicesController controller(
         browser()->profile(), content_settings, request,
         base::Bind(&MediaStreamDevicesControllerBrowserTest::Accept, this));
     controller.DismissInfoBarAndTakeActionOnSettings();
 
-    MessageLoop::current()->QuitWhenIdle();
+    base::MessageLoop::current()->QuitWhenIdle();
   }
 
   bool policy_value_;
 };
 
 IN_PROC_BROWSER_TEST_P(MediaStreamDevicesControllerBrowserTest,
                        AudioCaptureAllowed) {
   content::MediaStreamDevices audio_devices;
   content::MediaStreamDevice fake_audio_device(
       content::MEDIA_DEVICE_AUDIO_CAPTURE, "fake_dev", "Fake Audio Device");
   audio_devices.push_back(fake_audio_device);
 
   PolicyMap policies;
   policies.Set(key::kAudioCaptureAllowed, POLICY_LEVEL_MANDATORY,
                POLICY_SCOPE_USER,
                base::Value::CreateBooleanValue(policy_value_));
   UpdateProviderPolicy(policies);
 
   content::BrowserThread::PostTaskAndReply(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaCaptureDevicesDispatcher::OnAudioCaptureDevicesChanged,
                  base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()),
                  audio_devices),
       base::Bind(&MediaStreamDevicesControllerBrowserTest::FinishAudioTest,
                  this));
 
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 }
 
 IN_PROC_BROWSER_TEST_P(MediaStreamDevicesControllerBrowserTest,
                        VideoCaptureAllowed) {
   content::MediaStreamDevices video_devices;
   content::MediaStreamDevice fake_video_device(
       content::MEDIA_DEVICE_VIDEO_CAPTURE, "fake_dev", "Fake Video Device");
   video_devices.push_back(fake_video_device);
 
   PolicyMap policies;
   policies.Set(key::kVideoCaptureAllowed, POLICY_LEVEL_MANDATORY,
                POLICY_SCOPE_USER,
                base::Value::CreateBooleanValue(policy_value_));
   UpdateProviderPolicy(policies);
 
   content::BrowserThread::PostTaskAndReply(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaCaptureDevicesDispatcher::OnVideoCaptureDevicesChanged,
                  base::Unretained(MediaCaptureDevicesDispatcher::GetInstance()),
                  video_devices),
       base::Bind(&MediaStreamDevicesControllerBrowserTest::FinishVideoTest,
                  this));
 
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 }
 
 INSTANTIATE_TEST_CASE_P(MediaStreamDevicesControllerBrowserTestInstance,
                         MediaStreamDevicesControllerBrowserTest,
                         testing::Bool());
 
 #if !defined(OS_CHROMEOS)
 // Similar to PolicyTest but sets the proper policy before the browser is
 // started.
 class PolicyVariationsServiceTest : public PolicyTest {
@@ skipping 16 matching lines @@
           GetDefaultVariationsServerURLForTesting();
 
   // Policy is applied and pref is already updated in local state.
   EXPECT_EQ(default_variations_url + "?restrict=restricted",
             chrome_variations::VariationsService::GetVariationsServerURL(
                 g_browser_process->local_state()).spec());
 }
 #endif
 
 }  // namespace policy