Detect AudioInputStream muting and propagate to MediaStreamAudioSource.

media/audio/audio_input_controller.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 "media/audio/audio_input_controller.h"
 
 #include <inttypes.h>
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/user_input_monitor.h"
 
 namespace media {
 namespace {
 
 const int kMaxInputChannels = 3;
+constexpr int kCheckMutedStateIntervalSeconds = 1;
 
 #if defined(AUDIO_POWER_MONITORING)
 // Time in seconds between two successive measurements of audio power levels.
 const int kPowerMonitorLogIntervalSeconds = 15;
 
 // A warning will be logged when the microphone audio volume is below this
 // threshold.
 const int kLowLevelMicrophoneLevelPercent = 10;
 
 // Logs if the user has enabled the microphone mute or not. This is normally
@@ skipping 153 matching lines @@
 #endif
       weak_ptr_factory_(this) {
   DCHECK(creator_task_runner_.get());
   DCHECK(handler_);
   DCHECK(sync_writer_);
 }
 
 AudioInputController::~AudioInputController() {
   DCHECK(!audio_callback_);
   DCHECK(!stream_);
+  DCHECK(!check_muted_state_timer_.IsRunning());
 }
 
 // static
 scoped_refptr<AudioInputController> AudioInputController::Create(
     AudioManager* audio_manager,
     EventHandler* event_handler,
     SyncWriter* sync_writer,
     UserInputMonitor* user_input_monitor,
     const AudioParameters& params,
     const std::string& device_id,
@@ skipping 139 matching lines @@
   // functionality to modify the input volume slider. One such example is
   // Windows XP.
   power_measurement_is_enabled_ &= agc_is_supported;
 #else
   stream_to_control->SetAutomaticGainControl(enable_agc);
 #endif
 
   // Finally, keep the stream pointer around, update the state and notify.
   stream_ = stream_to_control;
   handler_->OnCreated(this);
+
+  // Check the current muted state and start the repeating timer to keep that
+  // updated.
+  CheckMutedState();
+  check_muted_state_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromSeconds(kCheckMutedStateIntervalSeconds),
+      this, &AudioInputController::CheckMutedState);
+  DCHECK(check_muted_state_timer_.IsRunning());
 }
 
 void AudioInputController::DoRecord() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.RecordTime");
 
   if (!stream_ || audio_callback_)
     return;
 
   handler_->OnLog(this, "AIC::DoRecord");
 
   if (user_input_monitor_) {
     user_input_monitor_->EnableKeyPressMonitoring();
     prev_key_down_count_ = user_input_monitor_->GetKeyPressCount();
   }
 
   stream_create_time_ = base::TimeTicks::Now();
 
   audio_callback_.reset(new AudioCallback(this));
   stream_->Start(audio_callback_.get());
 }
 
 void AudioInputController::DoClose() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.CloseTime");
 
   if (!stream_)
     return;
 
+  check_muted_state_timer_.Stop();
+
   std::string log_string;
   static const char kLogStringPrefix[] = "AIC::DoClose:";
 
+  // Allow calling unconditionally and bail if we don't have a stream to close.
   if (audio_callback_) {
     stream_->Stop();
 
     // Sometimes a stream (and accompanying audio track) is created and
     // immediately closed or discarded. In this case they are registered as
     // 'stopped early' rather than 'never got data'.
     const base::TimeDelta duration =
         base::TimeTicks::Now() - stream_create_time_;
     CaptureStartupResult capture_startup_result =
         audio_callback_->received_callback()
@@ skipping 255 matching lines @@
   *mic_volume_percent = static_cast<int>(100.0 * volume);
 
   last_audio_level_log_time_ = now;
 
   return true;
 #else
   return false;
 #endif
 }
 
+void AudioInputController::CheckMutedState() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(stream_);
+  const bool new_state = stream_->IsMuted();
+  if (new_state != is_muted_) {
+    is_muted_ = new_state;
+    // We don't log OnMuted here, but leave that for AudioInputRendererHost.
+    handler_->OnMuted(this, is_muted_);
+  }
+}
+
 // static
 AudioInputController::StreamType AudioInputController::ParamsToStreamType(
     const AudioParameters& params) {
   switch (params.format()) {
     case AudioParameters::Format::AUDIO_PCM_LINEAR:
       return AudioInputController::StreamType::HIGH_LATENCY;
     case AudioParameters::Format::AUDIO_PCM_LOW_LATENCY:
       return AudioInputController::StreamType::LOW_LATENCY;
     default:
       // Currently, the remaining supported type is fake. Reconsider if other
       // formats become supported.
       return AudioInputController::StreamType::FAKE;
   }
 }
 
 }  // namespace media