Allow dbus clients to silence logging when a service is unavailable.

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 <string.h>
+
 #include "dbus/bus.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "dbus/message.h"
 #include "dbus/object_proxy.h"
 #include "dbus/scoped_dbus_error.h"
 
 namespace {
 
+const char kErrorServiceUnknown[] = "org.freedesktop.DBus.Error.ServiceUnknown";
+
 // Used for success ratio histograms. 1 for success, 0 for failure.
 const int kSuccessRatioHistogramMaxValue = 2;
 
 // 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)
+                         const std::string& object_path,
+                         ServiceUnknownBehavior service_unknown_behavior)
     : bus_(bus),
       service_name_(service_name),
       object_path_(object_path),
-      filter_added_(false) {
+      filter_added_(false),
+      log_unknown_service_errors_(
+          service_unknown_behavior == LOG_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.
 Response* ObjectProxy::CallMethodAndBlock(MethodCall* method_call,
                                           int timeout_ms) {
@@ skipping 11 matching lines @@
   // Send the message synchronously.
   const base::TimeTicks start_time = base::TimeTicks::Now();
   DBusMessage* response_message =
       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);
 
   if (!response_message) {
-    LOG(ERROR) << "Failed to call method: "
-               << (error.is_set() ? error.message() : "");
+    const bool error_is_set = error.is_set();

[satorux1, 2012/02/10 08:12:52]

The caching is unnecessary. You'll only save two bytes "()".

[adamk, 2012/02/10 17:57:16]

It wasn't obvious to me that error.is_set() was cheap. Changed to not cache.

+    const char* error_name = error_is_set ? error.name() : "";
+    if (log_unknown_service_errors_ ||
+        strcmp(error_name, kErrorServiceUnknown)) {

[satorux1, 2012/02/10 08:12:52]

strcmp() is hard to read. Please make it something like

 std::string(error_name) != kErrorServiceUnknown

[adamk, 2012/02/10 17:57:16]

Changed error_name to be a base::StringPiece.

+      LOG(ERROR) << "Failed to call method: "
+                 << (error_is_set ? error.message() : "");
+    }
     return NULL;
   }
   // 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);
 }
 
 void ObjectProxy::CallMethod(MethodCall* method_call,
@@ skipping 137 matching lines @@
   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;
+    std::string error_name = error_response->GetErrorName();
+    if (log_unknown_service_errors_ || error_name != kErrorServiceUnknown) {
+      std::string error_message;
+      reader.PopString(&error_message);
+      LOG(ERROR) << "Failed to call method: " << error_name
+                 << ": " << 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());
     method_call_successful = true;
     // Record time spent for the method call. Don't include failures.
@@ skipping 159 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