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 32 matching lines @@
 }
 
 bool AudioMixerCras::IsMuted() {
   base::AutoLock lock(lock_);
   return is_muted_;
 }
 
 void AudioMixerCras::SetMuted(bool muted) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::AutoLock lock(lock_);
+  if (is_mute_locked_) {
+    NOTREACHED() << "Mute has been locked!";
+    return;
+  }
   is_muted_ = muted;
   if (client_connected_ && !apply_is_pending_)
     thread_->message_loop()->PostTask(FROM_HERE,
         base::Bind(&AudioMixerCras::ApplyState, base::Unretained(this)));
 }
 
+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;
+  if (client_connected_ && !apply_is_pending_)
+    thread_->message_loop()->PostTask(FROM_HERE,
+        base::Bind(&AudioMixerCras::ApplyState, base::Unretained(this)));
+}
+
+bool AudioMixerCras::IsCaptureMuted() {
+  base::AutoLock lock(lock_);
+  return is_capture_muted_;
+}
+
+void AudioMixerCras::SetCaptureMuted(bool locked) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  base::AutoLock lock(lock_);
+  if (is_capture_mute_locked_){
+     NOTREACHED() << "Capture mute has been locked!";
+     return;
+   }  is_capture_muted_ = locked;
+  if (client_connected_ && !apply_is_pending_)
+    thread_->message_loop()->PostTask(FROM_HERE,
+        base::Bind(&AudioMixerCras::ApplyState, base::Unretained(this)));
+}
+
+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;
+  if (client_connected_ && !apply_is_pending_)
+    thread_->message_loop()->PostTask(FROM_HERE,
+        base::Bind(&AudioMixerCras::ApplyState, base::Unretained(this)));

[Mattias Nissler (ping if slow), 2012/08/28 12:24:24]

Curlies missing here and above, same comment applies about duplication.

One thing that's not your business but I should ask when I see it: Are there
good reasons to use locks here? Chromium style generally discourages them, since
they may block the UI thread after all. In this case, is it guaranteed that
|thread_| never blocks on I/O? If not, it might be better to just post the
settings to apply as a parameter to the task posted.

[pastarmovj, 2012/08/28 15:11:50]

It is guaranteed that the lock is only held in the other thread to copy the
state to local variables so no IO happens while thread_ is holding the lock. I
think in this case it is relatively safe to use locks. I could make the
ApplyState function accept the state as arguments but I think this is not going
to contribute much to either the responsiveness or readability of this code.

+}
+
 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.
   }
 
   if (cras_client_connect(client_) != 0) {
@@ skipping 12 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);
 }
 
 }  // namespace chromeos