dbus/bus.cc

   1 // Copyright (c) 2011 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 // TODO(satorux):
   6 // - Handle "disconnected" signal.
   7
   8 #include "dbus/bus.h"
   9
  10 #include "base/bind.h"
  11 #include "base/logging.h"
  12 #include "base/message_loop.h"
  13 #include "base/message_loop_proxy.h"
  14 #include "base/stl_util.h"
  15 #include "base/threading/thread.h"
  16 #include "base/threading/thread_restrictions.h"
  17 #include "base/time.h"
  18 #include "dbus/exported_object.h"
  19 #include "dbus/object_proxy.h"
  20 #include "dbus/scoped_dbus_error.h"
  21
  22 namespace dbus {
  23
  24 namespace {
  25
  26 // The class is used for watching the file descriptor used for D-Bus
  27 // communication.
  28 class Watch : public base::MessagePumpLibevent::Watcher {
  29  public:
  30   Watch(DBusWatch* watch)
  31       : raw_watch_(watch) {
  32     dbus_watch_set_data(raw_watch_, this, NULL);
  33   }
  34
  35   ~Watch() {
  36     dbus_watch_set_data(raw_watch_, NULL, NULL);
  37   }
  38
  39   // Returns true if the underlying file descriptor is ready to be watched.
  40   bool IsReadyToBeWatched() {
  41     return dbus_watch_get_enabled(raw_watch_);
  42   }
  43
  44   // Starts watching the underlying file descriptor.
  45   void StartWatching() {
  46     const int file_descriptor = dbus_watch_get_unix_fd(raw_watch_);
  47     const int flags = dbus_watch_get_flags(raw_watch_);
  48
  49     MessageLoopForIO::Mode mode = MessageLoopForIO::WATCH_READ;
  50     if ((flags & DBUS_WATCH_READABLE) && (flags & DBUS_WATCH_WRITABLE))
  51       mode = MessageLoopForIO::WATCH_READ_WRITE;
  52     else if (flags & DBUS_WATCH_READABLE)
  53       mode = MessageLoopForIO::WATCH_READ;
  54     else if (flags & DBUS_WATCH_WRITABLE)
  55       mode = MessageLoopForIO::WATCH_WRITE;
  56     else
  57       NOTREACHED();
  58
  59     const bool persistent = true;  // Watch persistently.
  60     const bool success = MessageLoopForIO::current()->WatchFileDescriptor(
  61         file_descriptor,
  62         persistent,
  63         mode,
  64         &file_descriptor_watcher_,
  65         this);
  66     CHECK(success) << "Unable to allocate memory";
  67   }
  68
  69   // Stops watching the underlying file descriptor.
  70   void StopWatching() {
  71     file_descriptor_watcher_.StopWatchingFileDescriptor();
  72   }
  73
  74  private:
  75   // Implement MessagePumpLibevent::Watcher.
  76   virtual void OnFileCanReadWithoutBlocking(int file_descriptor) {
  77     const bool success = dbus_watch_handle(raw_watch_, DBUS_WATCH_READABLE);
  78     CHECK(success) << "Unable to allocate memory";
  79   }
  80
  81   // Implement MessagePumpLibevent::Watcher.
  82   virtual void OnFileCanWriteWithoutBlocking(int file_descriptor) {
  83     const bool success = dbus_watch_handle(raw_watch_, DBUS_WATCH_WRITABLE);
  84     CHECK(success) << "Unable to allocate memory";
  85   }
  86
  87   DBusWatch* raw_watch_;
  88   base::MessagePumpLibevent::FileDescriptorWatcher file_descriptor_watcher_;
  89 };
  90
  91 // The class is used for monitoring the timeout used for D-Bus method
  92 // calls.
  93 //
  94 // Unlike Watch, Timeout is a ref counted object, to ensure that |this| of
  95 // the object is is alive when HandleTimeout() is called. It's unlikely
  96 // but it may be possible that HandleTimeout() is called after
  97 // Bus::OnRemoveTimeout(). That's why we don't simply delete the object in
  98 // Bus::OnRemoveTimeout().
  99 class Timeout : public base::RefCountedThreadSafe<Timeout> {
 100  public:
 101   Timeout(DBusTimeout* timeout)
 102       : raw_timeout_(timeout),
 103         monitoring_is_active_(false),
 104         is_completed(false) {
 105     dbus_timeout_set_data(raw_timeout_, this, NULL);
 106     AddRef();  // Balanced on Complete().
 107   }
 108
 109   // Returns true if the timeout is ready to be monitored.
 110   bool IsReadyToBeMonitored() {
 111     return dbus_timeout_get_enabled(raw_timeout_);
 112   }
 113
 114   // Starts monitoring the timeout.
 115   void StartMonitoring(dbus::Bus* bus) {
 116     bus->PostDelayedTaskToDBusThread(FROM_HERE,
 117                                      base::Bind(&Timeout::HandleTimeout,
 118                                                 this),
 119                                      GetIntervalInMs());
 120     monitoring_is_active_ = true;
 121   }
 122
 123   // Stops monitoring the timeout.
 124   void StopMonitoring() {
 125     // We cannot take back the delayed task we posted in
 126     // StartMonitoring(), so we just mark the monitoring is inactive now.
 127     monitoring_is_active_ = false;
 128   }
 129
 130   // Returns the interval in milliseconds.
 131   int GetIntervalInMs() {
 132     return dbus_timeout_get_interval(raw_timeout_);
 133   }
 134
 135   // Cleans up the raw_timeout and marks that timeout is completed.
 136   // See the class comment above for why we are doing this.
 137   void Complete() {
 138     dbus_timeout_set_data(raw_timeout_, NULL, NULL);
 139     is_completed = true;
 140     Release();
 141   }
 142
 143  private:
 144   friend class base::RefCountedThreadSafe<Timeout>;
 145   ~Timeout() {
 146   }
 147
 148   // Handles the timeout.
 149   void HandleTimeout() {
 150     // If the timeout is marked completed, we should do nothing. This can
 151     // occur if this function is called after Bus::OnRemoveTimeout().
 152     if (is_completed)
 153       return;
 154     // Skip if monitoring is canceled.
 155     if (!monitoring_is_active_)
 156       return;
 157
 158     const bool success = dbus_timeout_handle(raw_timeout_);
 159     CHECK(success) << "Unable to allocate memory";
 160   }
 161
 162   DBusTimeout* raw_timeout_;
 163   bool monitoring_is_active_;
 164   bool is_completed;
 165 };
 166
 167 }  // namespace
 168
 169 Bus::Options::Options()
 170   : bus_type(SESSION),
 171     connection_type(PRIVATE) {
 172 }
 173
 174 Bus::Options::~Options() {
 175 }
 176
 177 Bus::Bus(const Options& options)
 178     : bus_type_(options.bus_type),
 179       connection_type_(options.connection_type),
 180       dbus_thread_message_loop_proxy_(options.dbus_thread_message_loop_proxy),
 181       on_shutdown_(false /* manual_reset */, false /* initially_signaled */),
 182       connection_(NULL),
 183       origin_thread_id_(base::PlatformThread::CurrentId()),
 184       async_operations_set_up_(false),
 185       shutdown_completed_(false),
 186       num_pending_watches_(0),
 187       num_pending_timeouts_(0) {
 188   // This is safe to call multiple times.
 189   dbus_threads_init_default();
 190   // The origin message loop is unnecessary if the client uses synchronous
 191   // functions only.
 192   if (MessageLoop::current())
 193     origin_message_loop_proxy_ =  MessageLoop::current()->message_loop_proxy();
 194 }
 195
 196 Bus::~Bus() {
 197   DCHECK(!connection_);
 198   DCHECK(owned_service_names_.empty());
 199   DCHECK(match_rules_added_.empty());
 200   DCHECK(filter_functions_added_.empty());
 201   DCHECK(registered_object_paths_.empty());
 202   DCHECK_EQ(0, num_pending_watches_);
 203   DCHECK_EQ(0, num_pending_timeouts_);
 204 }
 205
 206 ObjectProxy* Bus::GetObjectProxy(const std::string& service_name,
 207                                  const std::string& object_path) {
 208   AssertOnOriginThread();
 209
 210   // Check if we already have the requested object proxy.
 211   const std::string key = service_name + object_path;
 212   ObjectProxyTable::iterator iter = object_proxy_table_.find(key);
 213   if (iter != object_proxy_table_.end()) {
 214     return iter->second;
 215   }
 216
 217   scoped_refptr<ObjectProxy> object_proxy =
 218       new ObjectProxy(this, service_name, object_path);
 219   object_proxy_table_[key] = object_proxy;
 220
 221   return object_proxy.get();
 222 }
 223
 224 ExportedObject* Bus::GetExportedObject(const std::string& service_name,
 225                                        const std::string& object_path) {
 226   AssertOnOriginThread();
 227
 228   // Check if we already have the requested exported object.
 229   const std::string key = service_name + object_path;
 230   ExportedObjectTable::iterator iter = exported_object_table_.find(key);
 231   if (iter != exported_object_table_.end()) {
 232     return iter->second;
 233   }
 234
 235   scoped_refptr<ExportedObject> exported_object =
 236       new ExportedObject(this, service_name, object_path);
 237   exported_object_table_[key] = exported_object;
 238
 239   return exported_object.get();
 240 }
 241
 242 bool Bus::Connect() {
 243   // dbus_bus_get_private() and dbus_bus_get() are blocking calls.
 244   AssertOnDBusThread();
 245
 246   // Check if it's already initialized.
 247   if (connection_)
 248     return true;
 249
 250   ScopedDBusError error;
 251   const DBusBusType dbus_bus_type = static_cast<DBusBusType>(bus_type_);
 252   if (connection_type_ == PRIVATE) {
 253     connection_ = dbus_bus_get_private(dbus_bus_type, error.get());
 254   } else {
 255     connection_ = dbus_bus_get(dbus_bus_type, error.get());
 256   }
 257   if (!connection_) {
 258     LOG(ERROR) << "Failed to connect to the bus: "
 259                << (dbus_error_is_set(error.get()) ? error.message() : "");
 260     return false;
 261   }
 262   // We shouldn't exit on the disconnected signal.
 263   dbus_connection_set_exit_on_disconnect(connection_, false);
 264
 265   return true;
 266 }
 267
 268 void Bus::ShutdownAndBlock() {
 269   AssertOnDBusThread();
 270
 271   // Unregister the exported objects.
 272   for (ExportedObjectTable::iterator iter = exported_object_table_.begin();
 273        iter != exported_object_table_.end(); ++iter) {
 274     iter->second->Unregister();
 275   }
 276
 277   // Release all service names.
 278   for (std::set<std::string>::iterator iter = owned_service_names_.begin();
 279        iter != owned_service_names_.end();) {
 280     // This is a bit tricky but we should increment the iter here as
 281     // ReleaseOwnership() may remove |service_name| from the set.
 282     const std::string& service_name = *iter++;
 283     ReleaseOwnership(service_name);
 284   }
 285   if (!owned_service_names_.empty()) {
 286     LOG(ERROR) << "Failed to release all service names. # of services left: "
 287                << owned_service_names_.size();
 288   }
 289
 290   // Detach from the remote objects.
 291   for (ObjectProxyTable::iterator iter = object_proxy_table_.begin();
 292        iter != object_proxy_table_.end(); ++iter) {
 293     iter->second->Detach();
 294   }
 295
 296   // Private connection should be closed.
 297   if (connection_) {
 298     if (connection_type_ == PRIVATE)
 299       dbus_connection_close(connection_);
 300     // dbus_connection_close() won't unref.
 301     dbus_connection_unref(connection_);
 302   }
 303
 304   connection_ = NULL;
 305   shutdown_completed_ = true;
 306 }
 307
 308 void Bus::ShutdownOnDBusThreadAndBlock() {
 309   AssertOnOriginThread();
 310   DCHECK(dbus_thread_message_loop_proxy_.get());
 311
 312   PostTaskToDBusThread(FROM_HERE, base::Bind(
 313       &Bus::ShutdownOnDBusThreadAndBlockInternal,
 314       this));
 315
 316   // Wait until the shutdown is complete on the D-Bus thread.
 317   // The shutdown should not hang, but set timeout just in case.
 318   const int kTimeoutSecs = 3;
 319   const base::TimeDelta timeout(base::TimeDelta::FromSeconds(kTimeoutSecs));
 320   const bool signaled = on_shutdown_.TimedWait(timeout);
 321   LOG_IF(ERROR, !signaled) << "Failed to shutdown the bus";
 322 }
 323
 324 bool Bus::RequestOwnership(const std::string& service_name) {
 325   DCHECK(connection_);
 326   // dbus_bus_request_name() is a blocking call.
 327   AssertOnDBusThread();
 328
 329   // Check if we already own the service name.
 330   if (owned_service_names_.find(service_name) != owned_service_names_.end()) {
 331     return true;
 332   }
 333
 334   ScopedDBusError error;
 335   const int result = dbus_bus_request_name(connection_,
 336                                            service_name.c_str(),
 337                                            DBUS_NAME_FLAG_DO_NOT_QUEUE,
 338                                            error.get());
 339   if (result != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
 340     LOG(ERROR) << "Failed to get the ownership of " << service_name << ": "
 341                << (dbus_error_is_set(error.get()) ? error.message() : "");
 342     return false;
 343   }
 344   owned_service_names_.insert(service_name);
 345   return true;
 346 }
 347
 348 bool Bus::ReleaseOwnership(const std::string& service_name) {
 349   DCHECK(connection_);
 350   // dbus_bus_request_name() is a blocking call.
 351   AssertOnDBusThread();
 352
 353   // Check if we already own the service name.
 354   std::set<std::string>::iterator found =
 355       owned_service_names_.find(service_name);
 356   if (found == owned_service_names_.end()) {
 357     LOG(ERROR) << service_name << " is not owned by the bus";
 358     return false;
 359   }
 360
 361   ScopedDBusError error;
 362   const int result = dbus_bus_release_name(connection_, service_name.c_str(),
 363                                            error.get());
 364   if (result == DBUS_RELEASE_NAME_REPLY_RELEASED) {
 365     owned_service_names_.erase(found);
 366     return true;
 367   } else {
 368     LOG(ERROR) << "Failed to release the ownership of " << service_name << ": "
 369                << (error.is_set() ? error.message() : "");
 370     return false;
 371   }
 372 }
 373
 374 bool Bus::SetUpAsyncOperations() {
 375   DCHECK(connection_);
 376   AssertOnDBusThread();
 377
 378   if (async_operations_set_up_)
 379     return true;
 380
 381   // Process all the incoming data if any, so that OnDispatchStatus() will
 382   // be called when the incoming data is ready.
 383   ProcessAllIncomingDataIfAny();
 384
 385   bool success = dbus_connection_set_watch_functions(connection_,
 386                                                      &Bus::OnAddWatchThunk,
 387                                                      &Bus::OnRemoveWatchThunk,
 388                                                      &Bus::OnToggleWatchThunk,
 389                                                      this,
 390                                                      NULL);
 391   CHECK(success) << "Unable to allocate memory";
 392
 393   // TODO(satorux): Timeout is not yet implemented.
 394   success = dbus_connection_set_timeout_functions(connection_,
 395                                                   &Bus::OnAddTimeoutThunk,
 396                                                   &Bus::OnRemoveTimeoutThunk,
 397                                                   &Bus::OnToggleTimeoutThunk,
 398                                                   this,
 399                                                   NULL);
 400   CHECK(success) << "Unable to allocate memory";
 401
 402   dbus_connection_set_dispatch_status_function(
 403       connection_,
 404       &Bus::OnDispatchStatusChangedThunk,
 405       this,
 406       NULL);
 407
 408   async_operations_set_up_ = true;
 409
 410   return true;
 411 }
 412
 413 DBusMessage* Bus::SendWithReplyAndBlock(DBusMessage* request,
 414                                         int timeout_ms,
 415                                         DBusError* error) {
 416   DCHECK(connection_);
 417   AssertOnDBusThread();
 418
 419   return dbus_connection_send_with_reply_and_block(
 420       connection_, request, timeout_ms, error);
 421 }
 422
 423 void Bus::SendWithReply(DBusMessage* request,
 424                         DBusPendingCall** pending_call,
 425                         int timeout_ms) {
 426   DCHECK(connection_);
 427   AssertOnDBusThread();
 428
 429   const bool success = dbus_connection_send_with_reply(
 430       connection_, request, pending_call, timeout_ms);
 431   CHECK(success) << "Unable to allocate memory";
 432 }
 433
 434 void Bus::Send(DBusMessage* request, uint32* serial) {
 435   DCHECK(connection_);
 436   AssertOnDBusThread();
 437
 438   const bool success = dbus_connection_send(connection_, request, serial);
 439   CHECK(success) << "Unable to allocate memory";
 440 }
 441
 442 void Bus::AddFilterFunction(DBusHandleMessageFunction filter_function,
 443                             void* user_data) {
 444   DCHECK(connection_);
 445   AssertOnDBusThread();
 446
 447   if (filter_functions_added_.find(filter_function) !=
 448       filter_functions_added_.end()) {
 449     LOG(ERROR) << "Filter function already exists: " << filter_function;
 450     return;
 451   }
 452
 453   const bool success = dbus_connection_add_filter(
 454       connection_, filter_function, user_data, NULL);
 455   CHECK(success) << "Unable to allocate memory";
 456   filter_functions_added_.insert(filter_function);
 457 }
 458
 459 void Bus::RemoveFilterFunction(DBusHandleMessageFunction filter_function,
 460                                void* user_data) {
 461   DCHECK(connection_);
 462   AssertOnDBusThread();
 463
 464   if (filter_functions_added_.find(filter_function) ==
 465       filter_functions_added_.end()) {
 466     LOG(ERROR) << "Requested to remove an unknown filter function: "
 467                << filter_function;
 468     return;
 469   }
 470
 471   dbus_connection_remove_filter(connection_, filter_function, user_data);
 472   filter_functions_added_.erase(filter_function);
 473 }
 474
 475 void Bus::AddMatch(const std::string& match_rule, DBusError* error) {
 476   DCHECK(connection_);
 477   AssertOnDBusThread();
 478
 479   if (match_rules_added_.find(match_rule) != match_rules_added_.end()) {
 480     LOG(ERROR) << "Match rule already exists: " << match_rule;
 481     return;
 482   }
 483
 484   dbus_bus_add_match(connection_, match_rule.c_str(), error);
 485   match_rules_added_.insert(match_rule);
 486 }
 487
 488 void Bus::RemoveMatch(const std::string& match_rule, DBusError* error) {
 489   DCHECK(connection_);
 490   AssertOnDBusThread();
 491
 492   if (match_rules_added_.find(match_rule) == match_rules_added_.end()) {
 493     LOG(ERROR) << "Requested to remove an unknown match rule: " << match_rule;
 494     return;
 495   }
 496
 497   dbus_bus_remove_match(connection_, match_rule.c_str(), error);
 498   match_rules_added_.erase(match_rule);
 499 }
 500
 501 bool Bus::TryRegisterObjectPath(const std::string& object_path,
 502                                 const DBusObjectPathVTable* vtable,
 503                                 void* user_data,
 504                                 DBusError* error) {
 505   DCHECK(connection_);
 506   AssertOnDBusThread();
 507
 508   if (registered_object_paths_.find(object_path) !=
 509       registered_object_paths_.end()) {
 510     LOG(ERROR) << "Object path already registered: " << object_path;
 511     return false;
 512   }
 513
 514   const bool success = dbus_connection_try_register_object_path(
 515       connection_,
 516       object_path.c_str(),
 517       vtable,
 518       user_data,
 519       error);
 520   if (success)
 521     registered_object_paths_.insert(object_path);
 522   return success;
 523 }
 524
 525 void Bus::UnregisterObjectPath(const std::string& object_path) {
 526   DCHECK(connection_);
 527   AssertOnDBusThread();
 528
 529   if (registered_object_paths_.find(object_path) ==
 530       registered_object_paths_.end()) {
 531     LOG(ERROR) << "Requested to unregister an unknown object path: "
 532                << object_path;
 533     return;
 534   }
 535
 536   const bool success = dbus_connection_unregister_object_path(
 537       connection_,
 538       object_path.c_str());
 539   CHECK(success) << "Unable to allocate memory";
 540   registered_object_paths_.erase(object_path);
 541 }
 542
 543 void Bus::ShutdownOnDBusThreadAndBlockInternal() {
 544   AssertOnDBusThread();
 545
 546   ShutdownAndBlock();
 547   on_shutdown_.Signal();
 548 }
 549
 550 void Bus::ProcessAllIncomingDataIfAny() {
 551   AssertOnDBusThread();
 552
 553   // As mentioned at the class comment in .h file, connection_ can be NULL.
 554   if (!connection_ || !dbus_connection_get_is_connected(connection_))
 555     return;
 556
 557   if (dbus_connection_get_dispatch_status(connection_) ==
 558       DBUS_DISPATCH_DATA_REMAINS) {
 559     while (dbus_connection_dispatch(connection_) ==
 560            DBUS_DISPATCH_DATA_REMAINS);
 561   }
 562 }
 563
 564 void Bus::PostTaskToOriginThread(const tracked_objects::Location& from_here,
 565                                  const base::Closure& task) {
 566   DCHECK(origin_message_loop_proxy_.get());
 567   if (!origin_message_loop_proxy_->PostTask(from_here, task)) {
 568     LOG(WARNING) << "Failed to post a task to the origin message loop";
 569   }
 570 }
 571
 572 void Bus::PostTaskToDBusThread(const tracked_objects::Location& from_here,
 573                                const base::Closure& task) {
 574   if (dbus_thread_message_loop_proxy_.get()) {
 575     if (!dbus_thread_message_loop_proxy_->PostTask(from_here, task)) {
 576       LOG(WARNING) << "Failed to post a task to the D-Bus thread message loop";
 577     }
 578   } else {
 579     DCHECK(origin_message_loop_proxy_.get());
 580     if (!origin_message_loop_proxy_->PostTask(from_here, task)) {
 581       LOG(WARNING) << "Failed to post a task to the origin message loop";
 582     }
 583   }
 584 }
 585
 586 void Bus::PostDelayedTaskToDBusThread(
 587     const tracked_objects::Location& from_here,
 588     const base::Closure& task,
 589     int delay_ms) {
 590   if (dbus_thread_message_loop_proxy_.get()) {
 591     if (!dbus_thread_message_loop_proxy_->PostDelayedTask(
 592             from_here, task, delay_ms)) {
 593       LOG(WARNING) << "Failed to post a task to the D-Bus thread message loop";
 594     }
 595   } else {
 596     DCHECK(origin_message_loop_proxy_.get());
 597     if (!origin_message_loop_proxy_->PostDelayedTask(
 598             from_here, task, delay_ms)) {
 599       LOG(WARNING) << "Failed to post a task to the origin message loop";
 600     }
 601   }
 602 }
 603
 604 bool Bus::HasDBusThread() {
 605   return dbus_thread_message_loop_proxy_.get() != NULL;
 606 }
 607
 608 void Bus::AssertOnOriginThread() {
 609   DCHECK_EQ(origin_thread_id_, base::PlatformThread::CurrentId());
 610 }
 611
 612 void Bus::AssertOnDBusThread() {
 613   base::ThreadRestrictions::AssertIOAllowed();
 614
 615   if (dbus_thread_message_loop_proxy_.get()) {
 616     DCHECK(dbus_thread_message_loop_proxy_->BelongsToCurrentThread());
 617   } else {
 618     AssertOnOriginThread();
 619   }
 620 }
 621
 622 dbus_bool_t Bus::OnAddWatch(DBusWatch* raw_watch) {
 623   AssertOnDBusThread();
 624
 625   // watch will be deleted when raw_watch is removed in OnRemoveWatch().
 626   Watch* watch = new Watch(raw_watch);
 627   if (watch->IsReadyToBeWatched()) {
 628     watch->StartWatching();
 629   }
 630   ++num_pending_watches_;
 631   return true;
 632 }
 633
 634 void Bus::OnRemoveWatch(DBusWatch* raw_watch) {
 635   AssertOnDBusThread();
 636
 637   Watch* watch = static_cast<Watch*>(dbus_watch_get_data(raw_watch));
 638   delete watch;
 639   --num_pending_watches_;
 640 }
 641
 642 void Bus::OnToggleWatch(DBusWatch* raw_watch) {
 643   AssertOnDBusThread();
 644
 645   Watch* watch = static_cast<Watch*>(dbus_watch_get_data(raw_watch));
 646   if (watch->IsReadyToBeWatched()) {
 647     watch->StartWatching();
 648   } else {
 649     // It's safe to call this if StartWatching() wasn't called, per
 650     // message_pump_libevent.h.
 651     watch->StopWatching();
 652   }
 653 }
 654
 655 dbus_bool_t Bus::OnAddTimeout(DBusTimeout* raw_timeout) {
 656   AssertOnDBusThread();
 657
 658   // timeout will be deleted when raw_timeout is removed in
 659   // OnRemoveTimeoutThunk().
 660   Timeout* timeout = new Timeout(raw_timeout);
 661   if (timeout->IsReadyToBeMonitored()) {
 662     timeout->StartMonitoring(this);
 663   }
 664   ++num_pending_timeouts_;
 665   return true;
 666 }
 667
 668 void Bus::OnRemoveTimeout(DBusTimeout* raw_timeout) {
 669   AssertOnDBusThread();
 670
 671   Timeout* timeout = static_cast<Timeout*>(dbus_timeout_get_data(raw_timeout));
 672   timeout->Complete();
 673   --num_pending_timeouts_;
 674 }
 675
 676 void Bus::OnToggleTimeout(DBusTimeout* raw_timeout) {
 677   AssertOnDBusThread();
 678
 679   Timeout* timeout = static_cast<Timeout*>(dbus_timeout_get_data(raw_timeout));
 680   if (timeout->IsReadyToBeMonitored()) {
 681     timeout->StartMonitoring(this);
 682   } else {
 683     timeout->StopMonitoring();
 684   }
 685 }
 686
 687 void Bus::OnDispatchStatusChanged(DBusConnection* connection,
 688                                   DBusDispatchStatus status) {
 689   DCHECK_EQ(connection, connection_);
 690   AssertOnDBusThread();
 691
 692   if (!dbus_connection_get_is_connected(connection))
 693     return;
 694
 695   // We cannot call ProcessAllIncomingDataIfAny() here, as calling
 696   // dbus_connection_dispatch() inside DBusDispatchStatusFunction is
 697   // prohibited by the D-Bus library. Hence, we post a task here instead.
 698   // See comments for dbus_connection_set_dispatch_status_function().
 699   PostTaskToDBusThread(FROM_HERE,
 700                        base::Bind(&Bus::ProcessAllIncomingDataIfAny,
 701                                   this));
 702 }
 703
 704 dbus_bool_t Bus::OnAddWatchThunk(DBusWatch* raw_watch, void* data) {
 705   Bus* self = static_cast<Bus*>(data);
 706   return self->OnAddWatch(raw_watch);
 707 }
 708
 709 void Bus::OnRemoveWatchThunk(DBusWatch* raw_watch, void* data) {
 710   Bus* self = static_cast<Bus*>(data);
 711   return self->OnRemoveWatch(raw_watch);
 712 }
 713
 714 void Bus::OnToggleWatchThunk(DBusWatch* raw_watch, void* data) {
 715   Bus* self = static_cast<Bus*>(data);
 716   return self->OnToggleWatch(raw_watch);
 717 }
 718
 719 dbus_bool_t Bus::OnAddTimeoutThunk(DBusTimeout* raw_timeout, void* data) {
 720   Bus* self = static_cast<Bus*>(data);
 721   return self->OnAddTimeout(raw_timeout);
 722 }
 723
 724 void Bus::OnRemoveTimeoutThunk(DBusTimeout* raw_timeout, void* data) {
 725   Bus* self = static_cast<Bus*>(data);
 726   return self->OnRemoveTimeout(raw_timeout);
 727 }
 728
 729 void Bus::OnToggleTimeoutThunk(DBusTimeout* raw_timeout, void* data) {
 730   Bus* self = static_cast<Bus*>(data);
 731   return self->OnToggleTimeout(raw_timeout);
 732 }
 733
 734 void Bus::OnDispatchStatusChangedThunk(DBusConnection* connection,
 735                                        DBusDispatchStatus status,
 736                                        void* data) {
 737   Bus* self = static_cast<Bus*>(data);
 738   return self->OnDispatchStatusChanged(connection, status);
 739 }
 740
 741 }  // namespace dbus