dbus/bus_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "dbus/bus.h"
   6
   7 #include "base/bind.h"
   8 #include "base/memory/ref_counted.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/run_loop.h"
  11 #include "base/threading/thread.h"
  12 #include "dbus/exported_object.h"
  13 #include "dbus/object_path.h"
  14 #include "dbus/object_proxy.h"
  15 #include "dbus/scoped_dbus_error.h"
  16 #include "dbus/test_service.h"
  17
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 namespace dbus {
  21
  22 namespace {
  23
  24 // Used to test AddFilterFunction().
  25 DBusHandlerResult DummyHandler(DBusConnection* connection,
  26                                DBusMessage* raw_message,
  27                                void* user_data) {
  28   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
  29 }
  30
  31 // Test helper for BusTest.ListenForServiceOwnerChange that wraps a
  32 // base::RunLoop. At Run() time, the caller pass in the expected number of
  33 // quit calls, and at QuitIfConditionIsSatisified() time, only quit the RunLoop
  34 // if the expected number of quit calls have been reached.
  35 class RunLoopWithExpectedCount {
  36  public:
  37   RunLoopWithExpectedCount() : expected_quit_calls_(0), actual_quit_calls_(0) {}
  38   ~RunLoopWithExpectedCount() {}
  39
  40   void Run(int expected_quit_calls) {
  41     DCHECK_EQ(0, expected_quit_calls_);
  42     DCHECK_EQ(0, actual_quit_calls_);
  43     expected_quit_calls_ = expected_quit_calls;
  44     run_loop_.reset(new base::RunLoop());
  45     run_loop_->Run();
  46   }
  47
  48   void QuitIfConditionIsSatisified() {
  49     if (++actual_quit_calls_ != expected_quit_calls_)
  50       return;
  51     run_loop_->Quit();
  52     expected_quit_calls_ = 0;
  53     actual_quit_calls_ = 0;
  54   }
  55
  56  private:
  57   scoped_ptr<base::RunLoop> run_loop_;
  58   int expected_quit_calls_;
  59   int actual_quit_calls_;
  60
  61   DISALLOW_COPY_AND_ASSIGN(RunLoopWithExpectedCount);
  62 };
  63
  64 // Test helper for BusTest.ListenForServiceOwnerChange.
  65 void OnServiceOwnerChanged(RunLoopWithExpectedCount* run_loop_state,
  66                            std::string* service_owner,
  67                            int* num_of_owner_changes,
  68                            const std::string& new_service_owner) {
  69   *service_owner = new_service_owner;
  70   ++(*num_of_owner_changes);
  71   run_loop_state->QuitIfConditionIsSatisified();
  72 }
  73
  74 }  // namespace
  75
  76 TEST(BusTest, GetObjectProxy) {
  77   Bus::Options options;
  78   scoped_refptr<Bus> bus = new Bus(options);
  79
  80   ObjectProxy* object_proxy1 =
  81       bus->GetObjectProxy("org.chromium.TestService",
  82                           ObjectPath("/org/chromium/TestObject"));
  83   ASSERT_TRUE(object_proxy1);
  84
  85   // This should return the same object.
  86   ObjectProxy* object_proxy2 =
  87       bus->GetObjectProxy("org.chromium.TestService",
  88                           ObjectPath("/org/chromium/TestObject"));
  89   ASSERT_TRUE(object_proxy2);
  90   EXPECT_EQ(object_proxy1, object_proxy2);
  91
  92   // This should not.
  93   ObjectProxy* object_proxy3 =
  94       bus->GetObjectProxy(
  95           "org.chromium.TestService",
  96           ObjectPath("/org/chromium/DifferentTestObject"));
  97   ASSERT_TRUE(object_proxy3);
  98   EXPECT_NE(object_proxy1, object_proxy3);
  99
 100   bus->ShutdownAndBlock();
 101 }
 102
 103 TEST(BusTest, GetObjectProxyIgnoreUnknownService) {
 104   Bus::Options options;
 105   scoped_refptr<Bus> bus = new Bus(options);
 106
 107   ObjectProxy* object_proxy1 =
 108       bus->GetObjectProxyWithOptions(
 109           "org.chromium.TestService",
 110           ObjectPath("/org/chromium/TestObject"),
 111           ObjectProxy::IGNORE_SERVICE_UNKNOWN_ERRORS);
 112   ASSERT_TRUE(object_proxy1);
 113
 114   // This should return the same object.
 115   ObjectProxy* object_proxy2 =
 116       bus->GetObjectProxyWithOptions(
 117           "org.chromium.TestService",
 118           ObjectPath("/org/chromium/TestObject"),
 119           ObjectProxy::IGNORE_SERVICE_UNKNOWN_ERRORS);
 120   ASSERT_TRUE(object_proxy2);
 121   EXPECT_EQ(object_proxy1, object_proxy2);
 122
 123   // This should not.
 124   ObjectProxy* object_proxy3 =
 125       bus->GetObjectProxyWithOptions(
 126           "org.chromium.TestService",
 127           ObjectPath("/org/chromium/DifferentTestObject"),
 128           ObjectProxy::IGNORE_SERVICE_UNKNOWN_ERRORS);
 129   ASSERT_TRUE(object_proxy3);
 130   EXPECT_NE(object_proxy1, object_proxy3);
 131
 132   bus->ShutdownAndBlock();
 133 }
 134
 135 TEST(BusTest, RemoveObjectProxy) {
 136   // Setup the current thread's MessageLoop.
 137   base::MessageLoop message_loop;
 138
 139   // Start the D-Bus thread.
 140   base::Thread::Options thread_options;
 141   thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
 142   base::Thread dbus_thread("D-Bus thread");
 143   dbus_thread.StartWithOptions(thread_options);
 144
 145   // Create the bus.
 146   Bus::Options options;
 147   options.dbus_task_runner = dbus_thread.message_loop_proxy();
 148   scoped_refptr<Bus> bus = new Bus(options);
 149   ASSERT_FALSE(bus->shutdown_completed());
 150
 151   // Try to remove a non existant object proxy should return false.
 152   ASSERT_FALSE(
 153       bus->RemoveObjectProxy("org.chromium.TestService",
 154                              ObjectPath("/org/chromium/TestObject"),
 155                              base::Bind(&base::DoNothing)));
 156
 157   ObjectProxy* object_proxy1 =
 158       bus->GetObjectProxy("org.chromium.TestService",
 159                           ObjectPath("/org/chromium/TestObject"));
 160   ASSERT_TRUE(object_proxy1);
 161
 162   // Increment the reference count to the object proxy to avoid destroying it
 163   // while removing the object.
 164   object_proxy1->AddRef();
 165
 166   // Remove the object from the bus. This will invalidate any other usage of
 167   // object_proxy1 other than destroy it. We keep this object for a comparison
 168   // at a later time.
 169   ASSERT_TRUE(
 170       bus->RemoveObjectProxy("org.chromium.TestService",
 171                              ObjectPath("/org/chromium/TestObject"),
 172                              base::Bind(&base::DoNothing)));
 173
 174   // This should return a different object because the first object was removed
 175   // from the bus, but not deleted from memory.
 176   ObjectProxy* object_proxy2 =
 177       bus->GetObjectProxy("org.chromium.TestService",
 178                           ObjectPath("/org/chromium/TestObject"));
 179   ASSERT_TRUE(object_proxy2);
 180
 181   // Compare the new object with the first object. The first object still exists
 182   // thanks to the increased reference.
 183   EXPECT_NE(object_proxy1, object_proxy2);
 184
 185   // Release object_proxy1.
 186   object_proxy1->Release();
 187
 188   // Shut down synchronously.
 189   bus->ShutdownOnDBusThreadAndBlock();
 190   EXPECT_TRUE(bus->shutdown_completed());
 191   dbus_thread.Stop();
 192 }
 193
 194 TEST(BusTest, GetExportedObject) {
 195   Bus::Options options;
 196   scoped_refptr<Bus> bus = new Bus(options);
 197
 198   ExportedObject* object_proxy1 =
 199       bus->GetExportedObject(ObjectPath("/org/chromium/TestObject"));
 200   ASSERT_TRUE(object_proxy1);
 201
 202   // This should return the same object.
 203   ExportedObject* object_proxy2 =
 204       bus->GetExportedObject(ObjectPath("/org/chromium/TestObject"));
 205   ASSERT_TRUE(object_proxy2);
 206   EXPECT_EQ(object_proxy1, object_proxy2);
 207
 208   // This should not.
 209   ExportedObject* object_proxy3 =
 210       bus->GetExportedObject(
 211           ObjectPath("/org/chromium/DifferentTestObject"));
 212   ASSERT_TRUE(object_proxy3);
 213   EXPECT_NE(object_proxy1, object_proxy3);
 214
 215   bus->ShutdownAndBlock();
 216 }
 217
 218 TEST(BusTest, UnregisterExportedObject) {
 219   // Start the D-Bus thread.
 220   base::Thread::Options thread_options;
 221   thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
 222   base::Thread dbus_thread("D-Bus thread");
 223   dbus_thread.StartWithOptions(thread_options);
 224
 225   // Create the bus.
 226   Bus::Options options;
 227   options.dbus_task_runner = dbus_thread.message_loop_proxy();
 228   scoped_refptr<Bus> bus = new Bus(options);
 229   ASSERT_FALSE(bus->shutdown_completed());
 230
 231   ExportedObject* object_proxy1 =
 232       bus->GetExportedObject(ObjectPath("/org/chromium/TestObject"));
 233   ASSERT_TRUE(object_proxy1);
 234
 235   // Increment the reference count to the object proxy to avoid destroying it
 236   // calling UnregisterExportedObject. This ensures the dbus::ExportedObject is
 237   // not freed from memory. See http://crbug.com/137846 for details.
 238   object_proxy1->AddRef();
 239
 240   bus->UnregisterExportedObject(ObjectPath("/org/chromium/TestObject"));
 241
 242   // This should return a new object because the object_proxy1 is still in
 243   // alloc'ed memory.
 244   ExportedObject* object_proxy2 =
 245       bus->GetExportedObject(ObjectPath("/org/chromium/TestObject"));
 246   ASSERT_TRUE(object_proxy2);
 247   EXPECT_NE(object_proxy1, object_proxy2);
 248
 249   // Release the incremented reference.
 250   object_proxy1->Release();
 251
 252   // Shut down synchronously.
 253   bus->ShutdownOnDBusThreadAndBlock();
 254   EXPECT_TRUE(bus->shutdown_completed());
 255   dbus_thread.Stop();
 256 }
 257
 258 TEST(BusTest, ShutdownAndBlock) {
 259   Bus::Options options;
 260   scoped_refptr<Bus> bus = new Bus(options);
 261   ASSERT_FALSE(bus->shutdown_completed());
 262
 263   // Shut down synchronously.
 264   bus->ShutdownAndBlock();
 265   EXPECT_TRUE(bus->shutdown_completed());
 266 }
 267
 268 TEST(BusTest, ShutdownAndBlockWithDBusThread) {
 269   // Start the D-Bus thread.
 270   base::Thread::Options thread_options;
 271   thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
 272   base::Thread dbus_thread("D-Bus thread");
 273   dbus_thread.StartWithOptions(thread_options);
 274
 275   // Create the bus.
 276   Bus::Options options;
 277   options.dbus_task_runner = dbus_thread.message_loop_proxy();
 278   scoped_refptr<Bus> bus = new Bus(options);
 279   ASSERT_FALSE(bus->shutdown_completed());
 280
 281   // Shut down synchronously.
 282   bus->ShutdownOnDBusThreadAndBlock();
 283   EXPECT_TRUE(bus->shutdown_completed());
 284   dbus_thread.Stop();
 285 }
 286
 287 TEST(BusTest, AddFilterFunction) {
 288   Bus::Options options;
 289   scoped_refptr<Bus> bus = new Bus(options);
 290   // Should connect before calling AddFilterFunction().
 291   bus->Connect();
 292
 293   int data1 = 100;
 294   int data2 = 200;
 295   ASSERT_TRUE(bus->AddFilterFunction(&DummyHandler, &data1));
 296   // Cannot add the same function with the same data.
 297   ASSERT_FALSE(bus->AddFilterFunction(&DummyHandler, &data1));
 298   // Can add the same function with different data.
 299   ASSERT_TRUE(bus->AddFilterFunction(&DummyHandler, &data2));
 300
 301   ASSERT_TRUE(bus->RemoveFilterFunction(&DummyHandler, &data1));
 302   ASSERT_FALSE(bus->RemoveFilterFunction(&DummyHandler, &data1));
 303   ASSERT_TRUE(bus->RemoveFilterFunction(&DummyHandler, &data2));
 304
 305   bus->ShutdownAndBlock();
 306 }
 307
 308 TEST(BusTest, DoubleAddAndRemoveMatch) {
 309   Bus::Options options;
 310   scoped_refptr<Bus> bus = new Bus(options);
 311   ScopedDBusError error;
 312
 313   bus->Connect();
 314
 315   // Adds the same rule twice.
 316   bus->AddMatch(
 317       "type='signal',interface='org.chromium.TestService',path='/'",
 318       error.get());
 319   ASSERT_FALSE(error.is_set());
 320
 321   bus->AddMatch(
 322       "type='signal',interface='org.chromium.TestService',path='/'",
 323       error.get());
 324   ASSERT_FALSE(error.is_set());
 325
 326   // Removes the same rule twice.
 327   ASSERT_TRUE(bus->RemoveMatch(
 328       "type='signal',interface='org.chromium.TestService',path='/'",
 329       error.get()));
 330   ASSERT_FALSE(error.is_set());
 331
 332   // The rule should be still in the bus since it was removed only once.
 333   // A second removal shouldn't give an error.
 334   ASSERT_TRUE(bus->RemoveMatch(
 335       "type='signal',interface='org.chromium.TestService',path='/'",
 336       error.get()));
 337   ASSERT_FALSE(error.is_set());
 338
 339   // A third attemp to remove the same rule should fail.
 340   ASSERT_FALSE(bus->RemoveMatch(
 341       "type='signal',interface='org.chromium.TestService',path='/'",
 342       error.get()));
 343
 344   bus->ShutdownAndBlock();
 345 }
 346
 347 TEST(BusTest, ListenForServiceOwnerChange) {
 348   // Setup the current thread's MessageLoop. Must be of TYPE_IO for the
 349   // listeners to work.
 350   base::MessageLoop message_loop(base::MessageLoop::TYPE_IO);
 351   RunLoopWithExpectedCount run_loop_state;
 352
 353   // Create the bus.
 354   Bus::Options bus_options;
 355   scoped_refptr<Bus> bus = new Bus(bus_options);
 356
 357   // Add a listener.
 358   std::string service_owner1;
 359   int num_of_owner_changes1 = 0;
 360   Bus::GetServiceOwnerCallback callback1 =
 361       base::Bind(&OnServiceOwnerChanged,
 362                  &run_loop_state,
 363                  &service_owner1,
 364                  &num_of_owner_changes1);
 365   bus->ListenForServiceOwnerChange("org.chromium.TestService", callback1);
 366   // This should be a no-op.
 367   bus->ListenForServiceOwnerChange("org.chromium.TestService", callback1);
 368   base::RunLoop().RunUntilIdle();
 369
 370   // Nothing has happened yet. Check initial state.
 371   EXPECT_TRUE(service_owner1.empty());
 372   EXPECT_EQ(0, num_of_owner_changes1);
 373
 374   // Make an ownership change.
 375   ASSERT_TRUE(bus->RequestOwnershipAndBlock("org.chromium.TestService",
 376                                             Bus::REQUIRE_PRIMARY));
 377   run_loop_state.Run(1);
 378
 379   {
 380     // Get the current service owner and check to make sure the listener got
 381     // the right value.
 382     std::string current_service_owner =
 383         bus->GetServiceOwnerAndBlock("org.chromium.TestService",
 384                                      Bus::REPORT_ERRORS);
 385     ASSERT_FALSE(current_service_owner.empty());
 386
 387     // Make sure the listener heard about the new owner.
 388     EXPECT_EQ(current_service_owner, service_owner1);
 389
 390     // Test the second ListenForServiceOwnerChange() above is indeed a no-op.
 391     EXPECT_EQ(1, num_of_owner_changes1);
 392   }
 393
 394   // Add a second listener.
 395   std::string service_owner2;
 396   int num_of_owner_changes2 = 0;
 397   Bus::GetServiceOwnerCallback callback2 =
 398       base::Bind(&OnServiceOwnerChanged,
 399                  &run_loop_state,
 400                  &service_owner2,
 401                  &num_of_owner_changes2);
 402   bus->ListenForServiceOwnerChange("org.chromium.TestService", callback2);
 403   base::RunLoop().RunUntilIdle();
 404
 405   // Release the ownership and make sure the service owner listeners fire with
 406   // the right values and the right number of times.
 407   ASSERT_TRUE(bus->ReleaseOwnership("org.chromium.TestService"));
 408   run_loop_state.Run(2);
 409
 410   EXPECT_TRUE(service_owner1.empty());
 411   EXPECT_TRUE(service_owner2.empty());
 412   EXPECT_EQ(2, num_of_owner_changes1);
 413   EXPECT_EQ(1, num_of_owner_changes2);
 414
 415   // Unlisten so shutdown can proceed correctly.
 416   bus->UnlistenForServiceOwnerChange("org.chromium.TestService", callback1);
 417   bus->UnlistenForServiceOwnerChange("org.chromium.TestService", callback2);
 418   base::RunLoop().RunUntilIdle();
 419
 420   // Shut down synchronously.
 421   bus->ShutdownAndBlock();
 422   EXPECT_TRUE(bus->shutdown_completed());
 423 }
 424
 425 }  // namespace dbus