dbus/object_proxy.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/logging.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/metrics/histogram.h"
  11 #include "base/strings/string_piece.h"
  12 #include "base/strings/stringprintf.h"
  13 #include "base/task_runner_util.h"
  14 #include "base/threading/thread.h"
  15 #include "base/threading/thread_restrictions.h"
  16 #include "dbus/dbus_statistics.h"
  17 #include "dbus/message.h"
  18 #include "dbus/object_path.h"
  19 #include "dbus/object_proxy.h"
  20 #include "dbus/scoped_dbus_error.h"
  21 #include "dbus/util.h"
  22
  23 namespace dbus {
  24
  25 namespace {
  26
  27 const char kErrorServiceUnknown[] = "org.freedesktop.DBus.Error.ServiceUnknown";
  28 const char kErrorObjectUnknown[] = "org.freedesktop.DBus.Error.UnknownObject";
  29
  30 // Used for success ratio histograms. 1 for success, 0 for failure.
  31 const int kSuccessRatioHistogramMaxValue = 2;
  32
  33 // The path of D-Bus Object sending NameOwnerChanged signal.
  34 const char kDBusSystemObjectPath[] = "/org/freedesktop/DBus";
  35
  36 // The D-Bus Object interface.
  37 const char kDBusSystemObjectInterface[] = "org.freedesktop.DBus";
  38
  39 // The D-Bus Object address.
  40 const char kDBusSystemObjectAddress[] = "org.freedesktop.DBus";
  41
  42 // The NameOwnerChanged member in |kDBusSystemObjectInterface|.
  43 const char kNameOwnerChangedMember[] = "NameOwnerChanged";
  44
  45 // An empty function used for ObjectProxy::EmptyResponseCallback().
  46 void EmptyResponseCallbackBody(Response* /*response*/) {
  47 }
  48
  49 }  // namespace
  50
  51 ObjectProxy::ObjectProxy(Bus* bus,
  52                          const std::string& service_name,
  53                          const ObjectPath& object_path,
  54                          int options)
  55     : bus_(bus),
  56       service_name_(service_name),
  57       object_path_(object_path),
  58       ignore_service_unknown_errors_(
  59           options & IGNORE_SERVICE_UNKNOWN_ERRORS) {
  60 }
  61
  62 ObjectProxy::~ObjectProxy() {
  63 }
  64
  65 // Originally we tried to make |method_call| a const reference, but we
  66 // gave up as dbus_connection_send_with_reply_and_block() takes a
  67 // non-const pointer of DBusMessage as the second parameter.
  68 scoped_ptr<Response> ObjectProxy::CallMethodAndBlockWithErrorDetails(
  69     MethodCall* method_call, int timeout_ms, ScopedDBusError* error) {
  70   bus_->AssertOnDBusThread();
  71
  72   if (!bus_->Connect() ||
  73       !method_call->SetDestination(service_name_) ||
  74       !method_call->SetPath(object_path_))
  75     return scoped_ptr<Response>();
  76
  77   DBusMessage* request_message = method_call->raw_message();
  78
  79   // Send the message synchronously.
  80   const base::TimeTicks start_time = base::TimeTicks::Now();
  81   DBusMessage* response_message =
  82       bus_->SendWithReplyAndBlock(request_message, timeout_ms, error->get());
  83   // Record if the method call is successful, or not. 1 if successful.
  84   UMA_HISTOGRAM_ENUMERATION("DBus.SyncMethodCallSuccess",
  85                             response_message ? 1 : 0,
  86                             kSuccessRatioHistogramMaxValue);
  87   statistics::AddBlockingSentMethodCall(service_name_,
  88                                         method_call->GetInterface(),
  89                                         method_call->GetMember());
  90
  91   if (!response_message) {
  92     LogMethodCallFailure(method_call->GetInterface(),
  93                          method_call->GetMember(),
  94                          error->is_set() ? error->name() : "unknown error type",
  95                          error->is_set() ? error->message() : "");
  96     return scoped_ptr<Response>();
  97   }
  98   // Record time spent for the method call. Don't include failures.
  99   UMA_HISTOGRAM_TIMES("DBus.SyncMethodCallTime",
 100                       base::TimeTicks::Now() - start_time);
 101
 102   return Response::FromRawMessage(response_message);
 103 }
 104
 105 scoped_ptr<Response> ObjectProxy::CallMethodAndBlock(MethodCall* method_call,
 106                                                      int timeout_ms) {
 107   ScopedDBusError error;
 108   return CallMethodAndBlockWithErrorDetails(method_call, timeout_ms, &error);
 109 }
 110
 111 void ObjectProxy::CallMethod(MethodCall* method_call,
 112                              int timeout_ms,
 113                              ResponseCallback callback) {
 114   CallMethodWithErrorCallback(method_call, timeout_ms, callback,
 115                               base::Bind(&ObjectProxy::OnCallMethodError,
 116                                          this,
 117                                          method_call->GetInterface(),
 118                                          method_call->GetMember(),
 119                                          callback));
 120 }
 121
 122 void ObjectProxy::CallMethodWithErrorCallback(MethodCall* method_call,
 123                                               int timeout_ms,
 124                                               ResponseCallback callback,
 125                                               ErrorCallback error_callback) {
 126   bus_->AssertOnOriginThread();
 127
 128   const base::TimeTicks start_time = base::TimeTicks::Now();
 129
 130   if (!method_call->SetDestination(service_name_) ||
 131       !method_call->SetPath(object_path_)) {
 132     // In case of a failure, run the error callback with NULL.
 133     DBusMessage* response_message = NULL;
 134     base::Closure task = base::Bind(&ObjectProxy::RunResponseCallback,
 135                                     this,
 136                                     callback,
 137                                     error_callback,
 138                                     start_time,
 139                                     response_message);
 140     bus_->GetOriginTaskRunner()->PostTask(FROM_HERE, task);
 141     return;
 142   }
 143
 144   // Increment the reference count so we can safely reference the
 145   // underlying request message until the method call is complete. This
 146   // will be unref'ed in StartAsyncMethodCall().
 147   DBusMessage* request_message = method_call->raw_message();
 148   dbus_message_ref(request_message);
 149
 150   base::Closure task = base::Bind(&ObjectProxy::StartAsyncMethodCall,
 151                                   this,
 152                                   timeout_ms,
 153                                   request_message,
 154                                   callback,
 155                                   error_callback,
 156                                   start_time);
 157   statistics::AddSentMethodCall(service_name_,
 158                                 method_call->GetInterface(),
 159                                 method_call->GetMember());
 160
 161   // Wait for the response in the D-Bus thread.
 162   bus_->GetDBusTaskRunner()->PostTask(FROM_HERE, task);
 163 }
 164
 165 void ObjectProxy::ConnectToSignal(const std::string& interface_name,
 166                                   const std::string& signal_name,
 167                                   SignalCallback signal_callback,
 168                                   OnConnectedCallback on_connected_callback) {
 169   bus_->AssertOnOriginThread();
 170
 171   if (bus_->HasDBusThread()) {
 172     base::PostTaskAndReplyWithResult(
 173         bus_->GetDBusTaskRunner(), FROM_HERE,
 174         base::Bind(&ObjectProxy::ConnectToSignalInternal, this, interface_name,
 175                    signal_name, signal_callback),
 176         base::Bind(on_connected_callback, interface_name, signal_name));
 177   } else {
 178     // If the bus doesn't have a dedicated dbus thread we need to call
 179     // ConnectToSignalInternal directly otherwise we might miss a signal
 180     // that is currently queued if we do a PostTask.
 181     const bool success =
 182         ConnectToSignalInternal(interface_name, signal_name, signal_callback);
 183     on_connected_callback.Run(interface_name, signal_name, success);
 184   }
 185 }
 186
 187 void ObjectProxy::SetNameOwnerChangedCallback(
 188     NameOwnerChangedCallback callback) {
 189   bus_->AssertOnOriginThread();
 190
 191   name_owner_changed_callback_ = callback;
 192 }
 193
 194 void ObjectProxy::WaitForServiceToBeAvailable(
 195     WaitForServiceToBeAvailableCallback callback) {
 196   bus_->AssertOnOriginThread();
 197
 198   wait_for_service_to_be_available_callbacks_.push_back(callback);
 199   bus_->GetDBusTaskRunner()->PostTask(
 200       FROM_HERE,
 201       base::Bind(&ObjectProxy::WaitForServiceToBeAvailableInternal, this));
 202 }
 203
 204 void ObjectProxy::Detach() {
 205   bus_->AssertOnDBusThread();
 206
 207   if (bus_->is_connected())
 208     bus_->RemoveFilterFunction(&ObjectProxy::HandleMessageThunk, this);
 209
 210   for (std::set<std::string>::iterator iter = match_rules_.begin();
 211        iter != match_rules_.end(); ++iter) {
 212     ScopedDBusError error;
 213     bus_->RemoveMatch(*iter, error.get());
 214     if (error.is_set()) {
 215       // There is nothing we can do to recover, so just print the error.
 216       LOG(ERROR) << "Failed to remove match rule: " << *iter;
 217     }
 218   }
 219   match_rules_.clear();
 220 }
 221
 222 // static
 223 ObjectProxy::ResponseCallback ObjectProxy::EmptyResponseCallback() {
 224   return base::Bind(&EmptyResponseCallbackBody);
 225 }
 226
 227 ObjectProxy::OnPendingCallIsCompleteData::OnPendingCallIsCompleteData(
 228     ObjectProxy* in_object_proxy,
 229     ResponseCallback in_response_callback,
 230     ErrorCallback in_error_callback,
 231     base::TimeTicks in_start_time)
 232     : object_proxy(in_object_proxy),
 233       response_callback(in_response_callback),
 234       error_callback(in_error_callback),
 235       start_time(in_start_time) {
 236 }
 237
 238 ObjectProxy::OnPendingCallIsCompleteData::~OnPendingCallIsCompleteData() {
 239 }
 240
 241 void ObjectProxy::StartAsyncMethodCall(int timeout_ms,
 242                                        DBusMessage* request_message,
 243                                        ResponseCallback response_callback,
 244                                        ErrorCallback error_callback,
 245                                        base::TimeTicks start_time) {
 246   bus_->AssertOnDBusThread();
 247
 248   if (!bus_->Connect() || !bus_->SetUpAsyncOperations()) {
 249     // In case of a failure, run the error callback with NULL.
 250     DBusMessage* response_message = NULL;
 251     base::Closure task = base::Bind(&ObjectProxy::RunResponseCallback,
 252                                     this,
 253                                     response_callback,
 254                                     error_callback,
 255                                     start_time,
 256                                     response_message);
 257     bus_->GetOriginTaskRunner()->PostTask(FROM_HERE, task);
 258
 259     dbus_message_unref(request_message);
 260     return;
 261   }
 262
 263   DBusPendingCall* pending_call = NULL;
 264
 265   bus_->SendWithReply(request_message, &pending_call, timeout_ms);
 266
 267   // Prepare the data we'll be passing to OnPendingCallIsCompleteThunk().
 268   // The data will be deleted in OnPendingCallIsCompleteThunk().
 269   OnPendingCallIsCompleteData* data =
 270       new OnPendingCallIsCompleteData(this, response_callback, error_callback,
 271                                       start_time);
 272
 273   // This returns false only when unable to allocate memory.
 274   const bool success = dbus_pending_call_set_notify(
 275       pending_call,
 276       &ObjectProxy::OnPendingCallIsCompleteThunk,
 277       data,
 278       NULL);
 279   CHECK(success) << "Unable to allocate memory";
 280   dbus_pending_call_unref(pending_call);
 281
 282   // It's now safe to unref the request message.
 283   dbus_message_unref(request_message);
 284 }
 285
 286 void ObjectProxy::OnPendingCallIsComplete(DBusPendingCall* pending_call,
 287                                           ResponseCallback response_callback,
 288                                           ErrorCallback error_callback,
 289                                           base::TimeTicks start_time) {
 290   bus_->AssertOnDBusThread();
 291
 292   DBusMessage* response_message = dbus_pending_call_steal_reply(pending_call);
 293   base::Closure task = base::Bind(&ObjectProxy::RunResponseCallback,
 294                                   this,
 295                                   response_callback,
 296                                   error_callback,
 297                                   start_time,
 298                                   response_message);
 299   bus_->GetOriginTaskRunner()->PostTask(FROM_HERE, task);
 300 }
 301
 302 void ObjectProxy::RunResponseCallback(ResponseCallback response_callback,
 303                                       ErrorCallback error_callback,
 304                                       base::TimeTicks start_time,
 305                                       DBusMessage* response_message) {
 306   bus_->AssertOnOriginThread();
 307
 308   bool method_call_successful = false;
 309   if (!response_message) {
 310     // The response is not received.
 311     error_callback.Run(NULL);
 312   } else if (dbus_message_get_type(response_message) ==
 313              DBUS_MESSAGE_TYPE_ERROR) {
 314     // This will take |response_message| and release (unref) it.
 315     scoped_ptr<ErrorResponse> error_response(
 316         ErrorResponse::FromRawMessage(response_message));
 317     error_callback.Run(error_response.get());
 318     // Delete the message  on the D-Bus thread. See below for why.
 319     bus_->GetDBusTaskRunner()->PostTask(
 320         FROM_HERE,
 321         base::Bind(&base::DeletePointer<ErrorResponse>,
 322                    error_response.release()));
 323   } else {
 324     // This will take |response_message| and release (unref) it.
 325     scoped_ptr<Response> response(Response::FromRawMessage(response_message));
 326     // The response is successfully received.
 327     response_callback.Run(response.get());
 328     // The message should be deleted on the D-Bus thread for a complicated
 329     // reason:
 330     //
 331     // libdbus keeps track of the number of bytes in the incoming message
 332     // queue to ensure that the data size in the queue is manageable. The
 333     // bookkeeping is partly done via dbus_message_unref(), and immediately
 334     // asks the client code (Chrome) to stop monitoring the underlying
 335     // socket, if the number of bytes exceeds a certian number, which is set
 336     // to 63MB, per dbus-transport.cc:
 337     //
 338     //   /* Try to default to something that won't totally hose the system,
 339     //    * but doesn't impose too much of a limitation.
 340     //    */
 341     //   transport->max_live_messages_size = _DBUS_ONE_MEGABYTE * 63;
 342     //
 343     // The monitoring of the socket is done on the D-Bus thread (see Watch
 344     // class in bus.cc), hence we should stop the monitoring from D-Bus
 345     // thread, not from the current thread here, which is likely UI thread.
 346     bus_->GetDBusTaskRunner()->PostTask(
 347         FROM_HERE,
 348         base::Bind(&base::DeletePointer<Response>, response.release()));
 349
 350     method_call_successful = true;
 351     // Record time spent for the method call. Don't include failures.
 352     UMA_HISTOGRAM_TIMES("DBus.AsyncMethodCallTime",
 353                         base::TimeTicks::Now() - start_time);
 354   }
 355   // Record if the method call is successful, or not. 1 if successful.
 356   UMA_HISTOGRAM_ENUMERATION("DBus.AsyncMethodCallSuccess",
 357                             method_call_successful,
 358                             kSuccessRatioHistogramMaxValue);
 359 }
 360
 361 void ObjectProxy::OnPendingCallIsCompleteThunk(DBusPendingCall* pending_call,
 362                                                void* user_data) {
 363   OnPendingCallIsCompleteData* data =
 364       reinterpret_cast<OnPendingCallIsCompleteData*>(user_data);
 365   ObjectProxy* self = data->object_proxy;
 366   self->OnPendingCallIsComplete(pending_call,
 367                                 data->response_callback,
 368                                 data->error_callback,
 369                                 data->start_time);
 370   delete data;
 371 }
 372
 373 bool ObjectProxy::ConnectToNameOwnerChangedSignal() {
 374   bus_->AssertOnDBusThread();
 375
 376   if (!bus_->Connect() || !bus_->SetUpAsyncOperations())
 377     return false;
 378
 379   bus_->AddFilterFunction(&ObjectProxy::HandleMessageThunk, this);
 380
 381   // Add a match_rule listening NameOwnerChanged for the well-known name
 382   // |service_name_|.
 383   const std::string name_owner_changed_match_rule =
 384       base::StringPrintf(
 385           "type='signal',interface='org.freedesktop.DBus',"
 386           "member='NameOwnerChanged',path='/org/freedesktop/DBus',"
 387           "sender='org.freedesktop.DBus',arg0='%s'",
 388           service_name_.c_str());
 389
 390   const bool success =
 391       AddMatchRuleWithoutCallback(name_owner_changed_match_rule,
 392                                   "org.freedesktop.DBus.NameOwnerChanged");
 393
 394   // Try getting the current name owner. It's not guaranteed that we can get
 395   // the name owner at this moment, as the service may not yet be started. If
 396   // that's the case, we'll get the name owner via NameOwnerChanged signal,
 397   // as soon as the service is started.
 398   UpdateNameOwnerAndBlock();
 399
 400   return success;
 401 }
 402
 403 bool ObjectProxy::ConnectToSignalInternal(const std::string& interface_name,
 404                                           const std::string& signal_name,
 405                                           SignalCallback signal_callback) {
 406   bus_->AssertOnDBusThread();
 407
 408   if (!ConnectToNameOwnerChangedSignal())
 409     return false;
 410
 411   const std::string absolute_signal_name =
 412       GetAbsoluteMemberName(interface_name, signal_name);
 413
 414   // Add a match rule so the signal goes through HandleMessage().
 415   const std::string match_rule =
 416       base::StringPrintf("type='signal', interface='%s', path='%s'",
 417                          interface_name.c_str(),
 418                          object_path_.value().c_str());
 419   return AddMatchRuleWithCallback(match_rule,
 420                                   absolute_signal_name,
 421                                   signal_callback);
 422 }
 423
 424 void ObjectProxy::WaitForServiceToBeAvailableInternal() {
 425   bus_->AssertOnDBusThread();
 426
 427   if (!ConnectToNameOwnerChangedSignal()) {  // Failed to connect to the signal.
 428     const bool service_is_ready = false;
 429     bus_->GetOriginTaskRunner()->PostTask(
 430         FROM_HERE,
 431         base::Bind(&ObjectProxy::RunWaitForServiceToBeAvailableCallbacks,
 432                    this, service_is_ready));
 433     return;
 434   }
 435
 436   const bool service_is_available = !service_name_owner_.empty();
 437   if (service_is_available) {  // Service is already available.
 438     bus_->GetOriginTaskRunner()->PostTask(
 439         FROM_HERE,
 440         base::Bind(&ObjectProxy::RunWaitForServiceToBeAvailableCallbacks,
 441                    this, service_is_available));
 442     return;
 443   }
 444 }
 445
 446 DBusHandlerResult ObjectProxy::HandleMessage(
 447     DBusConnection* connection,
 448     DBusMessage* raw_message) {
 449   bus_->AssertOnDBusThread();
 450
 451   if (dbus_message_get_type(raw_message) != DBUS_MESSAGE_TYPE_SIGNAL)
 452     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 453
 454   // raw_message will be unrefed on exit of the function. Increment the
 455   // reference so we can use it in Signal.
 456   dbus_message_ref(raw_message);
 457   scoped_ptr<Signal> signal(
 458       Signal::FromRawMessage(raw_message));
 459
 460   // Verify the signal comes from the object we're proxying for, this is
 461   // our last chance to return DBUS_HANDLER_RESULT_NOT_YET_HANDLED and
 462   // allow other object proxies to handle instead.
 463   const ObjectPath path = signal->GetPath();
 464   if (path != object_path_) {
 465     if (path.value() == kDBusSystemObjectPath &&
 466         signal->GetMember() == kNameOwnerChangedMember) {
 467       // Handle NameOwnerChanged separately
 468       return HandleNameOwnerChanged(signal.Pass());
 469     }
 470     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 471   }
 472
 473   const std::string interface = signal->GetInterface();
 474   const std::string member = signal->GetMember();
 475
 476   statistics::AddReceivedSignal(service_name_, interface, member);
 477
 478   // Check if we know about the signal.
 479   const std::string absolute_signal_name = GetAbsoluteMemberName(
 480       interface, member);
 481   MethodTable::const_iterator iter = method_table_.find(absolute_signal_name);
 482   if (iter == method_table_.end()) {
 483     // Don't know about the signal.
 484     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 485   }
 486   VLOG(1) << "Signal received: " << signal->ToString();
 487
 488   std::string sender = signal->GetSender();
 489   if (service_name_owner_ != sender) {
 490     LOG(ERROR) << "Rejecting a message from a wrong sender.";
 491     UMA_HISTOGRAM_COUNTS("DBus.RejectedSignalCount", 1);
 492     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 493   }
 494
 495   const base::TimeTicks start_time = base::TimeTicks::Now();
 496   if (bus_->HasDBusThread()) {
 497     // Post a task to run the method in the origin thread.
 498     // Transfer the ownership of |signal| to RunMethod().
 499     // |released_signal| will be deleted in RunMethod().
 500     Signal* released_signal = signal.release();
 501     bus_->GetOriginTaskRunner()->PostTask(FROM_HERE,
 502                                           base::Bind(&ObjectProxy::RunMethod,
 503                                                      this,
 504                                                      start_time,
 505                                                      iter->second,
 506                                                      released_signal));
 507   } else {
 508     const base::TimeTicks start_time = base::TimeTicks::Now();
 509     // If the D-Bus thread is not used, just call the callback on the
 510     // current thread. Transfer the ownership of |signal| to RunMethod().
 511     Signal* released_signal = signal.release();
 512     RunMethod(start_time, iter->second, released_signal);
 513   }
 514
 515   // We don't return DBUS_HANDLER_RESULT_HANDLED for signals because other
 516   // objects may be interested in them. (e.g. Signals from org.freedesktop.DBus)
 517   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 518 }
 519
 520 void ObjectProxy::RunMethod(base::TimeTicks start_time,
 521                             std::vector<SignalCallback> signal_callbacks,
 522                             Signal* signal) {
 523   bus_->AssertOnOriginThread();
 524
 525   for (std::vector<SignalCallback>::iterator iter = signal_callbacks.begin();
 526        iter != signal_callbacks.end(); ++iter)
 527     iter->Run(signal);
 528
 529   // Delete the message on the D-Bus thread. See comments in
 530   // RunResponseCallback().
 531   bus_->GetDBusTaskRunner()->PostTask(
 532       FROM_HERE,
 533       base::Bind(&base::DeletePointer<Signal>, signal));
 534
 535   // Record time spent for handling the signal.
 536   UMA_HISTOGRAM_TIMES("DBus.SignalHandleTime",
 537                       base::TimeTicks::Now() - start_time);
 538 }
 539
 540 DBusHandlerResult ObjectProxy::HandleMessageThunk(
 541     DBusConnection* connection,
 542     DBusMessage* raw_message,
 543     void* user_data) {
 544   ObjectProxy* self = reinterpret_cast<ObjectProxy*>(user_data);
 545   return self->HandleMessage(connection, raw_message);
 546 }
 547
 548 void ObjectProxy::LogMethodCallFailure(
 549     const base::StringPiece& interface_name,
 550     const base::StringPiece& method_name,
 551     const base::StringPiece& error_name,
 552     const base::StringPiece& error_message) const {
 553   if (ignore_service_unknown_errors_ &&
 554       (error_name == kErrorServiceUnknown || error_name == kErrorObjectUnknown))
 555     return;
 556   logging::LogSeverity severity = logging::LOG_ERROR;
 557   // "UnknownObject" indicates that an object or service is no longer available,
 558   // e.g. a Shill network service has gone out of range. Treat these as warnings
 559   // not errors.
 560   if (error_name == kErrorObjectUnknown)
 561     severity = logging::LOG_WARNING;
 562   std::ostringstream msg;
 563   msg << "Failed to call method: " << interface_name << "." << method_name
 564       << ": object_path= " << object_path_.value()
 565       << ": " << error_name << ": " << error_message;
 566   logging::LogAtLevel(severity, msg.str());
 567 }
 568
 569 void ObjectProxy::OnCallMethodError(const std::string& interface_name,
 570                                     const std::string& method_name,
 571                                     ResponseCallback response_callback,
 572                                     ErrorResponse* error_response) {
 573   if (error_response) {
 574     // Error message may contain the error message as string.
 575     MessageReader reader(error_response);
 576     std::string error_message;
 577     reader.PopString(&error_message);
 578     LogMethodCallFailure(interface_name,
 579                          method_name,
 580                          error_response->GetErrorName(),
 581                          error_message);
 582   }
 583   response_callback.Run(NULL);
 584 }
 585
 586 bool ObjectProxy::AddMatchRuleWithCallback(
 587     const std::string& match_rule,
 588     const std::string& absolute_signal_name,
 589     SignalCallback signal_callback) {
 590   DCHECK(!match_rule.empty());
 591   DCHECK(!absolute_signal_name.empty());
 592   bus_->AssertOnDBusThread();
 593
 594   if (match_rules_.find(match_rule) == match_rules_.end()) {
 595     ScopedDBusError error;
 596     bus_->AddMatch(match_rule, error.get());
 597     if (error.is_set()) {
 598       LOG(ERROR) << "Failed to add match rule \"" << match_rule << "\". Got "
 599                  << error.name() << ": " << error.message();
 600       return false;
 601     } else {
 602       // Store the match rule, so that we can remove this in Detach().
 603       match_rules_.insert(match_rule);
 604       // Add the signal callback to the method table.
 605       method_table_[absolute_signal_name].push_back(signal_callback);
 606       return true;
 607     }
 608   } else {
 609     // We already have the match rule.
 610     method_table_[absolute_signal_name].push_back(signal_callback);
 611     return true;
 612   }
 613 }
 614
 615 bool ObjectProxy::AddMatchRuleWithoutCallback(
 616     const std::string& match_rule,
 617     const std::string& absolute_signal_name) {
 618   DCHECK(!match_rule.empty());
 619   DCHECK(!absolute_signal_name.empty());
 620   bus_->AssertOnDBusThread();
 621
 622   if (match_rules_.find(match_rule) != match_rules_.end())
 623     return true;
 624
 625   ScopedDBusError error;
 626   bus_->AddMatch(match_rule, error.get());
 627   if (error.is_set()) {
 628     LOG(ERROR) << "Failed to add match rule \"" << match_rule << "\". Got "
 629                << error.name() << ": " << error.message();
 630     return false;
 631   }
 632   // Store the match rule, so that we can remove this in Detach().
 633   match_rules_.insert(match_rule);
 634   return true;
 635 }
 636
 637 void ObjectProxy::UpdateNameOwnerAndBlock() {
 638   bus_->AssertOnDBusThread();
 639   // Errors should be suppressed here, as the service may not be yet running
 640   // when connecting to signals of the service, which is just fine.
 641   // The ObjectProxy will be notified when the service is launched via
 642   // NameOwnerChanged signal. See also comments in ConnectToSignalInternal().
 643   service_name_owner_ =
 644       bus_->GetServiceOwnerAndBlock(service_name_, Bus::SUPPRESS_ERRORS);
 645 }
 646
 647 DBusHandlerResult ObjectProxy::HandleNameOwnerChanged(
 648     scoped_ptr<Signal> signal) {
 649   DCHECK(signal);
 650   bus_->AssertOnDBusThread();
 651
 652   // Confirm the validity of the NameOwnerChanged signal.
 653   if (signal->GetMember() == kNameOwnerChangedMember &&
 654       signal->GetInterface() == kDBusSystemObjectInterface &&
 655       signal->GetSender() == kDBusSystemObjectAddress) {
 656     MessageReader reader(signal.get());
 657     std::string name, old_owner, new_owner;
 658     if (reader.PopString(&name) &&
 659         reader.PopString(&old_owner) &&
 660         reader.PopString(&new_owner) &&
 661         name == service_name_) {
 662       service_name_owner_ = new_owner;
 663       bus_->GetOriginTaskRunner()->PostTask(
 664           FROM_HERE,
 665           base::Bind(&ObjectProxy::RunNameOwnerChangedCallback,
 666                      this, old_owner, new_owner));
 667
 668       const bool service_is_available = !service_name_owner_.empty();
 669       if (service_is_available) {
 670         bus_->GetOriginTaskRunner()->PostTask(
 671             FROM_HERE,
 672             base::Bind(&ObjectProxy::RunWaitForServiceToBeAvailableCallbacks,
 673                        this, service_is_available));
 674       }
 675     }
 676   }
 677
 678   // Always return unhandled to let other object proxies handle the same
 679   // signal.
 680   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 681 }
 682
 683 void ObjectProxy::RunNameOwnerChangedCallback(const std::string& old_owner,
 684                                               const std::string& new_owner) {
 685   bus_->AssertOnOriginThread();
 686   if (!name_owner_changed_callback_.is_null())
 687     name_owner_changed_callback_.Run(old_owner, new_owner);
 688 }
 689
 690 void ObjectProxy::RunWaitForServiceToBeAvailableCallbacks(
 691     bool service_is_available) {
 692   bus_->AssertOnOriginThread();
 693
 694   std::vector<WaitForServiceToBeAvailableCallback> callbacks;
 695   callbacks.swap(wait_for_service_to_be_available_callbacks_);
 696   for (size_t i = 0; i < callbacks.size(); ++i)
 697     callbacks[i].Run(service_is_available);
 698 }
 699
 700 }  // namespace dbus