chrome: Use base::MessageLoop. (Part 3)

chrome/browser/chromeos/audio/audio_mixer_alsa.cc

 // Copyright (c) 2012 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_mixer_alsa.h"
 
 #include <unistd.h>
 
 #include <alsa/asoundlib.h>
 
@@ skipping 69 matching lines @@
       pcm_element_(NULL),
       mic_element_(NULL),
       front_mic_element_(NULL),
       disconnected_event_(true, false),
       num_connection_attempts_(0) {
 }
 
 AudioMixerAlsa::~AudioMixerAlsa() {
   if (!thread_.get())
     return;
-  DCHECK(MessageLoop::current() != thread_->message_loop());
+  DCHECK(base::MessageLoop::current() != thread_->message_loop());
 
   thread_->message_loop()->PostTask(
       FROM_HERE, base::Bind(&AudioMixerAlsa::Disconnect,
                             base::Unretained(this)));
   {
     // http://crbug.com/125206
     base::ThreadRestrictions::ScopedAllowWait allow_wait;
     disconnected_event_.Wait();
   }
 
@@ skipping 82 matching lines @@
   return is_capture_mute_locked_;
 }
 
 void AudioMixerAlsa::SetCaptureMuteLocked(bool locked) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::AutoLock lock(lock_);
   is_capture_mute_locked_ = locked;
 }
 
 void AudioMixerAlsa::Connect() {
-  DCHECK(MessageLoop::current() == thread_->message_loop());
+  DCHECK(base::MessageLoop::current() == thread_->message_loop());
   DCHECK(!alsa_mixer_);
 
   if (disconnected_event_.IsSignaled())
     return;
 
   // Do not attempt to connect if we're not on the device.
   if (!base::chromeos::IsRunningOnChromeOS())
     return;
 
   if (!ConnectInternal()) {
     thread_->message_loop()->PostDelayedTask(FROM_HERE,
         base::Bind(&AudioMixerAlsa::Connect, base::Unretained(this)),
         base::TimeDelta::FromSeconds(kConnectionRetrySleepSec));
   }
 }
 
 bool AudioMixerAlsa::ConnectInternal() {
-  DCHECK(MessageLoop::current() == thread_->message_loop());
+  DCHECK(base::MessageLoop::current() == thread_->message_loop());
   num_connection_attempts_++;
   int err;
   snd_mixer_t* handle = NULL;
 
   if ((err = snd_mixer_open(&handle, 0)) < 0) {
     if (num_connection_attempts_ == kConnectionAttemptToLogFailure)
       LOG(WARNING) << "Mixer open error: " << snd_strerror(err);
     return false;
   }
 
@@ skipping 100 matching lines @@
     min_volume_db_ = min_volume_db;
     max_volume_db_ = max_volume_db;
     volume_db_ = PercentToDb(initial_volume_percent_);
   }
 
   ApplyState();
   return true;
 }
 
 void AudioMixerAlsa::Disconnect() {
-  DCHECK(MessageLoop::current() == thread_->message_loop());
+  DCHECK(base::MessageLoop::current() == thread_->message_loop());
   if (alsa_mixer_) {
     snd_mixer_close(alsa_mixer_);
     alsa_mixer_ = NULL;
   }
   disconnected_event_.Signal();
 }
 
 void AudioMixerAlsa::ApplyState() {
-  DCHECK(MessageLoop::current() == thread_->message_loop());
+  DCHECK(base::MessageLoop::current() == thread_->message_loop());
   if (!alsa_mixer_)
     return;
 
   bool should_mute = false;
   bool should_mute_capture = false;
   double new_volume_db = 0;
   {
     base::AutoLock lock(lock_);
     should_mute = is_muted_;
     should_mute_capture = is_capture_muted_;
@@ skipping 18 matching lines @@
 
   SetElementMuted(master_element_, should_mute);
   if (mic_element_)
     SetElementMuted(mic_element_, should_mute_capture);
   if (front_mic_element_)
     SetElementMuted(front_mic_element_, should_mute_capture);
 }
 
 snd_mixer_elem_t* AudioMixerAlsa::FindElementWithName(
     snd_mixer_t* handle, const string& element_name) const {
-  DCHECK(MessageLoop::current() == thread_->message_loop());
+  DCHECK(base::MessageLoop::current() == thread_->message_loop());
   snd_mixer_selem_id_t* sid = NULL;
 
   // Using id_malloc/id_free API instead of id_alloca since the latter gives the
   // warning: the address of 'sid' will always evaluate as 'true'.
   if (snd_mixer_selem_id_malloc(&sid))
     return NULL;
 
   snd_mixer_selem_id_set_index(sid, 0);
   snd_mixer_selem_id_set_name(sid, element_name.c_str());
   snd_mixer_elem_t* element = snd_mixer_find_selem(handle, sid);
   if (!element)
     VLOG(1) << "Unable to find control " << snd_mixer_selem_id_get_name(sid);
 
   snd_mixer_selem_id_free(sid);
   return element;
 }
 
 bool AudioMixerAlsa::GetElementVolume(snd_mixer_elem_t* element,
                                       double* current_volume_db) {
-  DCHECK(MessageLoop::current() == thread_->message_loop());
+  DCHECK(base::MessageLoop::current() == thread_->message_loop());
   alsa_long_t long_volume = 0;
   int alsa_result = snd_mixer_selem_get_playback_dB(
       element, static_cast<snd_mixer_selem_channel_id_t>(0), &long_volume);
   if (alsa_result != 0) {
     LOG(WARNING) << "snd_mixer_selem_get_playback_dB() failed: "
                  << snd_strerror(alsa_result);
     return false;
   }
   *current_volume_db = static_cast<double>(long_volume) / 100.0;
   return true;
 }
 
 bool AudioMixerAlsa::SetElementVolume(snd_mixer_elem_t* element,
                                       double new_volume_db,
                                       double rounding_bias) {
-  DCHECK(MessageLoop::current() == thread_->message_loop());
+  DCHECK(base::MessageLoop::current() == thread_->message_loop());
   alsa_long_t volume_low = 0;
   alsa_long_t volume_high = 0;
   int alsa_result = snd_mixer_selem_get_playback_volume_range(
       element, &volume_low, &volume_high);
   if (alsa_result != 0) {
     LOG(WARNING) << "snd_mixer_selem_get_playback_volume_range() failed: "
                  << snd_strerror(alsa_result);
     return false;
   }
   alsa_long_t volume_range = volume_high - volume_low;
@@ skipping 29 matching lines @@
   }
 
   VLOG(1) << "Set volume " << snd_mixer_selem_get_name(element)
           << " to " << new_volume_db << " ==> "
           << (value - volume_low) * db_step + db_low << " dB";
 
   return true;
 }
 
 void AudioMixerAlsa::SetElementMuted(snd_mixer_elem_t* element, bool mute) {
-  DCHECK(MessageLoop::current() == thread_->message_loop());
+  DCHECK(base::MessageLoop::current() == thread_->message_loop());
   int alsa_result = snd_mixer_selem_set_playback_switch_all(element, !mute);
   if (alsa_result != 0) {
     LOG(WARNING) << "snd_mixer_selem_set_playback_switch_all() failed: "
                  << snd_strerror(alsa_result);
   } else {
     VLOG(1) << "Set playback switch " << snd_mixer_selem_get_name(element)
             << " to " << mute;
   }
 }
 
@@ skipping 14 matching lines @@
 void AudioMixerAlsa::ApplyStateIfNeeded() {
   lock_.AssertAcquired();
   if (!apply_is_pending_) {
     thread_->message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&AudioMixerAlsa::ApplyState, base::Unretained(this)));
   }
 }
 
 }  // namespace chromeos