DBus: Use TaskRunners instead of MessageLoopProxies.

dbus/signal_sender_verification_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/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/statistics_recorder.h"
@@ skipping 23 matching lines @@
     // 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;
     ASSERT_TRUE(dbus_thread_->StartWithOptions(thread_options));
 
     // Create the client, using the D-Bus thread.
     dbus::Bus::Options bus_options;
     bus_options.bus_type = dbus::Bus::SESSION;
     bus_options.connection_type = dbus::Bus::PRIVATE;
-    bus_options.dbus_thread_message_loop_proxy =
-        dbus_thread_->message_loop_proxy();
+    bus_options.dbus_task_runner = dbus_thread_->message_loop_proxy();
     bus_ = new dbus::Bus(bus_options);
     object_proxy_ = bus_->GetObjectProxy(
         "org.chromium.TestService",
         dbus::ObjectPath("/org/chromium/TestObject"));
     ASSERT_TRUE(bus_->HasDBusThread());
 
     object_proxy_->SetNameOwnerChangedCallback(
         base::Bind(&SignalSenderVerificationTest::OnNameOwnerChanged,
                    base::Unretained(this),
                    &on_name_owner_changed_called_));
 
     // Connect to the "Test" signal of "org.chromium.TestInterface" from
     // the remote object.
     object_proxy_->ConnectToSignal(
         "org.chromium.TestInterface",
         "Test",
         base::Bind(&SignalSenderVerificationTest::OnTestSignal,
                    base::Unretained(this)),
         base::Bind(&SignalSenderVerificationTest::OnConnected,
                    base::Unretained(this)));
     // Wait until the object proxy is connected to the signal.
     message_loop_.Run();
 
     // Start the test service, using the D-Bus thread.
     dbus::TestService::Options options;
-    options.dbus_thread_message_loop_proxy = dbus_thread_->message_loop_proxy();
+    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());
     ASSERT_TRUE(test_service_->has_ownership());
 
     // Same setup for the second TestService. This service should not have the
     // ownership of the name at this point.
     test_service2_.reset(new dbus::TestService(options));
     ASSERT_TRUE(test_service2_->StartService());
     ASSERT_TRUE(test_service2_->WaitUntilServiceIsStarted());
     ASSERT_TRUE(test_service2_->HasDBusThread());
     ASSERT_FALSE(test_service2_->has_ownership());
 
     // The name should be owned and known at this point.
     if (!on_name_owner_changed_called_)
       message_loop_.Run();
     ASSERT_FALSE(latest_name_owner_.empty());
-
   }
 
   virtual void TearDown() {
     bus_->ShutdownOnDBusThreadAndBlock();
 
     // Shut down the service.
     test_service_->ShutdownAndBlock();
     test_service2_->ShutdownAndBlock();
 
     // Reset to the default.
@@ skipping 40 matching lines @@
 
   // Called when connected to the signal.
   void OnConnected(const std::string& interface_name,
                    const std::string& signal_name,
                    bool success) {
     ASSERT_TRUE(success);
     message_loop_.Quit();
   }
 
  protected:
-
   // Wait for the hey signal to be received.
   void WaitForTestSignal() {
     // OnTestSignal() will quit the message loop.
     message_loop_.Run();
   }
 
   MessageLoop message_loop_;
   scoped_ptr<base::Thread> dbus_thread_;
   scoped_refptr<dbus::Bus> bus_;
   dbus::ObjectProxy* object_proxy_;
@@ skipping 145 matching lines @@
   // latest_name_owner_ becomes non empty as the new owner appears.
   ASSERT_FALSE(latest_name_owner_.empty());
 
   // Now the second service owns the name.
   const char kNewMessage[] = "hello, new world";
 
   test_service2_->SendTestSignal(kNewMessage);
   WaitForTestSignal();
   ASSERT_EQ(kNewMessage, test_signal_string_);
 }