Add test coverage for CrasAudioHandler.

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"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "chromeos/audio/audio_devices_pref_handler.h"
-#include "chromeos/audio/mock_cras_audio_handler.h"
+#include "chromeos/audio/audio_devices_pref_handler_stub.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 
 using std::max;
 using std::min;
 
 namespace chromeos {
 
 namespace {
 
 // Default value for unmuting, as a percent in the range [0, 100].
@@ skipping 37 matching lines @@
 // static
 void CrasAudioHandler::Initialize(
     scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler) {
   CHECK(!g_cras_audio_handler);
   g_cras_audio_handler = new CrasAudioHandler(audio_pref_handler);
 }
 
 // static
 void CrasAudioHandler::InitializeForTesting() {
   CHECK(!g_cras_audio_handler);
-  g_cras_audio_handler = new MockCrasAudioHandler();
+  CrasAudioHandler::Initialize(new AudioDevicesPrefHandlerStub());
 }
 
 // static
 void CrasAudioHandler::Shutdown() {
   CHECK(g_cras_audio_handler);
   delete g_cras_audio_handler;
   g_cras_audio_handler = NULL;
 }
 
 // static
@@ skipping 74 matching lines @@
 
 uint64 CrasAudioHandler::GetActiveOutputNode() const {
   return active_output_node_id_;
 }
 
 uint64 CrasAudioHandler::GetActiveInputNode() const {
   return active_input_node_id_;
 }
 
 void CrasAudioHandler::GetAudioDevices(AudioDeviceList* device_list) const {
+  device_list->clear();

[rkc, 2013/07/23 20:37:43]

A DCHECK(device_list) might be appropriate right before the ->clear().

[jennyz, 2013/07/24 21:12:25]

I think it is OK for client to pass in an non-empty device_list object, as long
as we cleared it inside GetAudioDevices, it is good.

   for (AudioDeviceMap::const_iterator it = audio_devices_.begin();
        it != audio_devices_.end(); ++it)
     device_list->push_back(it->second);
 }
 
 bool CrasAudioHandler::GetActiveOutputDevice(AudioDevice* device) const {
   const AudioDevice* active_device = GetDeviceFromId(active_output_node_id_);
   if (!device)
     return false;
   *device = *active_device;
@@ skipping 35 matching lines @@
 }
 
 void CrasAudioHandler::AdjustOutputVolumeByPercent(int adjust_by_percent) {
   SetOutputVolumePercent(output_volume_ + adjust_by_percent);
 }
 
 void CrasAudioHandler::SetOutputMute(bool mute_on) {
   if (!SetOutputMuteInternal(mute_on))
     return;
 
-  output_mute_on_ = mute_on;
-
   if (const AudioDevice* device = GetDeviceFromId(active_output_node_id_))
     audio_pref_handler_->SetMuteValue(*device, output_mute_on_);
 
   FOR_EACH_OBSERVER(AudioObserver, observers_, OnOutputMuteChanged());
 }
 
 void CrasAudioHandler::AdjustOutputVolumeToAudibleLevel() {
   if (output_volume_ <= kMuteThresholdPercent) {
     // Avoid the situation when sound has been unmuted, but the volume
     // is set to a very low value, so user still can't hear any sound.
     SetOutputVolumePercent(kDefaultUnmuteVolumePercent);
   }
 }
 
 void CrasAudioHandler::SetInputMute(bool mute_on) {
   if (!SetInputMuteInternal(mute_on))
     return;
 
-  input_mute_on_ = mute_on;
-
   AudioDevice device;
   if (const AudioDevice* device = GetDeviceFromId(active_input_node_id_))
     audio_pref_handler_->SetMuteValue(*device, input_mute_on_);
 
 
   FOR_EACH_OBSERVER(AudioObserver, observers_, OnInputMuteChanged());
 }
 
 void CrasAudioHandler::SetActiveOutputNode(uint64 node_id) {
   chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
@@ skipping 181 matching lines @@
 
 void CrasAudioHandler::SetOutputNodeVolume(uint64 node_id, int volume) {
   chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
       SetOutputNodeVolume(node_id, volume);
 }
 
 bool  CrasAudioHandler::SetOutputMuteInternal(bool mute_on) {
   if (output_mute_locked_)
     return false;
 
+  output_mute_on_ = mute_on;
   chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
       SetOutputUserMute(mute_on);
   return true;
 }
 
 void CrasAudioHandler::SetInputNodeGain(uint64 node_id, int gain) {
   chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->
       SetInputNodeGain(node_id, gain);
 }
 
 bool CrasAudioHandler::SetInputMuteInternal(bool mute_on) {
   if (input_mute_locked_)
     return false;
 
+  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()));
 }
@@ skipping 70 matching lines @@
   if (!success) {
     LOG(ERROR) << "Failed to retrieve audio nodes data";
     return;
   }
 
   UpdateDevicesAndSwitchActive(node_list);
   FOR_EACH_OBSERVER(AudioObserver, observers_, OnAudioNodesChanged());
 }
 
 }  // namespace chromeos