Reduce chrome cras dbus call logs during device rebooting.

chromeos/dbus/cras_audio_client.cc

 // Copyright (c) 2013 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 "chromeos/dbus/cras_audio_client.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
 #include "chromeos/dbus/cras_audio_client_stub_impl.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
+// Error name if cras dbus call fails with empty ErrorResponse.
+const char kNoResponseError[] =
+    "org.chromium.cras.Error.NoResponse";
+
 // The CrasAudioClient implementation used in production.
 class CrasAudioClientImpl : public CrasAudioClient {
  public:
   CrasAudioClientImpl() : cras_proxy_(NULL), weak_ptr_factory_(this) {}
 
   virtual ~CrasAudioClientImpl() {
   }
 
   // CrasAudioClient overrides:
   virtual void AddObserver(Observer* observer) OVERRIDE {
@@ skipping 11 matching lines @@
   virtual void GetVolumeState(const GetVolumeStateCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(cras::kCrasControlInterface,
                                  cras::kGetVolumeState);
     cras_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&CrasAudioClientImpl::OnGetVolumeState,
                    weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
-  virtual void GetNodes(const GetNodesCallback& callback) OVERRIDE {
+  virtual void GetNodes(const GetNodesCallback& callback,
+                        const ErrorCallback& error_callback) OVERRIDE {
     dbus::MethodCall method_call(cras::kCrasControlInterface,
                                  cras::kGetNodes);
-    cras_proxy_->CallMethod(
+    cras_proxy_->CallMethodWithErrorCallback(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&CrasAudioClientImpl::OnGetNodes,
-                   weak_ptr_factory_.GetWeakPtr(), callback));
+                   weak_ptr_factory_.GetWeakPtr(), callback),
+        base::Bind(&CrasAudioClientImpl::OnError,
+                   weak_ptr_factory_.GetWeakPtr(), error_callback));
   }
 
   virtual void SetOutputNodeVolume(uint64 node_id, int32 volume) OVERRIDE {
     dbus::MethodCall method_call(cras::kCrasControlInterface,
                                  cras::kSetOutputNodeVolume);
     dbus::MessageWriter writer(&method_call);
     writer.AppendUint64(node_id);
     writer.AppendInt32(volume);
     cras_proxy_->CallMethod(
         &method_call,
@@ skipping 218 matching lines @@
           LOG(WARNING) << "Error reading audio node data from cras: "
                        << response->ToString();
           break;
         }
         // Filter out the "UNKNOWN" type of audio devices.
         if (node.type != "UNKNOWN")
           node_list.push_back(node);
       }
     }
 
-    if (node_list.size() == 0) {
-      success = false;
-      LOG(ERROR) << "Error calling " << cras::kGetNodes;
-    }
+    if (node_list.size() == 0)
+      return;
 
     callback.Run(node_list, success);
   }
 
+  void OnError(const ErrorCallback& error_callback,
+               dbus::ErrorResponse* response) {
+    // Error response has optional error message argument.
+    std::string error_name;
+    std::string error_message;
+    if (response) {
+      dbus::MessageReader reader(response);
+      error_name = response->GetErrorName();
+      reader.PopString(&error_message);
+    } else {
+      error_name = kNoResponseError;
+      error_message = "";
+    }
+    error_callback.Run(error_name, error_message);
+  }
+
   bool GetAudioNode(dbus::Response* response,
                     dbus::MessageReader* array_reader,
                     AudioNode *node) {
     while (array_reader->HasMoreData()) {
       dbus::MessageReader dict_entry_reader(response);
       dbus::MessageReader value_reader(response);
       std::string key;
       if (!array_reader->PopDictEntry(&dict_entry_reader) ||
           !dict_entry_reader.PopString(&key) ||
           !dict_entry_reader.PopVariant(&value_reader)) {
@@ skipping 67 matching lines @@
 // static
 CrasAudioClient* CrasAudioClient::Create(DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION) {
     return new CrasAudioClientImpl();
   }
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new CrasAudioClientStubImpl();
 }
 
 }  // namespace chromeos