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

chrome/browser/chromeos/audio/audio_mixer_cras.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_cras.h"
 
 #include <cmath>
 #include <cras_client.h>
 #include <unistd.h>
 
@@ skipping 18 matching lines @@
 // Number of seconds that we'll sleep between each connection attempt.
 const int kConnectionRetrySleepSec = 1;
 
 }  // namespace
 
 AudioMixerCras::AudioMixerCras()
     : client_(NULL),
       client_connected_(false),
       volume_percent_(kDefaultVolumePercent),
       is_muted_(false),
+      is_mute_locked_(false),
+      is_capture_muted_(false),
+      is_capture_mute_locked_(false),
       apply_is_pending_(true) {
 }
 
 AudioMixerCras::~AudioMixerCras() {
   if (!thread_.get())
     return;
   DCHECK(MessageLoop::current() != thread_->message_loop());
 
   base::ThreadRestrictions::ScopedAllowIO allow_io_for_thread_join;
   thread_->Stop();
@@ skipping 29 matching lines @@
   if (client_connected_ && !apply_is_pending_)
     thread_->message_loop()->PostTask(FROM_HERE,
         base::Bind(&AudioMixerCras::ApplyState, base::Unretained(this)));
 }
 
 bool AudioMixerCras::IsMuted() {
   base::AutoLock lock(lock_);
   return is_muted_;
 }
 
-void AudioMixerCras::SetMuted(bool muted) {
+void AudioMixerCras::SetMuted(bool mute) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::AutoLock lock(lock_);
-  is_muted_ = muted;
-  if (client_connected_ && !apply_is_pending_)
-    thread_->message_loop()->PostTask(FROM_HERE,
-        base::Bind(&AudioMixerCras::ApplyState, base::Unretained(this)));
+  if (is_mute_locked_) {
+    NOTREACHED() << "Mute has been locked!";
+    return;
+  }
+  is_muted_ = mute;
+  ApplyStateIfNeeded();
+}
+
+bool AudioMixerCras::IsMuteLocked() {
+  base::AutoLock lock(lock_);
+  return is_mute_locked_;
+}
+
+void AudioMixerCras::SetMuteLocked(bool locked) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  base::AutoLock lock(lock_);
+  is_mute_locked_ = locked;
+  ApplyStateIfNeeded();
+}
+
+bool AudioMixerCras::IsCaptureMuted() {
+  base::AutoLock lock(lock_);
+  return is_capture_muted_;
+}
+
+void AudioMixerCras::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 AudioMixerCras::IsCaptureMuteLocked() {
+  base::AutoLock lock(lock_);
+  return is_capture_mute_locked_;
+}
+
+void AudioMixerCras::SetCaptureMuteLocked(bool locked) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  base::AutoLock lock(lock_);
+  is_capture_mute_locked_ = locked;
+  ApplyStateIfNeeded();
 }
 
 void AudioMixerCras::Connect() {
   DCHECK(MessageLoop::current() == thread_->message_loop());
 
   // Create the client structure.
   if (client_ == NULL && cras_client_create(&client_) < 0) {
     LOG(DFATAL) << "cras_client_create() failed";
     return; // TODO(dgreid) change interface so this can return an error.
   }
@@ skipping 14 matching lines @@
 
   ApplyState();
 }
 
 void AudioMixerCras::ApplyState() {
   DCHECK(MessageLoop::current() == thread_->message_loop());
   if (!client_connected_)
     return;
 
   bool should_mute = false;
+  bool should_lock_mute = false;
+  bool should_mute_capture = false;
+  bool should_lock_capture_mute = false;
   size_t new_volume = 0;
   {
     base::AutoLock lock(lock_);
     should_mute = is_muted_;
+    should_lock_mute = is_mute_locked_;
+    should_mute_capture = is_capture_muted_;
+    should_lock_capture_mute = is_capture_mute_locked_;
     new_volume = floor(volume_percent_ + 0.5);
     apply_is_pending_ = false;
   }
 
   // If muting mute before setting volume, if un-muting set volume first.
   if (should_mute) {
     cras_client_set_system_mute(client_, should_mute);
     cras_client_set_system_volume(client_, new_volume);
   } else {
     cras_client_set_system_volume(client_, new_volume);
     cras_client_set_system_mute(client_, should_mute);
   }
+  cras_client_set_system_mute_locked(client_, should_lock_mute);
+  cras_client_set_system_capture_mute(client_, should_mute_capture);
+  cras_client_set_system_capture_mute_locked(client_, should_lock_capture_mute);
+}
+
+void AudioMixerCras::ApplyStateIfNeeded() {
+  lock_.AssertAcquired();
+  if (client_connected_ && !apply_is_pending_) {
+    thread_->message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&AudioMixerCras::ApplyState, base::Unretained(this)));
+  }
 }
 
 }  // namespace chromeos