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

chrome/browser/chromeos/login/login_utils_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 "chrome/browser/chromeos/login/login_utils.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 116 matching lines @@
 }
 
 // Single task of the fake IO loop used in the test, that just waits until
 // it is signaled to quit or perform some work.
 // |completion| is the event to wait for, and |work| is the task to invoke
 // when signaled. If the task returns false then this quits the IO loop.
 void BlockLoop(base::WaitableEvent* completion, base::Callback<bool()> work) {
   do {
     completion->Wait();
   } while (work.Run());
-  MessageLoop::current()->QuitNow();
+  base::MessageLoop::current()->QuitNow();
 }
 
 void CopyLockResult(base::RunLoop* loop,
                     policy::EnterpriseInstallAttributes::LockResult* out,
                     policy::EnterpriseInstallAttributes::LockResult result) {
   *out = result;
   loop->Quit();
 }
 
 class LoginUtilsTest : public testing::Test,
                        public LoginUtils::Delegate,
                        public LoginStatusConsumer {
  public:
   // Initialization here is important. The UI thread gets the test's
   // message loop, as does the file thread (which never actually gets
   // started - so this is a way to fake multiple threads on a single
   // test thread).  The IO thread does not get the message loop set,
   // and is never started.  This is necessary so that we skip various
   // bits of initialization that get posted to the IO thread.  We do
   // however, at one point in the test, temporarily set the message
   // loop for the IO thread.
   LoginUtilsTest()
       : fake_io_thread_completion_(false, false),
         fake_io_thread_("fake_io_thread"),
-        loop_(MessageLoop::TYPE_IO),
+        loop_(base::MessageLoop::TYPE_IO),
         browser_process_(TestingBrowserProcess::GetGlobal()),
         local_state_(browser_process_),
         ui_thread_(BrowserThread::UI, &loop_),
         db_thread_(BrowserThread::DB, &loop_),
         file_thread_(BrowserThread::FILE, &loop_),
         mock_input_method_manager_(NULL),
         mock_async_method_caller_(NULL),
         connector_(NULL),
         cryptohome_(NULL),
         prepared_profile_(NULL) {}
 
   virtual void SetUp() OVERRIDE {
     // This test is not a full blown InProcessBrowserTest, and doesn't have
     // all the usual threads running. However a lot of subsystems pulled from
     // ProfileImpl post to IO (usually from ProfileIOData), and DCHECK that
     // those tasks were posted. Those tasks in turn depend on a lot of other
     // components that aren't there during this test, so this kludge is used to
     // have a running IO loop that doesn't really execute any tasks.
     //
     // See InvokeOnIO() below for a way to perform specific tasks on IO, when
     // that's necessary.
 
     // A thread is needed to create a new MessageLoop, since there can be only
     // one loop per thread.
     fake_io_thread_.StartWithOptions(
-        base::Thread::Options(MessageLoop::TYPE_IO, 0));
-    MessageLoop* fake_io_loop = fake_io_thread_.message_loop();
+        base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
+    base::MessageLoop* fake_io_loop = fake_io_thread_.message_loop();
     // Make this loop enter the single task, BlockLoop(). Pass in the completion
     // event and the work callback.
     fake_io_thread_.StopSoon();
     fake_io_loop->PostTask(
         FROM_HERE,
         base::Bind(
           BlockLoop,
           &fake_io_thread_completion_,
           base::Bind(&LoginUtilsTest::DoIOWork, base::Unretained(this))));
     // Map BrowserThread::IO to this loop. This allows posting to IO but nothing
@@ skipping 156 matching lines @@
   }
 
   // Helper for BlockLoop, InvokeOnIO and QuitIOLoop.
   bool DoIOWork() {
     bool has_work = !fake_io_thread_work_.is_null();
     if (has_work)
       fake_io_thread_work_.Run();
     fake_io_thread_work_.Reset();
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        MessageLoop::QuitWhenIdleClosure());
+        base::MessageLoop::QuitWhenIdleClosure());
     // If there was work then keep waiting for more work.
     // If there was no work then quit the fake IO loop.
     return has_work;
   }
 
   virtual void OnProfilePrepared(Profile* profile) OVERRIDE {
     EXPECT_FALSE(prepared_profile_);
     prepared_profile_ = profile;
   }
 
@@ skipping 119 matching lines @@
     return PrepareDMServiceFetcher(kDMPolicyRequest, response);
   }
 
  protected:
   ScopedStubCrosEnabler stub_cros_enabler_;
 
   base::Closure fake_io_thread_work_;
   base::WaitableEvent fake_io_thread_completion_;
   base::Thread fake_io_thread_;
 
-  MessageLoop loop_;
+  base::MessageLoop loop_;
   TestingBrowserProcess* browser_process_;
   ScopedTestingLocalState local_state_;
 
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread db_thread_;
   content::TestBrowserThread file_thread_;
   scoped_ptr<content::TestBrowserThread> io_thread_;
   scoped_ptr<IOThread> io_thread_state_;
 
   MockDBusThreadManagerWithoutGMock mock_dbus_thread_manager_;
@@ skipping 201 matching lines @@
 }
 
 INSTANTIATE_TEST_CASE_P(
     LoginUtilsBlockingLoginTestInstance,
     LoginUtilsBlockingLoginTest,
     testing::Values(0, 1, 2, 3, 4, 5));
 
 }  // namespace
 
 }