Reduce chrome cras dbus call logs during device rebooting.

chromeos/audio/cras_audio_handler.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/audio/cras_audio_handler.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/bind.h"
@@ skipping 270 matching lines @@
   } else if (device_id == active_input_node_id_) {
     SetInputMute(mute_on);
     return;
   }
 
   AudioDevice device;
   if (const AudioDevice* device = GetDeviceFromId(device_id))
     audio_pref_handler_->SetMuteValue(*device, mute_on);
 }
 
+void CrasAudioHandler::LogErrors() {
+  log_errors_ = true;
+}
+
 CrasAudioHandler::CrasAudioHandler(
     scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler)
     : audio_pref_handler_(audio_pref_handler),
       weak_ptr_factory_(this),
       output_mute_on_(false),
       input_mute_on_(false),
       output_volume_(0),
       input_gain_(0),
       active_output_node_id_(0),
       active_input_node_id_(0),
       has_alternative_input_(false),
       has_alternative_output_(false),
       output_mute_locked_(false),
-      input_mute_locked_(false) {
+      input_mute_locked_(false),
+      log_errors_(false) {
   if (!audio_pref_handler.get())
     return;
   // If the DBusThreadManager or the CrasAudioClient aren't available, there
   // isn't much we can do. This should only happen when running tests.
   if (!chromeos::DBusThreadManager::IsInitialized() ||
       !chromeos::DBusThreadManager::Get() ||
       !chromeos::DBusThreadManager::Get()->GetCrasAudioClient())
     return;
   chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->AddObserver(this);
   audio_pref_handler_->AddAudioPrefObserver(this);
+  if (chromeos::DBusThreadManager::Get()->GetSessionManagerClient()) {
+    chromeos::DBusThreadManager::Get()->GetSessionManagerClient()->
+        AddObserver(this);
+  }
   InitializeAudioState();
 }
 
 CrasAudioHandler::~CrasAudioHandler() {
   if (!chromeos::DBusThreadManager::IsInitialized() ||
       !chromeos::DBusThreadManager::Get() ||
       !chromeos::DBusThreadManager::Get()->GetCrasAudioClient())
     return;
   chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
       RemoveObserver(this);
+  chromeos::DBusThreadManager::Get()->GetSessionManagerClient()->
+      RemoveObserver(this);
   if (audio_pref_handler_.get())
     audio_pref_handler_->RemoveAudioPrefObserver(this);
   audio_pref_handler_ = NULL;
 }
 
 void CrasAudioHandler::AudioClientRestarted() {
+  // Make sure the logging is enabled in case cras server
+  // restarts after crashing.
+  LogErrors();
   InitializeAudioState();
 }
 
 void CrasAudioHandler::NodesChanged() {
   // Refresh audio nodes data.
   GetNodes();
 }
 
 void CrasAudioHandler::ActiveOutputNodeChanged(uint64 node_id) {
   if (active_output_node_id_ == node_id)
     return;
 
   // Active audio output device should always be changed by chrome.
-  LOG(WARNING) << "Active output node changed unexpectedly by system node_id="
-      << "0x" << std::hex << node_id;
+  // During system boot, cras may change active input to unknown device 0x1,
+  // we don't need to log it, since it is not an valid device.
+  if (GetDeviceFromId(node_id)) {
+    LOG_IF(WARNING, log_errors_)
+        << "Active output node changed unexpectedly by system node_id="
+        << "0x" << std::hex << node_id;
+  }
 }
 
 void CrasAudioHandler::ActiveInputNodeChanged(uint64 node_id) {
   if (active_input_node_id_ == node_id)
     return;
 
   // Active audio input device should always be changed by chrome.
-  LOG(WARNING) << "Active input node changed unexpectedly by system node_id="
-      << "0x" << std::hex << node_id;
+  // During system boot, cras may change active input to unknown device 0x2,
+  // we don't need to log it, since it is not an valid device.
+  if (GetDeviceFromId(node_id)) {
+    LOG_IF(WARNING, log_errors_)
+        << "Active input node changed unexpectedly by system node_id="
+        << "0x" << std::hex << node_id;
+  }
 }
 
 void CrasAudioHandler::OnAudioPolicyPrefChanged() {
   ApplyAudioPolicy();
 }
 
+void CrasAudioHandler::EmitLoginPromptVisibleCalled() {
+  // Enable logging after cras server is started, which will be after
+  // EmitLoginPromptVisible.
+  LogErrors();
+}
+
 const AudioDevice* CrasAudioHandler::GetDeviceFromId(uint64 device_id) const {
   AudioDeviceMap::const_iterator it = audio_devices_.find(device_id);
   if (it == audio_devices_.end())
     return NULL;
 
   return &(it->second);
 }
 
 void CrasAudioHandler::SetupAudioInputState() {
   // Set the initial audio state to the ones read from audio prefs.
   const AudioDevice* device = GetDeviceFromId(active_input_node_id_);
   if (!device) {
-    LOG(ERROR) << "Can't set up audio state for unknow input device id ="
+    LOG_IF(ERROR, log_errors_)
+        << "Can't set up audio state for unknown input device id ="
         << "0x" << std::hex << active_input_node_id_;
     return;
   }
   input_mute_on_ = audio_pref_handler_->GetMuteValue(*device);
   input_gain_ = audio_pref_handler_->GetInputGainValue(device);
   SetInputMuteInternal(input_mute_on_);
   // TODO(rkc,jennyz): Set input gain once we decide on how to store
   // the gain values since the range and step are both device specific.
 }
 
 void CrasAudioHandler::SetupAudioOutputState() {
   const AudioDevice* device = GetDeviceFromId(active_output_node_id_);
   if (!device) {
-    LOG(ERROR) << "Can't set up audio state for unknow output device id ="
-               << "0x" << std::hex << active_output_node_id_;
+    LOG_IF(ERROR, log_errors_)
+        << "Can't set up audio state for unknown output device id ="
+        << "0x" << std::hex << active_output_node_id_;
     return;
   }
   output_mute_on_ = audio_pref_handler_->GetMuteValue(*device);
   output_volume_ = audio_pref_handler_->GetOutputVolumeValue(device);
 
   SetOutputMuteInternal(output_mute_on_);
   SetOutputNodeVolume(active_output_node_id_, output_volume_);
 }
 
 void CrasAudioHandler::InitializeAudioState() {
   ApplyAudioPolicy();
   GetNodes();
 }
 
 void CrasAudioHandler::ApplyAudioPolicy() {
   output_mute_locked_ = false;
   if (!audio_pref_handler_->GetAudioOutputAllowedValue()) {
     // Mute the device, but do not update the preference.
     SetOutputMuteInternal(true);
     output_mute_locked_ = true;
   } else {
     // Restore the mute state.
     const AudioDevice* device = GetDeviceFromId(active_output_node_id_);
     if (device)
       SetOutputMuteInternal(audio_pref_handler_->GetMuteValue(*device));
   }
 
   input_mute_locked_ = false;
   if (audio_pref_handler_->GetAudioCaptureAllowedValue()) {
-    SetInputMute(false);
+    // Set input mute if we have discovered active input device.
+    const AudioDevice* device = GetDeviceFromId(active_input_node_id_);
+    if (device)
+      SetInputMuteInternal(false);
   } else {
     SetInputMute(true);
     input_mute_locked_ = true;
   }
 }
 
 void CrasAudioHandler::SetOutputNodeVolume(uint64 node_id, int volume) {
   chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
       SetOutputNodeVolume(node_id, volume);
 }
@@ skipping 19 matching lines @@
 
   input_mute_on_ = mute_on;
   chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
       SetInputMute(mute_on);
   return true;
 }
 
 void CrasAudioHandler::GetNodes() {
   chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->GetNodes(
       base::Bind(&CrasAudioHandler::HandleGetNodes,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&CrasAudioHandler::HandleGetNodesError,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 bool CrasAudioHandler::ChangeActiveDevice(const AudioDevice& new_active_device,
                                           uint64* current_active_node_id) {
   // If the device we want to switch to is already the current active device,
   // do nothing.
   if (new_active_device.active &&
       new_active_device.id == *current_active_node_id) {
     return false;
@@ skipping 111 matching lines @@
                                 audio_devices_.size(),
                                 active_output_node_id_) &&
       !output_devices_pq_.empty()) {
     SwitchToDevice(output_devices_pq_.top());
   }
 }
 
 void CrasAudioHandler::HandleGetNodes(const chromeos::AudioNodeList& node_list,
                                       bool success) {
   if (!success) {
-    LOG(ERROR) << "Failed to retrieve audio nodes data";
+    LOG_IF(ERROR, log_errors_) << "Failed to retrieve audio nodes data";
     return;
   }
 
   UpdateDevicesAndSwitchActive(node_list);
   FOR_EACH_OBSERVER(AudioObserver, observers_, OnAudioNodesChanged());
 }
 
+void CrasAudioHandler::HandleGetNodesError(const std::string& error_name,
+                                           const std::string& error_msg) {
+  LOG_IF(ERROR, log_errors_) << "Failed to call GetNodes: "
+      << error_name  << ": " << error_msg;
+}
 }  // namespace chromeos