Implement two new policies to control muting the audio I/O.

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 23 matching lines @@
 const char kCardName[] = "default";
 
 // Mixer element names.  We'll use the first master element from the list that
 // exists.
 const char* const kMasterElementNames[] = {
   "Master",   // x86
   "Digital",  // ARM
 };
 const char kPCMElementName[] = "PCM";
 
+const char kMicElementName[] = "Mic";
+const char kFrontMicElementName[] = "Front Mic";
+
 // Default minimum and maximum volume (before we've loaded the actual range from
 // ALSA), in decibels.
 const double kDefaultMinVolumeDb = -90.0;
 const double kDefaultMaxVolumeDb = 0.0;
 
 // Default volume as a percentage in the range [0.0, 100.0].
 const double kDefaultVolumePercent = 75.0;
 
 // A value of less than 1.0 adjusts quieter volumes in larger steps (giving
 // finer resolution in the higher volumes).
@@ skipping 15 matching lines @@
 
 AudioMixerAlsa::AudioMixerAlsa()
     : min_volume_db_(kDefaultMinVolumeDb),
       max_volume_db_(kDefaultMaxVolumeDb),
       volume_db_(kDefaultMinVolumeDb),
       is_muted_(false),
       apply_is_pending_(true),
       initial_volume_percent_(kDefaultVolumePercent),
       alsa_mixer_(NULL),
       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());
 
   thread_->message_loop()->PostTask(
@@ skipping 31 matching lines @@
 
   if (isnan(percent))
     percent = 0.0;
   percent = std::max(std::min(percent, 100.0), 0.0);
 
   base::AutoLock lock(lock_);
   if (!alsa_mixer_) {
     initial_volume_percent_ = percent;
   } else {
     volume_db_ = PercentToDb(percent);
-    if (!apply_is_pending_)
-      thread_->message_loop()->PostTask(FROM_HERE,
-          base::Bind(&AudioMixerAlsa::ApplyState, base::Unretained(this)));
+    ApplyStateIfNeeded();
   }
 }
 
 bool AudioMixerAlsa::IsMuted() {
   base::AutoLock lock(lock_);
   return is_muted_;
 }
 
-void AudioMixerAlsa::SetMuted(bool muted) {
+void AudioMixerAlsa::SetMuted(bool mute) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::AutoLock lock(lock_);
-  is_muted_ = muted;
-  if (!apply_is_pending_)
-    thread_->message_loop()->PostTask(FROM_HERE,
-        base::Bind(&AudioMixerAlsa::ApplyState, base::Unretained(this)));
+  if (is_mute_locked_) {
+    NOTREACHED() << "Capture mute has been locked!";
+    return;
+  }
+  is_muted_ = mute;
+  ApplyStateIfNeeded();
+}
+
+bool AudioMixerAlsa::IsMuteLocked() {
+  base::AutoLock lock(lock_);
+  return is_mute_locked_;
+}
+
+void AudioMixerAlsa::SetMuteLocked(bool locked) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  base::AutoLock lock(lock_);
+  is_mute_locked_ = locked;
+}
+
+bool AudioMixerAlsa::IsCaptureMuted() {
+  base::AutoLock lock(lock_);
+  return is_capture_muted_;
+}
+
+void AudioMixerAlsa::SetCaptureMuted(bool mute) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  base::AutoLock lock(lock_);
+  if (is_capture_mute_locked_) {
+    NOTREACHED() << "Capture mute has been locked!";
+    return;
+  }
+  is_capture_muted_ = mute;
+  ApplyStateIfNeeded();
+}
+
+bool AudioMixerAlsa::IsCaptureMuteLocked() {
+  base::AutoLock lock(lock_);
+  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(!alsa_mixer_);
 
   if (disconnected_event_.IsSignaled())
     return;
 
   // Do not attempt to connect if we're not on the device.
@@ skipping 101 matching lines @@
                      << kPCMElementName << ": " << snd_strerror(err);
       snd_mixer_close(handle);
       return false;
     }
     min_volume_db += static_cast<double>(long_low) / 100.0;
     max_volume_db += static_cast<double>(long_high) / 100.0;
   }
 
   VLOG(1) << "Volume range is " << min_volume_db << " dB to "
           << max_volume_db << " dB";
+
+  snd_mixer_elem_t* mic_element = FindElementWithName(handle, kMicElementName);
+  snd_mixer_elem_t* front_mic_element =
+      FindElementWithName(handle, kFrontMicElementName);
   {
     base::AutoLock lock(lock_);
     alsa_mixer_ = handle;
     master_element_ = master_element;
     pcm_element_ = pcm_element;
+    mic_element_ = mic_element;
+    front_mic_element_ = front_mic_element;
     min_volume_db_ = min_volume_db;
     max_volume_db_ = max_volume_db;
     volume_db_ = PercentToDb(initial_volume_percent_);
   }
 
   // The speech synthesis service shouldn't be initialized until after
   // we get to this point, so we call this function to tell it that it's
   // safe to do TTS now.  NotificationService would be cleaner,
   // but it's not available at this point.
   EnableChromeOsTts();
@@ skipping 10 matching lines @@
   }
   disconnected_event_.Signal();
 }
 
 void AudioMixerAlsa::ApplyState() {
   DCHECK(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_;
     new_volume_db = should_mute ? min_volume_db_ : volume_db_;
     apply_is_pending_ = false;
   }
 
   if (pcm_element_) {
     // If a PCM volume slider exists, then first set the Master volume to the
     // nearest volume >= requested volume, then adjust PCM volume down to get
     // closer to the requested volume.
     SetElementVolume(master_element_, new_volume_db, 0.9999f);
 
     double pcm_volume_db = 0.0;
     double master_volume_db = 0.0;
     if (GetElementVolume(master_element_, &master_volume_db))
       pcm_volume_db = new_volume_db - master_volume_db;
     SetElementVolume(pcm_element_, pcm_volume_db, 0.5f);
   } else {
     SetElementVolume(master_element_, new_volume_db, 0.5f);
   }
 
   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());
   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))
@@ skipping 95 matching lines @@
   return 100.0 * pow((db - min_volume_db_) /
       (max_volume_db_ - min_volume_db_), 1/kVolumeBias);
 }
 
 double AudioMixerAlsa::PercentToDb(double percent) const {
   lock_.AssertAcquired();
   return pow(percent / 100.0, kVolumeBias) *
       (max_volume_db_ - min_volume_db_) + min_volume_db_;
 }
 
+void AudioMixerAlsa::ApplyStateIfNeeded() {
+  lock_.AssertAcquired();
+  if (!apply_is_pending_) {
+    thread_->message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&AudioMixerAlsa::ApplyState, base::Unretained(this)));
+  }
+}
+
 }  // namespace chromeos