Fix the corner case for new audio device is not selected as active if it is plugged in for the firs…

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 "chromeos/audio/audio_devices_pref_handler_impl.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "chromeos/audio/audio_device.h"
 #include "chromeos/chromeos_pref_names.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 
 namespace {
 
 // Values used for muted preference.
 const int kPrefMuteOff = 0;
 const int kPrefMuteOn = 1;
 
+// Prefs keys.
+const char kActiveKey[] = "active";
+const char kActivateByUserKey[] = "activate_by_user";
+
 // Gets the device id string for storing audio preference. The format of
 // device string is a string consisting of 2 parts.
 // |integer from lower 32 bit of device id| :
 // |0(output device) or 1(input device)|
 // If an audio device has both integrated input and output devices, the first 2
 // parts of the string could be identical, only the last part will differentiate
 // them.
 std::string GetDeviceIdString(const chromeos::AudioDevice& device) {
   std::string device_id_string =
       base::Uint64ToString(device.stable_device_id &
@@ skipping 45 matching lines @@
                                                bool mute) {
   device_mute_settings_->SetInteger(GetDeviceIdString(device),
                                     mute ? kPrefMuteOn : kPrefMuteOff);
   SaveDevicesMutePref();
 }
 
 void AudioDevicesPrefHandlerImpl::SetDeviceActive(const AudioDevice& device,
                                                   bool active,
                                                   bool activate_by_user) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetBoolean("active", active);
+  dict->SetBoolean(kActiveKey, active);
   if (active)
-    dict->SetBoolean("activate_by_user", activate_by_user);
+    dict->SetBoolean(kActivateByUserKey, activate_by_user);
 
   device_state_settings_->Set(GetDeviceIdString(device), std::move(dict));
   SaveDevicesStatePref();
 }
 
 bool AudioDevicesPrefHandlerImpl::GetDeviceActive(const AudioDevice& device,
                                                   bool* active,
                                                   bool* activate_by_user) {
   const std::string device_id_str = GetDeviceIdString(device);
   if (!device_state_settings_->HasKey(device_id_str))
     return false;
 
   base::DictionaryValue* dict = NULL;
   if (!device_state_settings_->GetDictionary(device_id_str, &dict)) {
     LOG(ERROR) << "Could not get device state for device:" << device.ToString();
     return false;
   }
-  if (!dict->GetBoolean("active", active)) {
+  if (!dict->GetBoolean(kActiveKey, active)) {
     LOG(ERROR) << "Could not get active value for device:" << device.ToString();
     return false;
   }
 
-  if (*active && !dict->GetBoolean("activate_by_user", activate_by_user)) {
+  if (*active && !dict->GetBoolean(kActivateByUserKey, activate_by_user)) {
     LOG(ERROR) << "Could not get activate_by_user value for previously "
                   "active device:"
                << device.ToString();
     return false;
   }
 
   return true;
 }
 
 bool AudioDevicesPrefHandlerImpl::GetAudioOutputAllowedValue() {
@@ skipping 128 matching lines @@
   // media system.
   registry->RegisterBooleanPref(prefs::kAudioOutputAllowed, true);
 
   // Register the legacy audio prefs for migration.
   registry->RegisterDoublePref(prefs::kAudioVolumePercent,
                                kDefaultOutputVolumePercent);
   registry->RegisterIntegerPref(prefs::kAudioMute, kPrefMuteOff);
 }
 
 }  // namespace chromeos