Add ObjectProxy::CallMethodAndBlockWithErrorDetails methods

dbus/object_proxy.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "dbus/bus.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 48 matching lines @@
       ignore_service_unknown_errors_(
           options & IGNORE_SERVICE_UNKNOWN_ERRORS) {
 }
 
 ObjectProxy::~ObjectProxy() {
 }
 
 // Originally we tried to make |method_call| a const reference, but we
 // gave up as dbus_connection_send_with_reply_and_block() takes a
 // non-const pointer of DBusMessage as the second parameter.
-scoped_ptr<Response> ObjectProxy::CallMethodAndBlock(MethodCall* method_call,
-                                                     int timeout_ms) {
+scoped_ptr<Response> ObjectProxy::CallMethodAndBlockWithErrorDetails(
+    MethodCall* method_call, int timeout_ms, ScopedDBusError* error) {
   bus_->AssertOnDBusThread();
 
   if (!bus_->Connect() ||
       !method_call->SetDestination(service_name_) ||
       !method_call->SetPath(object_path_))
     return scoped_ptr<Response>();
 
   DBusMessage* request_message = method_call->raw_message();
 
-  ScopedDBusError error;
-
   // Send the message synchronously.
   const base::TimeTicks start_time = base::TimeTicks::Now();
   DBusMessage* response_message =
-      bus_->SendWithReplyAndBlock(request_message, timeout_ms, error.get());
+      bus_->SendWithReplyAndBlock(request_message, timeout_ms, error->get());
   // Record if the method call is successful, or not. 1 if successful.
   UMA_HISTOGRAM_ENUMERATION("DBus.SyncMethodCallSuccess",
                             response_message ? 1 : 0,
                             kSuccessRatioHistogramMaxValue);
   statistics::AddBlockingSentMethodCall(service_name_,
                                         method_call->GetInterface(),
                                         method_call->GetMember());
 
   if (!response_message) {
     LogMethodCallFailure(method_call->GetInterface(),
                          method_call->GetMember(),
-                         error.is_set() ? error.name() : "unknown error type",
-                         error.is_set() ? error.message() : "");
+                         error->is_set() ? error->name() : "unknown error type",
+                         error->is_set() ? error->message() : "");
     return scoped_ptr<Response>();
   }
   // Record time spent for the method call. Don't include failures.
   UMA_HISTOGRAM_TIMES("DBus.SyncMethodCallTime",
                       base::TimeTicks::Now() - start_time);
 
   return Response::FromRawMessage(response_message);
 }
 
+scoped_ptr<Response> ObjectProxy::CallMethodAndBlock(MethodCall* method_call,
+                                                     int timeout_ms) {
+  ScopedDBusError error;
+  return CallMethodAndBlockWithErrorDetails(method_call, timeout_ms, &error);
+}
+
 void ObjectProxy::CallMethod(MethodCall* method_call,
                              int timeout_ms,
                              ResponseCallback callback) {
   CallMethodWithErrorCallback(method_call, timeout_ms, callback,
                               base::Bind(&ObjectProxy::OnCallMethodError,
                                          this,
                                          method_call->GetInterface(),
                                          method_call->GetMember(),
                                          callback));
 }
@@ skipping 577 matching lines @@
     bool service_is_available) {
   bus_->AssertOnOriginThread();
 
   std::vector<WaitForServiceToBeAvailableCallback> callbacks;
   callbacks.swap(wait_for_service_to_be_available_callbacks_);
   for (size_t i = 0; i < callbacks.size(); ++i)
     callbacks[i].Run(service_is_available);
 }
 
 }  // namespace dbus