dbus: Use base::MessageLoop.

dbus/end_to_end_async_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 <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 23 matching lines @@
  public:
   EndToEndAsyncTest() : on_disconnected_call_count_(0) {}
 
   virtual void SetUp() {
     // Make the main thread not to allow IO.
     base::ThreadRestrictions::SetIOAllowed(false);
 
     // Start the D-Bus thread.
     dbus_thread_.reset(new base::Thread("D-Bus Thread"));
     base::Thread::Options thread_options;
-    thread_options.message_loop_type = MessageLoop::TYPE_IO;
+    thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
     ASSERT_TRUE(dbus_thread_->StartWithOptions(thread_options));
 
     // Start the test service, using the D-Bus thread.
     dbus::TestService::Options options;
     options.dbus_task_runner = dbus_thread_->message_loop_proxy();
     test_service_.reset(new dbus::TestService(options));
     ASSERT_TRUE(test_service_->StartService());
     ASSERT_TRUE(test_service_->WaitUntilServiceIsStarted());
     ASSERT_TRUE(test_service_->HasDBusThread());
 
@@ skipping 191 matching lines @@
     message_loop_.Quit();
     ++on_disconnected_call_count_;
   }
 
   // Wait for the hey signal to be received.
   void WaitForTestSignal() {
     // OnTestSignal() will quit the message loop.
     message_loop_.Run();
   }
 
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
   std::vector<std::string> response_strings_;
   std::vector<std::string> error_names_;
   scoped_ptr<base::Thread> dbus_thread_;
   scoped_refptr<dbus::Bus> bus_;
   dbus::ObjectProxy* object_proxy_;
   dbus::ObjectProxy* root_object_proxy_;
   scoped_ptr<dbus::TestService> test_service_;
   // Text message from "Test" signal.
   std::string test_signal_string_;
   // Text message from "Test" signal delivered to root.
@@ skipping 263 matching lines @@
   dbus::MessageWriter writer(&method_call);
   writer.AppendString(kHello);
 
   // Call the method with an empty callback.
   const int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT;
   object_proxy_->CallMethod(&method_call,
                             timeout_ms,
                             dbus::ObjectProxy::EmptyResponseCallback());
   // Post a delayed task to quit the message loop.
   message_loop_.PostDelayedTask(FROM_HERE,
-                                MessageLoop::QuitClosure(),
+                                base::MessageLoop::QuitClosure(),
                                 TestTimeouts::tiny_timeout());
   message_loop_.Run();
   // We cannot tell if the empty callback is called, but at least we can
   // check if the test does not crash.
 }
 
 TEST_F(EndToEndAsyncTest, TestSignal) {
   const char kMessage[] = "hello, world";
   // Send the test signal from the exported object.
   test_service_->SendTestSignal(kMessage);
@@ skipping 84 matching lines @@
   const char kMessage[] = "hello, world";
   // Send the test signal from the exported object.
   test_service_->SendTestSignal(kMessage);
   // Receive the signal with the object proxy.
   WaitForTestSignal();
   // Verify the string WAS received by the original handler.
   ASSERT_EQ(kMessage, test_signal_string_);
   // Verify the signal WAS ALSO received by the additional handler.
   ASSERT_EQ(kMessage, additional_test_signal_string_);
 }