Supporting callback for Disconnected signal.

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"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "dbus/test_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace dbus {
+class DisconnectableBusForTesting : public Bus {
+ public:
+  explicit DisconnectableBusForTesting(const Options& options)
+      : Bus(options) {}
+
+  // Disconnects on-going connection.
+  void CloseConnection() {
+    CHECK(is_connected()) << "There is no on-going connection.";
+    dbus_connection_close(connection_);
+  }
+
+ protected:
+  ~DisconnectableBusForTesting() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DisconnectableBusForTesting);
+};
+}  // namespace dbus
+
 namespace {
 
 // See comments in ObjectProxy::RunResponseCallback() for why the number was
 // chosen.
 const int kHugePayloadSize = 64 << 20;  // 64 MB
 
 }  // namespace
 
 // The end-to-end test exercises the asynchronous APIs in ObjectProxy and
 // ExportedObject.
 class EndToEndAsyncTest : public testing::Test {
  public:
-  EndToEndAsyncTest() {
-  }
+  EndToEndAsyncTest() : on_disconnected_callcount_(0) {}

[satorux1, 2013/02/13 08:06:53]

callcount -> call_count

[Seigo Nonaka, 2013/02/13 09:45:29]

Done.

 
   virtual void SetUp() {
+    // Reset function call count.
+    on_disconnected_callcount_ = 0;
+
     // 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;
     ASSERT_TRUE(dbus_thread_->StartWithOptions(thread_options));
 
     // Start the test service, using the D-Bus thread.
@@ skipping 69 matching lines @@
     test_service_->ShutdownAndBlock();
 
     // Reset to the default.
     base::ThreadRestrictions::SetIOAllowed(true);
 
     // Stopping a thread is considered an IO operation, so do this after
     // allowing IO.
     test_service_->Stop();
   }
 
+  // Callback function for "Disconnected" signal.
+  void OnDisconnected() {
+    ++on_disconnected_callcount_;
+    message_loop_.Quit();
+  }
+
  protected:
   // Replaces the bus with a broken one.
   void SetUpBrokenBus() {
     // Shut down the existing bus.
     bus_->ShutdownOnDBusThreadAndBlock();
 
     // Create new bus with invalid address.
     const char kInvalidAddress[] = "";
     dbus::Bus::Options bus_options;
     bus_options.bus_type = dbus::Bus::CUSTOM_ADDRESS;
     bus_options.address = kInvalidAddress;
     bus_options.connection_type = dbus::Bus::PRIVATE;
     bus_options.dbus_thread_message_loop_proxy =
         dbus_thread_->message_loop_proxy();
     bus_ = new dbus::Bus(bus_options);
     ASSERT_TRUE(bus_->HasDBusThread());
 
     // Create new object proxy.
     object_proxy_ = bus_->GetObjectProxy(
         "org.chromium.TestService",
         dbus::ObjectPath("/org/chromium/TestObject"));
   }
 
+  // Replace the bus with DisconnectableBusFOrTesting.
+  void SetUpDisconnectableBus() {
+    // Shut down the existing bus.
+    bus_->ShutdownOnDBusThreadAndBlock();
+
+    // Create new disconnectable bus.
+    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_ = new dbus::DisconnectableBusForTesting(bus_options);
+    ASSERT_TRUE(bus_->HasDBusThread());
+
+    // Create new object proxy.
+    object_proxy_ = bus_->GetObjectProxy(
+        "org.chromium.TestService",
+        dbus::ObjectPath("/org/chromium/TestObject"));
+
+    // Connect to the "Test" signal of "org.chromium.TestInterface" from
+    // the remote object.
+    object_proxy_->ConnectToSignal(
+        "org.chromium.TestInterface",
+        "Test",
+        base::Bind(&EndToEndAsyncTest::OnTestSignal,
+                   base::Unretained(this)),
+        base::Bind(&EndToEndAsyncTest::OnConnected,
+                   base::Unretained(this)));
+    // Wait until the object proxy is connected to the signal.
+    message_loop_.Run();
+  }
+
   // Calls the method asynchronously. OnResponse() will be called once the
   // response is received.
   void CallMethod(dbus::MethodCall* method_call,
                   int timeout_ms) {
     object_proxy_->CallMethod(method_call,
                               timeout_ms,
                               base::Bind(&EndToEndAsyncTest::OnResponse,
                                          base::Unretained(this)));
   }
 
@@ skipping 92 matching lines @@
   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.
   std::string root_test_signal_string_;
+  int on_disconnected_callcount_;
 };
 
 TEST_F(EndToEndAsyncTest, Echo) {
   const char* kHello = "hello";
 
   // Create the method call.
   dbus::MethodCall method_call("org.chromium.TestInterface", "Echo");
   dbus::MessageWriter writer(&method_call);
   writer.AppendString(kHello);
 
@@ skipping 292 matching lines @@
 TEST_F(EndToEndAsyncTest, TestHugeSignal) {
   const std::string kHugeMessage(kHugePayloadSize, 'o');
 
   // Send the huge signal from the exported object.
   test_service_->SendTestSignal(kHugeMessage);
   // This caused a DCHECK failure before. Ensure that the issue is fixed.
   WaitForTestSignal();
   ASSERT_EQ(kHugeMessage, test_signal_string_);
 }
 
+TEST_F(EndToEndAsyncTest, DisconnectedSignal) {
+  // Set up a disconnectable bus.
+  SetUpDisconnectableBus();
+  dbus::DisconnectableBusForTesting* disconnectable_bus =
+      static_cast<dbus::DisconnectableBusForTesting*>(bus_.get());
+
+  disconnectable_bus->SetDisconnectedCallback(
+      base::Bind(&EndToEndAsyncTest::OnDisconnected,
+                 base::Unretained(this)));
+
+  // Request diconnect from daemon.
+  disconnectable_bus->PostTaskToDBusThread(
+      FROM_HERE,
+      base::Bind(
+          &dbus::DisconnectableBusForTesting::CloseConnection,
+          base::Unretained(disconnectable_bus)));
+
+  // OnDisconnected will quit message loop.
+  message_loop_.Run();
+
+  EXPECT_EQ(1, on_disconnected_callcount_);
+}
+
 class SignalReplacementTest : public EndToEndAsyncTest {
  public:
   SignalReplacementTest() {
   }
 
   virtual void SetUp() {
     // Set up base class.
     EndToEndAsyncTest::SetUp();
 
     // Reconnect the root object proxy's signal handler to a new handler
@@ skipping 35 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 NOT received by the original handler.
   ASSERT_TRUE(test_signal_string_.empty());
   // Verify the signal WAS received by the replacement handler.
   ASSERT_EQ(kMessage, replacement_test_signal_string_);
 }