Set up hdmi output device default volume to 100.

chrome/browser/chromeos/audio/audio_devices_pref_handler_impl.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 "chrome/browser/chromeos/audio/audio_devices_pref_handler_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/audio/audio_device.h"
-#include "chromeos/audio/cras_audio_handler.h"
 
 namespace {
 
+const double kDefaultOutputVolume = 75.0;
+const double kDefaultHDMIOutputVolume = 100.0;
+
+// Values used for muted preference.
+const int kPrefMuteOff = 0;
+const int kPrefMuteOn = 1;
+
 std::string GetDeviceIdString(const chromeos::AudioDevice& device) {
   return device.device_name + " : " +
          base::Uint64ToString(device.id & static_cast<uint64>(0xffffffff));
 }
 
-}
+}  // namespace
 
 namespace chromeos {
 
-double AudioDevicesPrefHandlerImpl::GetVolumeGainValue(
-    const AudioDevice& device) {
-  UpdateDevicesVolumePref();
+double AudioDevicesPrefHandlerImpl::GetOutputVolumeValue(
+    const AudioDevice* device) {
+  if (!device)
+    return kDefaultOutputVolume;
+  else
+    return GetVolumeGainPrefValue(*device);
+}
 
-  std::string device_id_str = GetDeviceIdString(device);
-  if (!device_volume_settings_->HasKey(device_id_str))
-    MigrateDeviceVolumeSettings(device_id_str);
-
-  double volume = kDefaultVolumeGainPercent;
-  device_volume_settings_->GetDouble(device_id_str, &volume);
-
-  return volume;
+double AudioDevicesPrefHandlerImpl::GetInputGainValue(
+    const AudioDevice* device) {
+  DCHECK(device);
+  return GetVolumeGainPrefValue(*device);
 }
 
 void AudioDevicesPrefHandlerImpl::SetVolumeGainValue(
     const AudioDevice& device, double value) {
   device_volume_settings_->SetDouble(GetDeviceIdString(device), value);
 
   SaveDevicesVolumePref();
 }
 
 bool AudioDevicesPrefHandlerImpl::GetMuteValue(const AudioDevice& device) {
@@ skipping 28 matching lines @@
 void AudioDevicesPrefHandlerImpl::AddAudioPrefObserver(
     AudioPrefObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void AudioDevicesPrefHandlerImpl::RemoveAudioPrefObserver(
     AudioPrefObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
+double AudioDevicesPrefHandlerImpl::GetVolumeGainPrefValue(
+    const AudioDevice& device) {
+  UpdateDevicesVolumePref();
+
+  std::string device_id_str = GetDeviceIdString(device);
+  if (!device_volume_settings_->HasKey(device_id_str))
+    MigrateDeviceVolumeSettings(device_id_str);
+
+  // TODO(jennyz, rkc): Return a meaningful input gain default value, when
+  // cras has added support for normalizing input gain range.
+  double value = device.is_input ?
+      0.0 : GetDeviceDefaultOutputVolume(device);
+  device_volume_settings_->GetDouble(device_id_str, &value);
+
+  return value;
+}
+
+double AudioDevicesPrefHandlerImpl::GetDeviceDefaultOutputVolume(
+    const AudioDevice& device) {
+  if (device.type == AUDIO_TYPE_HDMI)
+    return kDefaultHDMIOutputVolume;
+  else
+    return kDefaultOutputVolume;
+}
+
 AudioDevicesPrefHandlerImpl::AudioDevicesPrefHandlerImpl(
     PrefService* local_state)
     : device_mute_settings_(new base::DictionaryValue()),
       device_volume_settings_(new base::DictionaryValue()),
       local_state_(local_state) {
   InitializePrefObservers();
 
   UpdateDevicesMutePref();
   UpdateDevicesVolumePref();
 }
@@ skipping 33 matching lines @@
       local_state_->GetDictionary(prefs::kAudioDevicesVolumePercent);
   if (volume_prefs)
     device_volume_settings_.reset(volume_prefs->DeepCopy());
 }
 
 void AudioDevicesPrefHandlerImpl::SaveDevicesVolumePref() {
   DictionaryPrefUpdate dict_update(local_state_,
                                    prefs::kAudioDevicesVolumePercent);
   base::DictionaryValue::Iterator it(*device_volume_settings_);
   while (!it.IsAtEnd()) {
-    double volume = kDefaultVolumeGainPercent;
-    it.value().GetAsDouble(&volume);
+    double volume = kDefaultOutputVolume;
+    bool success = it.value().GetAsDouble(&volume);
+    DCHECK(success);
     dict_update->SetDouble(it.key(), volume);
     it.Advance();
   }
 }
 
 void AudioDevicesPrefHandlerImpl::MigrateDeviceMuteSettings(
     std::string active_device) {
   int old_mute = local_state_->GetInteger(prefs::kAudioMute);
   device_mute_settings_->SetInteger(active_device, old_mute);
   SaveDevicesMutePref();
@@ skipping 18 matching lines @@
   registry->RegisterDictionaryPref(prefs::kAudioDevicesMute);
 
   // Register the prefs backing the audio muting policies.
   registry->RegisterBooleanPref(prefs::kAudioOutputAllowed, true);
   // This pref has moved to the media subsystem but we should verify it is there
   // before we use it.
   registry->RegisterBooleanPref(::prefs::kAudioCaptureAllowed, true);
 
   // Register the legacy audio prefs for migration.
   registry->RegisterDoublePref(prefs::kAudioVolumePercent,
-                               kDefaultVolumeGainPercent);
+                               kDefaultOutputVolume);
   registry->RegisterIntegerPref(prefs::kAudioMute, kPrefMuteOff);
 }
 
 // static
 AudioDevicesPrefHandler* AudioDevicesPrefHandler::Create(
     PrefService* local_state) {
   return new AudioDevicesPrefHandlerImpl(local_state);
 }
 
 }  // namespace chromeos