Use base::MessageLoop in more files.

base/mac/libdispatch_task_runner_unittest.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/mac/libdispatch_task_runner.h"
 
 #include "base/bind.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 class LibDispatchTaskRunnerTest : public testing::Test {
  public:
   virtual void SetUp() OVERRIDE {
     task_runner_ = new base::mac::LibDispatchTaskRunner(
         "org.chromium.LibDispatchTaskRunnerTest");
   }
 
   // DispatchLastTask is used to run the main test thread's MessageLoop until
   // all non-delayed tasks are run on the LibDispatchTaskRunner.
   void DispatchLastTask() {
     dispatch_async(task_runner_->GetDispatchQueue(), ^{
         (&message_loop_)->PostTask(FROM_HERE,
-                                   MessageLoop::QuitWhenIdleClosure());
+                                   base::MessageLoop::QuitWhenIdleClosure());
     });
     message_loop_.Run();
     task_runner_->Shutdown();
   }
 
   // VerifyTaskOrder takes the expectations from TaskOrderMarkers and compares
   // them against the recorded values.
   void VerifyTaskOrder(const char* const expectations[],
                        size_t num_expectations) {
     size_t actual_size = task_order_.size();
 
     for (size_t i = 0; i < num_expectations; ++i) {
       if (i >= actual_size) {
         EXPECT_LE(i, actual_size) << "Expected " << expectations[i];
         continue;
       }
 
       EXPECT_EQ(expectations[i], task_order_[i]);
     }
 
     if (actual_size > num_expectations) {
       EXPECT_LE(actual_size, num_expectations) << "Extra tasks were run:";
       for (size_t i = num_expectations; i < actual_size; ++i) {
         EXPECT_EQ("<none>", task_order_[i]) << " (i=" << i << ")";
       }
     }
   }
 
   // The message loop for the test main thread.
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
 
   // The task runner under test.
   scoped_refptr<base::mac::LibDispatchTaskRunner> task_runner_;
 
   // Vector that records data from TaskOrderMarker.
   std::vector<std::string> task_order_;
 };
 
 // Scoper that records the beginning and end of a running task.
 class TaskOrderMarker {
@@ skipping 44 matching lines @@
     "END Outer",
     "BEGIN Inner",
     "END Inner"
   };
   VerifyTaskOrder(expectations, arraysize(expectations));
 }
 
 TEST_F(LibDispatchTaskRunnerTest, NoMessageLoop) {
   task_runner_->PostTask(FROM_HERE, base::BindBlock(^{
       TaskOrderMarker marker(this,
-          base::StringPrintf("MessageLoop = %p", MessageLoop::current()));
+          base::StringPrintf("MessageLoop = %p", base::MessageLoop::current()));
   }));
   DispatchLastTask();
 
   const char* const expectations[] = {
     "BEGIN MessageLoop = 0x0",
     "END MessageLoop = 0x0"
   };
   VerifyTaskOrder(expectations, arraysize(expectations));
 }
 
@@ skipping 20 matching lines @@
   };
   VerifyTaskOrder(expectations, arraysize(expectations));
 }
 
 TEST_F(LibDispatchTaskRunnerTest, NonNestable) {
   task_runner_->PostTask(FROM_HERE, base::BindBlock(^{
       TaskOrderMarker marker(this, "First");
       task_runner_->PostNonNestableTask(FROM_HERE, base::BindBlock(^{
           TaskOrderMarker marker(this, "Second NonNestable");
           (&message_loop_)->PostTask(FROM_HERE,
-                                     MessageLoop::QuitWhenIdleClosure());
+                                     base::MessageLoop::QuitWhenIdleClosure());
       }));
   }));
   message_loop_.Run();
   task_runner_->Shutdown();
 
   const char* const expectations[] = {
     "BEGIN First",
     "END First",
     "BEGIN Second NonNestable",
     "END Second NonNestable"
   };
   VerifyTaskOrder(expectations, arraysize(expectations));
 }
 
 TEST_F(LibDispatchTaskRunnerTest, PostDelayed) {
   base::TimeTicks post_time;
   __block base::TimeTicks run_time;
   const base::TimeDelta delta = base::TimeDelta::FromMilliseconds(50);
 
   task_runner_->PostTask(FROM_HERE, BoundRecordTaskOrder(this, "First"));
   post_time = base::TimeTicks::Now();
   task_runner_->PostDelayedTask(FROM_HERE, base::BindBlock(^{
       TaskOrderMarker marker(this, "Timed");
       run_time = base::TimeTicks::Now();
-      (&message_loop_)->PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure());
+      (&message_loop_)->PostTask(FROM_HERE,
+                                 base::MessageLoop::QuitWhenIdleClosure());
   }), delta);
   task_runner_->PostTask(FROM_HERE, BoundRecordTaskOrder(this, "Second"));
   message_loop_.Run();
   task_runner_->Shutdown();
 
   const char* const expectations[] = {
     "BEGIN First",
     "END First",
     "BEGIN Second",
     "END Second",
@@ skipping 17 matching lines @@
   })));
 
   const char* const expectations[] = {
     "BEGIN First",
     "END First",
     "BEGIN Second",
     "END Second"
   };
   VerifyTaskOrder(expectations, arraysize(expectations));
 }