Update AudioMixerAlsa to not use PrefMember.

chrome/browser/chromeos/audio_mixer_alsa.cc

 // Copyright (c) 2010 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_mixer_alsa.h"
 
 #include <alsa/asoundlib.h>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 29 matching lines @@
 
 }  // namespace
 
 AudioMixerAlsa::AudioMixerAlsa()
     : min_volume_(kDefaultMinVolume),
       max_volume_(kDefaultMaxVolume),
       save_volume_(0),
       mixer_state_(UNINITIALIZED),
       alsa_mixer_(NULL),
       elem_master_(NULL),
-      elem_pcm_(NULL) {
+      elem_pcm_(NULL),
+      prefs_(NULL) {
 }
 
 AudioMixerAlsa::~AudioMixerAlsa() {
   FreeAlsaMixer();
   if (thread_ != NULL) {
     // A ScopedAllowIO object is required to join the thread when calling Stop.
     // The worker thread should be idle at this time.
     // See http://crosbug.com/11110 for discussion.
     base::ThreadRestrictions::ScopedAllowIO allow_io_for_thread_join;
     thread_->message_loop()->AssertIdle();
@@ skipping 44 matching lines @@
   return true;
 }
 
 void AudioMixerAlsa::SetVolumeDb(double vol_db) {
   base::AutoLock lock(mixer_state_lock_);
   if (mixer_state_ != READY)
     return;
   if (vol_db < kSilenceDb)
     vol_db = kSilenceDb;
   DoSetVolumeDb_Locked(vol_db);
-  volume_pref_.SetValue(vol_db);
+  prefs_->SetDouble(prefs::kAudioVolume, vol_db);
 }
 
 bool AudioMixerAlsa::IsMute() const {
   base::AutoLock lock(mixer_state_lock_);
   if (mixer_state_ != READY)
     return false;
   return GetElementMuted_Locked(elem_master_);
 }
 
 // To indicate the volume is not valid yet, a very low volume value is stored.
@@ skipping 21 matching lines @@
       save_volume_ = DoGetVolumeDb_Locked();
       DoSetVolumeDb_Locked(min_volume_);
     } else {
       DoSetVolumeDb_Locked(save_volume_);
     }
   }
 
   SetElementMuted_Locked(elem_master_, mute);
   if (elem_pcm_)
     SetElementMuted_Locked(elem_pcm_, mute);
-  mute_pref_.SetValue(mute ? kPrefMuteOn : kPrefMuteOff);
+  prefs_->SetInteger(prefs::kAudioMute, mute ? kPrefMuteOn : kPrefMuteOff);
 }
 
 AudioMixer::State AudioMixerAlsa::GetState() const {
   base::AutoLock lock(mixer_state_lock_);
   // If we think it's ready, verify it is actually so.
   if ((mixer_state_ == READY) && (alsa_mixer_ == NULL))
     mixer_state_ = IN_ERROR;
   return mixer_state_;
 }
 
@@ skipping 35 matching lines @@
       thread_.reset();
       return false;
     }
   }
 
   mixer_state_ = INITIALIZING;
   return true;
 }
 
 void AudioMixerAlsa::InitPrefs() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  PrefService* prefs = g_browser_process->local_state();
-  volume_pref_.Init(prefs::kAudioVolume, prefs, NULL);
-  mute_pref_.Init(prefs::kAudioMute, prefs, NULL);
+  prefs_ = g_browser_process->local_state();
 }
 
 bool AudioMixerAlsa::InitializeAlsaMixer() {
   base::AutoLock lock(mixer_state_lock_);
   if (mixer_state_ != INITIALIZING)
     return false;
 
   int err;
   snd_mixer_t* handle = NULL;
   const char* card = "default";
@@ skipping 88 matching lines @@
   }
 
   SetElementMuted_Locked(elem_master_, mute);
   if (elem_pcm_)
     SetElementMuted_Locked(elem_pcm_, mute);
 }
 
 void AudioMixerAlsa::RestoreVolumeMuteOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // This happens during init, so set the volume off the UI thread.
+  int mute = prefs_->GetInteger(prefs::kAudioMute);
+  double volume = prefs_->GetDouble(prefs::kAudioVolume);
   thread_->message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &AudioMixerAlsa::DoSetVolumeMute,
-                        volume_pref_.GetValue(), mute_pref_.GetValue()));
+      NewRunnableMethod(this, &AudioMixerAlsa::DoSetVolumeMute, volume, mute));
 }
 
 double AudioMixerAlsa::DoGetVolumeDb_Locked() const {
   double vol_total = 0.0;
   GetElementVolume_Locked(elem_master_, &vol_total);
 
   double vol_pcm = 0.0;
   if (elem_pcm_ && (GetElementVolume_Locked(elem_pcm_, &vol_pcm)))
     vol_total += vol_pcm;
 
@@ skipping 103 matching lines @@
 
 void AudioMixerAlsa::SetElementMuted_Locked(snd_mixer_elem_t* elem, bool mute) {
   int enabled = mute ? 0 : 1;
   snd_mixer_selem_set_playback_switch_all(elem, enabled);
 
   VLOG(1) << "Set playback switch " << snd_mixer_selem_get_name(elem)
           << " to " << enabled;
 }
 
 }  // namespace chromeos