dbus/test_service.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/test_service.h"
   6
   7 #include "base/bind.h"
   8 #include "base/test/test_timeouts.h"
   9 #include "base/threading/platform_thread.h"
  10 #include "dbus/bus.h"
  11 #include "dbus/exported_object.h"
  12 #include "dbus/message.h"
  13 #include "dbus/object_manager.h"
  14 #include "dbus/object_path.h"
  15 #include "dbus/property.h"
  16
  17 namespace {
  18
  19 void EmptyCallback(bool /* success */) {
  20 }
  21
  22 }  // namespace
  23
  24 namespace dbus {
  25
  26 // Echo, SlowEcho, AsyncEcho, BrokenMethod, GetAll, Get, Set, PerformAction,
  27 // GetManagedObjects.
  28 const int TestService::kNumMethodsToExport = 9;
  29
  30 TestService::Options::Options() {
  31 }
  32
  33 TestService::Options::~Options() {
  34 }
  35
  36 TestService::TestService(const Options& options)
  37     : base::Thread("TestService"),
  38       dbus_task_runner_(options.dbus_task_runner),
  39       on_all_methods_exported_(false, false),
  40       num_exported_methods_(0) {
  41 }
  42
  43 TestService::~TestService() {
  44   Stop();
  45 }
  46
  47 bool TestService::StartService() {
  48   base::Thread::Options thread_options;
  49   thread_options.message_loop_type = MessageLoop::TYPE_IO;
  50   return StartWithOptions(thread_options);
  51 }
  52
  53 bool TestService::WaitUntilServiceIsStarted() {
  54   const base::TimeDelta timeout(TestTimeouts::action_max_timeout());
  55   // Wait until all methods are exported.
  56   return on_all_methods_exported_.TimedWait(timeout);
  57 }
  58
  59 void TestService::ShutdownAndBlock() {
  60   message_loop()->PostTask(
  61       FROM_HERE,
  62       base::Bind(&TestService::ShutdownAndBlockInternal,
  63                  base::Unretained(this)));
  64 }
  65
  66 bool TestService::HasDBusThread() {
  67   return bus_->HasDBusThread();
  68 }
  69
  70 void TestService::ShutdownAndBlockInternal() {
  71   if (HasDBusThread())
  72     bus_->ShutdownOnDBusThreadAndBlock();
  73   else
  74     bus_->ShutdownAndBlock();
  75 }
  76
  77 void TestService::SendTestSignal(const std::string& message) {
  78   message_loop()->PostTask(
  79       FROM_HERE,
  80       base::Bind(&TestService::SendTestSignalInternal,
  81                  base::Unretained(this),
  82                  message));
  83 }
  84
  85 void TestService::SendTestSignalFromRoot(const std::string& message) {
  86   message_loop()->PostTask(
  87       FROM_HERE,
  88       base::Bind(&TestService::SendTestSignalFromRootInternal,
  89                  base::Unretained(this),
  90                  message));
  91 }
  92
  93 void TestService::SendTestSignalInternal(const std::string& message) {
  94   dbus::Signal signal("org.chromium.TestInterface", "Test");
  95   dbus::MessageWriter writer(&signal);
  96   writer.AppendString(message);
  97   exported_object_->SendSignal(&signal);
  98 }
  99
 100 void TestService::SendTestSignalFromRootInternal(const std::string& message) {
 101   dbus::Signal signal("org.chromium.TestInterface", "Test");
 102   dbus::MessageWriter writer(&signal);
 103   writer.AppendString(message);
 104
 105   bus_->RequestOwnership("org.chromium.TestService",
 106                          base::Bind(&TestService::OnOwnership,
 107                                     base::Unretained(this),
 108                                     base::Bind(&EmptyCallback)));
 109
 110   // Use "/" just like dbus-send does.
 111   ExportedObject* root_object =
 112       bus_->GetExportedObject(dbus::ObjectPath("/"));
 113   root_object->SendSignal(&signal);
 114 }
 115
 116 void TestService::RequestOwnership(base::Callback<void(bool)> callback) {
 117   message_loop()->PostTask(
 118       FROM_HERE,
 119       base::Bind(&TestService::RequestOwnershipInternal,
 120                  base::Unretained(this),
 121                  callback));
 122 }
 123
 124 void TestService::RequestOwnershipInternal(
 125     base::Callback<void(bool)> callback) {
 126   bus_->RequestOwnership("org.chromium.TestService",
 127                          base::Bind(&TestService::OnOwnership,
 128                                     base::Unretained(this),
 129                                     callback));
 130 }
 131
 132 void TestService::OnOwnership(base::Callback<void(bool)> callback,
 133                               const std::string& service_name,
 134                               bool success) {
 135   has_ownership_ = success;
 136   LOG_IF(ERROR, !success) << "Failed to own: " << service_name;
 137   callback.Run(success);
 138 }
 139
 140 void TestService::OnExported(const std::string& interface_name,
 141                              const std::string& method_name,
 142                              bool success) {
 143   if (!success) {
 144     LOG(ERROR) << "Failed to export: " << interface_name << "."
 145                << method_name;
 146     // Returning here will make WaitUntilServiceIsStarted() to time out
 147     // and return false.
 148     return;
 149   }
 150
 151   ++num_exported_methods_;
 152   if (num_exported_methods_ == kNumMethodsToExport)
 153     on_all_methods_exported_.Signal();
 154 }
 155
 156 void TestService::Run(MessageLoop* message_loop) {
 157   Bus::Options bus_options;
 158   bus_options.bus_type = Bus::SESSION;
 159   bus_options.connection_type = Bus::PRIVATE;
 160   bus_options.dbus_task_runner = dbus_task_runner_;
 161   bus_ = new Bus(bus_options);
 162
 163   bus_->RequestOwnership("org.chromium.TestService",
 164                          base::Bind(&TestService::OnOwnership,
 165                                     base::Unretained(this),
 166                                     base::Bind(&EmptyCallback)));
 167
 168   exported_object_ = bus_->GetExportedObject(
 169       dbus::ObjectPath("/org/chromium/TestObject"));
 170
 171   int num_methods = 0;
 172   exported_object_->ExportMethod(
 173       "org.chromium.TestInterface",
 174       "Echo",
 175       base::Bind(&TestService::Echo,
 176                  base::Unretained(this)),
 177       base::Bind(&TestService::OnExported,
 178                  base::Unretained(this)));
 179   ++num_methods;
 180
 181   exported_object_->ExportMethod(
 182       "org.chromium.TestInterface",
 183       "SlowEcho",
 184       base::Bind(&TestService::SlowEcho,
 185                  base::Unretained(this)),
 186       base::Bind(&TestService::OnExported,
 187                  base::Unretained(this)));
 188   ++num_methods;
 189
 190   exported_object_->ExportMethod(
 191       "org.chromium.TestInterface",
 192       "AsyncEcho",
 193       base::Bind(&TestService::AsyncEcho,
 194                  base::Unretained(this)),
 195       base::Bind(&TestService::OnExported,
 196                  base::Unretained(this)));
 197   ++num_methods;
 198
 199   exported_object_->ExportMethod(
 200       "org.chromium.TestInterface",
 201       "BrokenMethod",
 202       base::Bind(&TestService::BrokenMethod,
 203                  base::Unretained(this)),
 204       base::Bind(&TestService::OnExported,
 205                  base::Unretained(this)));
 206   ++num_methods;
 207
 208   exported_object_->ExportMethod(
 209       "org.chromium.TestInterface",
 210       "PerformAction",
 211       base::Bind(&TestService::PerformAction,
 212                  base::Unretained(this)),
 213       base::Bind(&TestService::OnExported,
 214                  base::Unretained(this)));
 215   ++num_methods;
 216
 217   exported_object_->ExportMethod(
 218        kPropertiesInterface,
 219        kPropertiesGetAll,
 220        base::Bind(&TestService::GetAllProperties,
 221                   base::Unretained(this)),
 222        base::Bind(&TestService::OnExported,
 223                   base::Unretained(this)));
 224   ++num_methods;
 225
 226   exported_object_->ExportMethod(
 227        kPropertiesInterface,
 228        kPropertiesGet,
 229        base::Bind(&TestService::GetProperty,
 230                   base::Unretained(this)),
 231        base::Bind(&TestService::OnExported,
 232                   base::Unretained(this)));
 233   ++num_methods;
 234
 235   exported_object_->ExportMethod(
 236        kPropertiesInterface,
 237        kPropertiesSet,
 238        base::Bind(&TestService::SetProperty,
 239                   base::Unretained(this)),
 240        base::Bind(&TestService::OnExported,
 241                   base::Unretained(this)));
 242   ++num_methods;
 243
 244   exported_object_manager_ = bus_->GetExportedObject(
 245     dbus::ObjectPath("/org/chromium/TestService"));
 246
 247   exported_object_manager_->ExportMethod(
 248        kObjectManagerInterface,
 249        kObjectManagerGetManagedObjects,
 250        base::Bind(&TestService::GetManagedObjects,
 251                   base::Unretained(this)),
 252        base::Bind(&TestService::OnExported,
 253                   base::Unretained(this)));
 254   ++num_methods;
 255
 256   // Just print an error message as we don't want to crash tests.
 257   // Tests will fail at a call to WaitUntilServiceIsStarted().
 258   if (num_methods != kNumMethodsToExport) {
 259     LOG(ERROR) << "The number of methods does not match";
 260   }
 261   message_loop->Run();
 262 }
 263
 264 void TestService::Echo(MethodCall* method_call,
 265                        dbus::ExportedObject::ResponseSender response_sender) {
 266   MessageReader reader(method_call);
 267   std::string text_message;
 268   if (!reader.PopString(&text_message)) {
 269     response_sender.Run(scoped_ptr<dbus::Response>());
 270     return;
 271   }
 272
 273   scoped_ptr<Response> response = Response::FromMethodCall(method_call);
 274   MessageWriter writer(response.get());
 275   writer.AppendString(text_message);
 276   response_sender.Run(response.Pass());
 277 }
 278
 279 void TestService::SlowEcho(
 280     MethodCall* method_call,
 281     dbus::ExportedObject::ResponseSender response_sender) {
 282   base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());
 283   Echo(method_call, response_sender);
 284 }
 285
 286 void TestService::AsyncEcho(
 287     MethodCall* method_call,
 288     dbus::ExportedObject::ResponseSender response_sender) {
 289   // Schedule a call to Echo() to send an asynchronous response after we return.
 290   message_loop()->PostDelayedTask(FROM_HERE,
 291                                   base::Bind(&TestService::Echo,
 292                                              base::Unretained(this),
 293                                              method_call,
 294                                              response_sender),
 295                                   TestTimeouts::tiny_timeout());
 296 }
 297
 298 void TestService::BrokenMethod(
 299     MethodCall* method_call,
 300     dbus::ExportedObject::ResponseSender response_sender) {
 301   response_sender.Run(scoped_ptr<dbus::Response>());
 302 }
 303
 304
 305 void TestService::GetAllProperties(
 306     MethodCall* method_call,
 307     dbus::ExportedObject::ResponseSender response_sender) {
 308   MessageReader reader(method_call);
 309   std::string interface;
 310   if (!reader.PopString(&interface)) {
 311     response_sender.Run(scoped_ptr<dbus::Response>());
 312     return;
 313   }
 314
 315   scoped_ptr<Response> response = Response::FromMethodCall(method_call);
 316   MessageWriter writer(response.get());
 317
 318   AddPropertiesToWriter(&writer);
 319
 320   response_sender.Run(response.Pass());
 321 }
 322
 323 void TestService::GetProperty(
 324     MethodCall* method_call,
 325     dbus::ExportedObject::ResponseSender response_sender) {
 326   MessageReader reader(method_call);
 327   std::string interface;
 328   if (!reader.PopString(&interface)) {
 329     response_sender.Run(scoped_ptr<dbus::Response>());
 330     return;
 331   }
 332
 333   std::string name;
 334   if (!reader.PopString(&name)) {
 335     response_sender.Run(scoped_ptr<dbus::Response>());
 336     return;
 337   }
 338
 339   if (name == "Name") {
 340     // Return the previous value for the "Name" property:
 341     // Variant<"TestService">
 342     scoped_ptr<Response> response = Response::FromMethodCall(method_call);
 343     MessageWriter writer(response.get());
 344
 345     writer.AppendVariantOfString("TestService");
 346
 347     response_sender.Run(response.Pass());
 348   } else if (name == "Version") {
 349     // Return a new value for the "Version" property:
 350     // Variant<20>
 351     scoped_ptr<Response> response = Response::FromMethodCall(method_call);
 352     MessageWriter writer(response.get());
 353
 354     writer.AppendVariantOfInt16(20);
 355
 356     response_sender.Run(response.Pass());
 357   } else if (name == "Methods") {
 358     // Return the previous value for the "Methods" property:
 359     // Variant<["Echo", "SlowEcho", "AsyncEcho", "BrokenMethod"]>
 360     scoped_ptr<Response> response = Response::FromMethodCall(method_call);
 361     MessageWriter writer(response.get());
 362     MessageWriter variant_writer(NULL);
 363     MessageWriter variant_array_writer(NULL);
 364
 365     writer.OpenVariant("as", &variant_writer);
 366     variant_writer.OpenArray("s", &variant_array_writer);
 367     variant_array_writer.AppendString("Echo");
 368     variant_array_writer.AppendString("SlowEcho");
 369     variant_array_writer.AppendString("AsyncEcho");
 370     variant_array_writer.AppendString("BrokenMethod");
 371     variant_writer.CloseContainer(&variant_array_writer);
 372     writer.CloseContainer(&variant_writer);
 373
 374     response_sender.Run(response.Pass());
 375   } else if (name == "Objects") {
 376     // Return the previous value for the "Objects" property:
 377     // Variant<[objectpath:"/TestObjectPath"]>
 378     scoped_ptr<Response> response = Response::FromMethodCall(method_call);
 379     MessageWriter writer(response.get());
 380     MessageWriter variant_writer(NULL);
 381     MessageWriter variant_array_writer(NULL);
 382
 383     writer.OpenVariant("ao", &variant_writer);
 384     variant_writer.OpenArray("o", &variant_array_writer);
 385     variant_array_writer.AppendObjectPath(dbus::ObjectPath("/TestObjectPath"));
 386     variant_writer.CloseContainer(&variant_array_writer);
 387     writer.CloseContainer(&variant_writer);
 388
 389     response_sender.Run(response.Pass());
 390   } else {
 391     // Return error.
 392     response_sender.Run(scoped_ptr<dbus::Response>());
 393     return;
 394   }
 395 }
 396
 397 void TestService::SetProperty(
 398     MethodCall* method_call,
 399     dbus::ExportedObject::ResponseSender response_sender) {
 400   MessageReader reader(method_call);
 401   std::string interface;
 402   if (!reader.PopString(&interface)) {
 403     response_sender.Run(scoped_ptr<dbus::Response>());
 404     return;
 405   }
 406
 407   std::string name;
 408   if (!reader.PopString(&name)) {
 409     response_sender.Run(scoped_ptr<dbus::Response>());
 410     return;
 411   }
 412
 413   if (name != "Name") {
 414     response_sender.Run(scoped_ptr<dbus::Response>());
 415     return;
 416   }
 417
 418   std::string value;
 419   if (!reader.PopVariantOfString(&value)) {
 420     response_sender.Run(scoped_ptr<dbus::Response>());
 421     return;
 422   }
 423
 424   SendPropertyChangedSignal(value);
 425
 426   response_sender.Run(Response::FromMethodCall(method_call));
 427 }
 428
 429 void TestService::PerformAction(
 430       MethodCall* method_call,
 431       dbus::ExportedObject::ResponseSender response_sender) {
 432   MessageReader reader(method_call);
 433   std::string action;
 434   dbus::ObjectPath object_path;
 435   if (!reader.PopString(&action) || !reader.PopObjectPath(&object_path)) {
 436     response_sender.Run(scoped_ptr<dbus::Response>());
 437     return;
 438   }
 439
 440   if (action == "AddObject")
 441     AddObject(object_path);
 442   else if (action == "RemoveObject")
 443     RemoveObject(object_path);
 444
 445   scoped_ptr<Response> response = Response::FromMethodCall(method_call);
 446   response_sender.Run(response.Pass());
 447 }
 448
 449 void TestService::GetManagedObjects(
 450     MethodCall* method_call,
 451     dbus::ExportedObject::ResponseSender response_sender) {
 452   scoped_ptr<Response> response = Response::FromMethodCall(method_call);
 453   MessageWriter writer(response.get());
 454
 455   // The managed objects response is a dictionary of object paths identifying
 456   // the object(s) with a dictionary of strings identifying the interface(s)
 457   // they implement and then a dictionary of property values.
 458   //
 459   // Thus this looks something like:
 460   //
 461   // {
 462   //   "/org/chromium/TestObject": {
 463   //     "org.chromium.TestInterface": { /* Properties */ }
 464   //   }
 465   // }
 466
 467
 468   MessageWriter array_writer(NULL);
 469   MessageWriter dict_entry_writer(NULL);
 470   MessageWriter object_array_writer(NULL);
 471   MessageWriter object_dict_entry_writer(NULL);
 472
 473   writer.OpenArray("{oa{sa{sv}}}", &array_writer);
 474
 475   array_writer.OpenDictEntry(&dict_entry_writer);
 476   dict_entry_writer.AppendObjectPath(
 477       dbus::ObjectPath("/org/chromium/TestObject"));
 478   dict_entry_writer.OpenArray("{sa{sv}}", &object_array_writer);
 479
 480   object_array_writer.OpenDictEntry(&object_dict_entry_writer);
 481   object_dict_entry_writer.AppendString("org.chromium.TestInterface");
 482   AddPropertiesToWriter(&object_dict_entry_writer);
 483   object_array_writer.CloseContainer(&object_dict_entry_writer);
 484
 485   dict_entry_writer.CloseContainer(&object_array_writer);
 486
 487   array_writer.CloseContainer(&dict_entry_writer);
 488   writer.CloseContainer(&array_writer);
 489
 490   response_sender.Run(response.Pass());
 491 }
 492
 493 void TestService::AddPropertiesToWriter(MessageWriter* writer)
 494 {
 495   // The properties response is a dictionary of strings identifying the
 496   // property and a variant containing the property value. We return all
 497   // of the properties, thus the response is:
 498   //
 499   // {
 500   //   "Name": Variant<"TestService">,
 501   //   "Version": Variant<10>,
 502   //   "Methods": Variant<["Echo", "SlowEcho", "AsyncEcho", "BrokenMethod"]>,
 503   //   "Objects": Variant<[objectpath:"/TestObjectPath"]>
 504   // ]
 505
 506   MessageWriter array_writer(NULL);
 507   MessageWriter dict_entry_writer(NULL);
 508   MessageWriter variant_writer(NULL);
 509   MessageWriter variant_array_writer(NULL);
 510
 511   writer->OpenArray("{sv}", &array_writer);
 512
 513   array_writer.OpenDictEntry(&dict_entry_writer);
 514   dict_entry_writer.AppendString("Name");
 515   dict_entry_writer.AppendVariantOfString("TestService");
 516   array_writer.CloseContainer(&dict_entry_writer);
 517
 518   array_writer.OpenDictEntry(&dict_entry_writer);
 519   dict_entry_writer.AppendString("Version");
 520   dict_entry_writer.AppendVariantOfInt16(10);
 521   array_writer.CloseContainer(&dict_entry_writer);
 522
 523   array_writer.OpenDictEntry(&dict_entry_writer);
 524   dict_entry_writer.AppendString("Methods");
 525   dict_entry_writer.OpenVariant("as", &variant_writer);
 526   variant_writer.OpenArray("s", &variant_array_writer);
 527   variant_array_writer.AppendString("Echo");
 528   variant_array_writer.AppendString("SlowEcho");
 529   variant_array_writer.AppendString("AsyncEcho");
 530   variant_array_writer.AppendString("BrokenMethod");
 531   variant_writer.CloseContainer(&variant_array_writer);
 532   dict_entry_writer.CloseContainer(&variant_writer);
 533   array_writer.CloseContainer(&dict_entry_writer);
 534
 535   array_writer.OpenDictEntry(&dict_entry_writer);
 536   dict_entry_writer.AppendString("Objects");
 537   dict_entry_writer.OpenVariant("ao", &variant_writer);
 538   variant_writer.OpenArray("o", &variant_array_writer);
 539   variant_array_writer.AppendObjectPath(dbus::ObjectPath("/TestObjectPath"));
 540   variant_writer.CloseContainer(&variant_array_writer);
 541   dict_entry_writer.CloseContainer(&variant_writer);
 542   array_writer.CloseContainer(&dict_entry_writer);
 543
 544   writer->CloseContainer(&array_writer);
 545 }
 546
 547 void TestService::AddObject(const dbus::ObjectPath& object_path) {
 548   message_loop()->PostTask(
 549       FROM_HERE,
 550       base::Bind(&TestService::AddObjectInternal,
 551                  base::Unretained(this),
 552                  object_path));
 553 }
 554
 555 void TestService::AddObjectInternal(const dbus::ObjectPath& object_path) {
 556   dbus::Signal signal(kObjectManagerInterface, kObjectManagerInterfacesAdded);
 557   dbus::MessageWriter writer(&signal);
 558   writer.AppendObjectPath(object_path);
 559
 560   MessageWriter array_writer(NULL);
 561   MessageWriter dict_entry_writer(NULL);
 562
 563   writer.OpenArray("{sa{sv}}", &array_writer);
 564   array_writer.OpenDictEntry(&dict_entry_writer);
 565   dict_entry_writer.AppendString("org.chromium.TestInterface");
 566   AddPropertiesToWriter(&dict_entry_writer);
 567   array_writer.CloseContainer(&dict_entry_writer);
 568   writer.CloseContainer(&array_writer);
 569
 570   exported_object_manager_->SendSignal(&signal);
 571 }
 572
 573 void TestService::RemoveObject(const dbus::ObjectPath& object_path) {
 574     message_loop()->PostTask(
 575       FROM_HERE,
 576       base::Bind(&TestService::RemoveObjectInternal,
 577                  base::Unretained(this),
 578                  object_path));
 579 }
 580
 581 void TestService::RemoveObjectInternal(const dbus::ObjectPath& object_path) {
 582   dbus::Signal signal(kObjectManagerInterface, kObjectManagerInterfacesRemoved);
 583   dbus::MessageWriter writer(&signal);
 584
 585   writer.AppendObjectPath(object_path);
 586
 587   std::vector<std::string> interfaces;
 588   interfaces.push_back("org.chromium.TestInterface");
 589   writer.AppendArrayOfStrings(interfaces);
 590
 591   exported_object_manager_->SendSignal(&signal);
 592 }
 593
 594 void TestService::SendPropertyChangedSignal(const std::string& name) {
 595   message_loop()->PostTask(
 596       FROM_HERE,
 597       base::Bind(&TestService::SendPropertyChangedSignalInternal,
 598                  base::Unretained(this),
 599                  name));
 600 }
 601
 602 void TestService::SendPropertyChangedSignalInternal(const std::string& name) {
 603   dbus::Signal signal(kPropertiesInterface, kPropertiesChanged);
 604   dbus::MessageWriter writer(&signal);
 605   writer.AppendString("org.chromium.TestInterface");
 606
 607   MessageWriter array_writer(NULL);
 608   MessageWriter dict_entry_writer(NULL);
 609
 610   writer.OpenArray("{sv}", &array_writer);
 611   array_writer.OpenDictEntry(&dict_entry_writer);
 612   dict_entry_writer.AppendString("Name");
 613   dict_entry_writer.AppendVariantOfString(name);
 614   array_writer.CloseContainer(&dict_entry_writer);
 615   writer.CloseContainer(&array_writer);
 616
 617   exported_object_->SendSignal(&signal);
 618 }
 619
 620 }  // namespace dbus