Set up hdmi output device default volume to 100.

chromeos/audio/cras_audio_handler_unittest.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 "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/values.h"
@@ skipping 1057 matching lines @@
 
   // Verify the output volume is changed to the designated value,
   // OnOutputVolumeChanged event is fired, and the device volume value
   // is saved the preferences.
   const int kVolume = 60;
   EXPECT_EQ(kVolume, cras_audio_handler_->GetOutputVolumePercent());
   EXPECT_EQ(1, test_observer_->output_volume_changed_count());
   AudioDevice device;
   EXPECT_TRUE(cras_audio_handler_->GetActiveOutputDevice(&device));
   EXPECT_EQ(device.id, kInternalSpeaker.id);
-  EXPECT_EQ(kVolume, audio_pref_handler_->GetVolumeGainValue(device));
+  EXPECT_EQ(kVolume, audio_pref_handler_->GetOutputVolumeValue(&device));
 }
 
 TEST_F(CrasAudioHandlerTest, SetInputGainPercent) {
   AudioNodeList audio_nodes;
   audio_nodes.push_back(kInternalMic);
   SetUpCrasAudioHandler(audio_nodes);
   EXPECT_EQ(0, test_observer_->input_gain_changed_count());
 
   cras_audio_handler_->SetInputGainPercent(60);
 
   // Verify the input gain changed to the designated value,
   // OnInputGainChanged event is fired, and the device gain value
   // is saved in the preferences.
   const int kGain = 60;
   EXPECT_EQ(kGain, cras_audio_handler_->GetInputGainPercent());
   EXPECT_EQ(1, test_observer_->input_gain_changed_count());
   AudioDevice internal_mic(kInternalMic);
-  EXPECT_EQ(kGain, audio_pref_handler_->GetVolumeGainValue(internal_mic));
+  EXPECT_EQ(kGain, audio_pref_handler_->GetInputGainValue(&internal_mic));
 }
 
 TEST_F(CrasAudioHandlerTest, SetMuteForDevice) {
   AudioNodeList audio_nodes;
   audio_nodes.push_back(kInternalSpeaker);
   audio_nodes.push_back(kHeadphone);
   audio_nodes.push_back(kInternalMic);
   audio_nodes.push_back(kUSBMic);
   SetUpCrasAudioHandler(audio_nodes);
 
@@ skipping 47 matching lines @@
   EXPECT_EQ(kHeadphone.id, cras_audio_handler_->GetActiveOutputNode());
   cras_audio_handler_->SetVolumeGainPercentForDevice(kHeadphone.id,
                                                      kHeadphoneVolume);
 
   // Verify the volume percent of headphone is set, and saved in preferences.
   EXPECT_EQ(kHeadphoneVolume,
             cras_audio_handler_->GetOutputVolumePercentForDevice(
                 kHeadphone.id));
   AudioDevice headphone(kHeadphone);
   EXPECT_EQ(kHeadphoneVolume,
-            audio_pref_handler_->GetVolumeGainValue(headphone));
+            audio_pref_handler_->GetOutputVolumeValue(&headphone));
 
   // Set volume percent for non-active output device.
   const int kSpeakerVolume = 60;
   cras_audio_handler_->SetVolumeGainPercentForDevice(kInternalSpeaker.id,
                                                      kSpeakerVolume);
 
   // Verify the volume percent of speaker is set, and saved in preferences.
   EXPECT_EQ(kSpeakerVolume,
             cras_audio_handler_->GetOutputVolumePercentForDevice(
                 kInternalSpeaker.id));
   AudioDevice speaker(kInternalSpeaker);
   EXPECT_EQ(kSpeakerVolume,
-            audio_pref_handler_->GetVolumeGainValue(speaker));
+            audio_pref_handler_->GetOutputVolumeValue(&speaker));
 
   // Set gain percent for active input device.
   const int kUSBMicGain = 30;
   EXPECT_EQ(kUSBMic.id, cras_audio_handler_->GetActiveInputNode());
   cras_audio_handler_->SetVolumeGainPercentForDevice(kUSBMic.id,
                                                      kUSBMicGain);
 
   // Verify the gain percent of USB mic is set, and saved in preferences.
   EXPECT_EQ(kUSBMicGain,
             cras_audio_handler_->GetOutputVolumePercentForDevice(kUSBMic.id));
   AudioDevice usb_mic(kHeadphone);
   EXPECT_EQ(kUSBMicGain,
-            audio_pref_handler_->GetVolumeGainValue(usb_mic));
+            audio_pref_handler_->GetInputGainValue(&usb_mic));
 
   // Set gain percent for non-active input device.
   const int kInternalMicGain = 60;
   cras_audio_handler_->SetVolumeGainPercentForDevice(kInternalMic.id,
                                                      kInternalMicGain);
 
   // Verify the gain percent of internal mic is set, and saved in preferences.
   EXPECT_EQ(kInternalMicGain,
             cras_audio_handler_->GetOutputVolumePercentForDevice(
                 kInternalMic.id));
   AudioDevice internal_mic(kInternalMic);
   EXPECT_EQ(kInternalMicGain,
-            audio_pref_handler_->GetVolumeGainValue(internal_mic));
+            audio_pref_handler_->GetInputGainValue(&internal_mic));
 }
 
 TEST_F(CrasAudioHandlerTest, HandleOtherDeviceType) {
   const size_t kNumValidAudioDevices = 4;
   AudioNodeList audio_nodes;
   audio_nodes.push_back(kInternalSpeaker);
   audio_nodes.push_back(kOtherTypeOutput);
   audio_nodes.push_back(kInternalMic);
   audio_nodes.push_back(kOtherTypeInput);
   SetUpCrasAudioHandler(audio_nodes);
@@ skipping 12 matching lines @@
   EXPECT_TRUE(cras_audio_handler_->has_alternative_output());
 
   // Ensure the internal microphone has been selected as the active input,
   // and the input device with some random unknown type is handled gracefully.
   AudioDevice active_input;
   EXPECT_EQ(kInternalMic.id, cras_audio_handler_->GetActiveInputNode());
   EXPECT_TRUE(cras_audio_handler_->has_alternative_input());
 }
 
 }  // namespace chromeos