dbus: Add ObjectProxy::EmptyResponseCallback().

dbus/object_proxy.cc

 // Copyright (c) 2011 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.h"
 #include "base/metrics/histogram.h"
@@ skipping 11 matching lines @@
 
 // Gets the absolute signal name by concatenating the interface name and
 // the signal name. Used for building keys for method_table_ in
 // ObjectProxy.
 std::string GetAbsoluteSignalName(
     const std::string& interface_name,
     const std::string& signal_name) {
   return interface_name + "." + signal_name;
 }
 
+// An empty function used for ObjectProxy::EmptyResponseCallback().
+void EmptyResponseCallbackBody(dbus::Response* unused_response) {
+}
+
 }  // namespace
 
 namespace dbus {
 
 ObjectProxy::ObjectProxy(Bus* bus,
                          const std::string& service_name,
                          const std::string& object_path)
     : bus_(bus),
       service_name_(service_name),
       object_path_(object_path),
@@ skipping 91 matching lines @@
   for (size_t i = 0; i < match_rules_.size(); ++i) {
     ScopedDBusError error;
     bus_->RemoveMatch(match_rules_[i], error.get());
     if (error.is_set()) {
       // There is nothing we can do to recover, so just print the error.
       LOG(ERROR) << "Failed to remove match rule: " << match_rules_[i];
     }
   }
 }
 
+// static
+ObjectProxy::ResponseCallback ObjectProxy::EmptyResponseCallback() {
+  return base::Bind(&EmptyResponseCallbackBody);
+}
+
 ObjectProxy::OnPendingCallIsCompleteData::OnPendingCallIsCompleteData(
     ObjectProxy* in_object_proxy,
     ResponseCallback in_response_callback,
     base::TimeTicks in_start_time)
     : object_proxy(in_object_proxy),
       response_callback(in_response_callback),
       start_time(in_start_time) {
 }
 
 ObjectProxy::OnPendingCallIsCompleteData::~OnPendingCallIsCompleteData() {
@@ skipping 52 matching lines @@
                                   start_time,
                                   response_message);
   bus_->PostTaskToOriginThread(FROM_HERE, task);
 }
 
 void ObjectProxy::RunResponseCallback(ResponseCallback response_callback,
                                       base::TimeTicks start_time,
                                       DBusMessage* response_message) {
   bus_->AssertOnOriginThread();
 
-  bool response_callback_called = false;
+  bool method_call_successful = false;
   if (!response_message) {
     // The response is not received.
     response_callback.Run(NULL);
   } else if (dbus_message_get_type(response_message) ==
              DBUS_MESSAGE_TYPE_ERROR) {
     // This will take |response_message| and release (unref) it.
     scoped_ptr<dbus::ErrorResponse> error_response(
         dbus::ErrorResponse::FromRawMessage(response_message));
     // Error message may contain the error message as string.
     dbus::MessageReader reader(error_response.get());
     std::string error_message;
     reader.PopString(&error_message);
     LOG(ERROR) << "Failed to call method: " << error_response->GetErrorName()
                << ": " << error_message;
     // We don't give the error message to the callback.
     response_callback.Run(NULL);
   } else {
     // This will take |response_message| and release (unref) it.
     scoped_ptr<dbus::Response> response(
         dbus::Response::FromRawMessage(response_message));
     // The response is successfully received.
     response_callback.Run(response.get());
-    response_callback_called = true;
+    method_call_successful = true;
     // Record time spent for the method call. Don't include failures.
     UMA_HISTOGRAM_TIMES("DBus.AsyncMethodCallTime",
                         base::TimeTicks::Now() - start_time);
   }
   // Record if the method call is successful, or not. 1 if successful.
   UMA_HISTOGRAM_ENUMERATION("DBus.AsyncMethodCallSuccess",
-                            response_callback_called,
+                            method_call_successful,
                             kSuccessRatioHistogramMaxValue);
 }
 
 void ObjectProxy::OnPendingCallIsCompleteThunk(DBusPendingCall* pending_call,
                                                void* user_data) {
   OnPendingCallIsCompleteData* data =
       reinterpret_cast<OnPendingCallIsCompleteData*>(user_data);
   ObjectProxy* self = data->object_proxy;
   self->OnPendingCallIsComplete(pending_call,
                                 data->response_callback,
@@ skipping 135 matching lines @@
 
 DBusHandlerResult ObjectProxy::HandleMessageThunk(
     DBusConnection* connection,
     DBusMessage* raw_message,
     void* user_data) {
   ObjectProxy* self = reinterpret_cast<ObjectProxy*>(user_data);
   return self->HandleMessage(connection, raw_message);
 }
 
 }  // namespace dbus