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

chrome/browser/printing/cloud_print/test/cloud_print_proxy_process_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.
 
 // Create a service process that uses a Mock to respond to the browser in order
 // to test launching the browser using the cloud print policy check command
 // line switch.
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 74 matching lines @@
   }
 };
 
 }  // namespace
 
 class TestServiceProcess : public ServiceProcess {
  public:
   TestServiceProcess() { }
   virtual ~TestServiceProcess() { }
 
-  bool Initialize(MessageLoopForUI* message_loop, ServiceProcessState* state);
+  bool Initialize(base::MessageLoopForUI* message_loop,
+                  ServiceProcessState* state);
 
   base::MessageLoopProxy* IOMessageLoopProxy() {
     return io_thread_->message_loop_proxy();
   }
 };
 
-bool TestServiceProcess::Initialize(MessageLoopForUI* message_loop,
+bool TestServiceProcess::Initialize(base::MessageLoopForUI* message_loop,
                                     ServiceProcessState* state) {
   main_message_loop_ = message_loop;
 
   service_process_state_.reset(state);
 
-  base::Thread::Options options(MessageLoop::TYPE_IO, 0);
+  base::Thread::Options options(base::MessageLoop::TYPE_IO, 0);
   io_thread_.reset(new base::Thread("TestServiceProcess_IO"));
   return io_thread_->StartWithOptions(options);
 }
 
 // This mocks the service side IPC message handler, allowing us to have a
 // minimal service process.
 class MockServiceIPCServer : public ServiceIPCServer {
  public:
   static std::string EnabledUserId();
 
@@ skipping 76 matching lines @@
   return true;
 }
 
 typedef base::Callback<void(MockServiceIPCServer* server)>
     SetExpectationsCallback;
 
 // The return value from this routine is used as the exit code for the mock
 // service process. Any non-zero return value will be printed out and can help
 // determine the failure.
 int CloudPrintMockService_Main(SetExpectationsCallback set_expectations) {
-  MessageLoopForUI main_message_loop;
+  base::MessageLoopForUI main_message_loop;
   main_message_loop.set_thread_name("Main Thread");
 
 #if defined(OS_MACOSX)
   CommandLine* cl = CommandLine::ForCurrentProcess();
   if (!cl->HasSwitch(kTestExecutablePath))
     return kMissingSwitch;
   base::FilePath executable_path = cl->GetSwitchValuePath(kTestExecutablePath);
   EXPECT_FALSE(executable_path.empty());
   MockLaunchd mock_launchd(executable_path, &main_message_loop, true, true);
   Launchd::ScopedInstance use_mock(&mock_launchd);
@@ skipping 92 matching lines @@
 
   bool LaunchBrowser(const CommandLine& command_line, Profile* profile) {
     int return_code = 0;
     StartupBrowserCreator browser_creator;
     return StartupBrowserCreator::ProcessCmdLineImpl(
         command_line, base::FilePath(), false, profile,
         StartupBrowserCreator::Profiles(), &return_code, &browser_creator);
   }
 
  protected:
-  MessageLoopForUI message_loop_;
+  base::MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   base::Thread io_thread_;
 
   std::string startup_channel_id_;
   scoped_ptr<IPC::ChannelProxy> startup_channel_;
 
 #if defined(OS_MACOSX)
   base::ScopedTempDir temp_dir_;
   base::FilePath executable_path_, bundle_path_;
   scoped_ptr<MockLaunchd> mock_launchd_;
@@ skipping 10 matching lines @@
     void Wait() {
       if (seen_)
         return;
       running_ = true;
       content::RunMessageLoop();
     }
 
     void Notify() {
       seen_ = true;
       if (running_)
-        MessageLoopForUI::current()->Quit();
+        base::MessageLoopForUI::current()->Quit();
     }
 
    private:
     bool seen_;
     bool running_;
   };
 
   WindowedChannelConnectionObserver observer_;
 };
 
 CloudPrintProxyPolicyStartupTest::CloudPrintProxyPolicyStartupTest()
     : ui_thread_(content::BrowserThread::UI, &message_loop_),
       io_thread_("CloudPrintProxyPolicyTestThread") {
 }
 
 CloudPrintProxyPolicyStartupTest::~CloudPrintProxyPolicyStartupTest() {
 }
 
 void CloudPrintProxyPolicyStartupTest::SetUp() {
-  base::Thread::Options options(MessageLoop::TYPE_IO, 0);
+  base::Thread::Options options(base::MessageLoop::TYPE_IO, 0);
   ASSERT_TRUE(io_thread_.StartWithOptions(options));
 
 #if defined(OS_MACOSX)
   EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
   EXPECT_TRUE(MockLaunchd::MakeABundle(temp_dir_.path(),
                                        "CloudPrintProxyTest",
                                        &bundle_path_,
                                        &executable_path_));
   mock_launchd_.reset(new MockLaunchd(executable_path_, &message_loop_,
                                       true, false));
@@ skipping 99 matching lines @@
   TestingPrefServiceSyncable* prefs = profile->GetTestingPrefService();
   prefs->SetUserPref(prefs::kCloudPrintEmail,
                      Value::CreateStringValue(
                          MockServiceIPCServer::EnabledUserId()));
 
   CommandLine command_line(CommandLine::NO_PROGRAM);
   command_line.AppendSwitch(switches::kCheckCloudPrintConnectorPolicy);
   test_launcher_utils::PrepareBrowserCommandLineForTests(&command_line);
 
   WaitForConnect();
-  MessageLoop::current()->PostDelayedTask(FROM_HERE,
-                                          MessageLoop::QuitClosure(),
-                                          TestTimeouts::action_timeout());
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::MessageLoop::QuitClosure(),
+      TestTimeouts::action_timeout());
 
   bool run_loop = LaunchBrowser(command_line, profile);
   EXPECT_FALSE(run_loop);
   if (run_loop)
-    MessageLoop::current()->Run();
+    base::MessageLoop::current()->Run();
 
   EXPECT_EQ(MockServiceIPCServer::EnabledUserId(),
             prefs->GetString(prefs::kCloudPrintEmail));
 
   ShutdownAndWaitForExitWithTimeout(handle);
   profile_manager.DeleteTestingProfile("StartBrowserWithoutPolicy");
 }
 
 TEST_F(CloudPrintProxyPolicyStartupTest, StartBrowserWithPolicy) {
   base::ProcessHandle handle =
@@ skipping 14 matching lines @@
                      Value::CreateStringValue(
                          MockServiceIPCServer::EnabledUserId()));
   prefs->SetManagedPref(prefs::kCloudPrintProxyEnabled,
                         Value::CreateBooleanValue(false));
 
   CommandLine command_line(CommandLine::NO_PROGRAM);
   command_line.AppendSwitch(switches::kCheckCloudPrintConnectorPolicy);
   test_launcher_utils::PrepareBrowserCommandLineForTests(&command_line);
 
   WaitForConnect();
-  MessageLoop::current()->PostDelayedTask(FROM_HERE,
-                                          MessageLoop::QuitClosure(),
-                                          TestTimeouts::action_timeout());
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::MessageLoop::QuitClosure(),
+      TestTimeouts::action_timeout());
 
   bool run_loop = LaunchBrowser(command_line, profile);
 
   // No expectations on run_loop being true here; that would be a race
   // condition.
   if (run_loop)
-    MessageLoop::current()->Run();
+    base::MessageLoop::current()->Run();
 
   EXPECT_EQ("", prefs->GetString(prefs::kCloudPrintEmail));
 
   ShutdownAndWaitForExitWithTimeout(handle);
   profile_manager.DeleteTestingProfile("StartBrowserWithPolicy");
 }