chromeos: Use base::MessageLoop.

chromeos/process_proxy/process_proxy_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 <gtest/gtest.h>
 
 #include <string>
 #include <sys/wait.h>
 
 #include "base/bind.h"
@@ skipping 59 matching lines @@
     bool valid = true;
     for (size_t i = 0; i < output.length(); i++) {
       // The character output[i] should be next in at least one of the lines we
       // are testing.
       valid = (ProcessReceivedCharacter(output[i], 0) ||
                ProcessReceivedCharacter(output[i], 1));
       EXPECT_TRUE(valid) << "Received: " << output;
     }
 
     if (!valid || TestSucceeded()) {
-      MessageLoop::current()->PostTask(FROM_HERE,
-                                       MessageLoop::QuitClosure());
+      base::MessageLoop::current()->PostTask(FROM_HERE,
+                                             base::MessageLoop::QuitClosure());
     }
   }
 
   virtual void StartRegistryTest(ProcessProxyRegistry* registry) OVERRIDE {
     for (int i = 0; i < kTestLineNum; i++) {
       EXPECT_TRUE(registry->SendInput(pid_, kTestLineToSend));
     }
   }
 
  private:
@@ skipping 38 matching lines @@
                           const std::string& output) OVERRIDE {
     EXPECT_EQ(pid_, pid);
     if (!output_received_) {
       output_received_ = true;
       EXPECT_EQ(type, "stdout");
       EXPECT_EQ(output, "p");
       base::KillProcess(pid_, 0 , true);
       return;
     }
     EXPECT_EQ("exit", type);
-    MessageLoop::current()->PostTask(FROM_HERE,
-                                     MessageLoop::QuitClosure());
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+                                           base::MessageLoop::QuitClosure());
   }
 
   virtual void StartRegistryTest(ProcessProxyRegistry* registry) OVERRIDE {
     EXPECT_TRUE(registry->SendInput(pid_, "p"));
   }
 
  private:
   bool output_received_;
 };
 
 class SigIntTestRunner : public TestRunner {
  public:
   virtual ~SigIntTestRunner() {}
 
   virtual void SetupExpectations(pid_t pid) OVERRIDE {
     pid_ = pid;
   }
 
   virtual void OnSomeRead(pid_t pid, const std::string& type,
                           const std::string& output) OVERRIDE {
     EXPECT_EQ(pid_, pid);
     // We may receive ^C on stdout, but we don't care about that, as long as we
     // eventually received exit event.
     if (type == "exit") {
-      MessageLoop::current()->PostTask(FROM_HERE,
-                                       MessageLoop::QuitClosure());
+      base::MessageLoop::current()->PostTask(FROM_HERE,
+                                             base::MessageLoop::QuitClosure());
     }
   }
 
   virtual void StartRegistryTest(ProcessProxyRegistry* registry) OVERRIDE {
     // Send SingInt and verify the process exited.
     EXPECT_TRUE(registry->SendInput(pid_, "\003"));
   }
 };
 
 }  // namespace
@@ skipping 17 matching lines @@
   }
 
   void EndRegistryTest() {
     registry_->CloseProcess(pid_);
 
     base::TerminationStatus status = base::GetTerminationStatus(pid_, NULL);
     EXPECT_NE(base::TERMINATION_STATUS_STILL_RUNNING, status);
     if (status == base::TERMINATION_STATUS_STILL_RUNNING)
       base::KillProcess(pid_, 0, true);
 
-    MessageLoop::current()->PostTask(FROM_HERE,
-                                     MessageLoop::QuitClosure());
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+                                           base::MessageLoop::QuitClosure());
   }
 
   void RunTest() {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ProcessProxyTest::InitRegistryTest,
                    base::Unretained(this)));
 
     // Wait until all data from output watcher is received (QuitTask will be
     // fired on watcher thread).
-    MessageLoop::current()->Run();
+    base::MessageLoop::current()->Run();
 
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ProcessProxyTest::EndRegistryTest,
                    base::Unretained(this)));
 
     // Wait until we clean up the process proxy.
-    MessageLoop::current()->Run();
+    base::MessageLoop::current()->Run();
   }
 
   scoped_ptr<TestRunner> test_runner_;
 
  private:
   ProcessProxyRegistry* registry_;
   pid_t pid_;
 
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
 };
 
 // Test will open new process that will run cat command, and verify data we
 // write to process gets echoed back.
 TEST_F(ProcessProxyTest, RegistryTest) {
   test_runner_.reset(new RegistryTestRunner());
   RunTest();
 }
 
 // Open new process, then kill it. Verifiy that we detect when the process dies.
 TEST_F(ProcessProxyTest, RegistryNotifiedOnProcessExit) {
   test_runner_.reset(new RegistryNotifiedOnProcessExitTestRunner());
   RunTest();
 }
 
 // Test verifies that \003 message send to process is processed as SigInt.
 // Timing out on the waterfall: http://crbug.com/115064
 TEST_F(ProcessProxyTest, DISABLED_SigInt) {
   test_runner_.reset(new SigIntTestRunner());
   RunTest();
 }
 
 }  // namespace chromeos