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 307 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 a repeating timer to keep that
+  // updated.
+  CheckMutedState();
+  check_muted_state_timer_.reset(new base::RepeatingTimer());

[Max Morin, 2017/06/02 09:56:04]

If you use unique_ptr, most Chromium people prefer base::MakeUnique over raw new
calls for allocating memory. Up to you though.

[Guido Urdaneta, 2017/06/02 13:33:45]

MakeUnique is strongly preferred over raw new, but you can alsop switch to a
regular object.

+  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;
 
+  // Stop the muted check timer.
+  // TODO(ossu): Can't we just reset() it here? Should stop automatically, IIUC.

[Max Morin, 2017/06/02 09:56:04]

Looking at the implementation, yes. Would be nice to have that documented in
timer.h if you want to use it, though.

[ossu-chromium, 2017/06/02 10:48:00]

The top of timer.h says:
"OneShotTimer and RepeatingTimer both cancel the timer when they go out of
scope, which makes it easy to ensure that you do not get called when your object
has gone out of scope."

But this is how we've used it elsewhere. Looking at it again, I'm not sure why
we recreate the timer at all. Can it not just be a member variable and
started/stopped on Create() and Close()?

[Guido Urdaneta, 2017/06/02 13:33:45]

There are also many uses in the codebase that just call reset() without calling
Stop().

+  if (check_muted_state_timer_ != nullptr) {
+    check_muted_state_timer_->Stop();
+    check_muted_state_timer_.reset();
+  }
+
   // 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 =
@@ skipping 76 matching lines @@
 #if defined(AUDIO_POWER_MONITORING)
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (!stream_)
     return;
 
   // Detect if the user has enabled hardware mute by pressing the mute
   // button in audio settings for the selected microphone.
   const bool microphone_is_muted = stream_->IsMuted();
   if (microphone_is_muted) {
     LogMicrophoneMuteResult(MICROPHONE_IS_MUTED);
     handler_->OnLog(this, "AIC::OnData: microphone is muted!");

[Max Morin, 2017/06/02 09:56:04]

If you log it elsewhere, maybe remove this log?

[ossu-chromium, 2017/06/02 10:48:00]

I think it's probably good to keep this one, since it's directly related to the
periodic audio power logging. Makes it that much easier to figure out why
there's no audio, rather than looking for the separate muted message.

     // Return early if microphone is muted. No need to adding logs and UMA stats
     // of audio levels if we know that the micropone is muted.
     return;
   }
 
   LogMicrophoneMuteResult(MICROPHONE_IS_NOT_MUTED);
 
   std::string log_string = base::StringPrintf(
       "AIC::OnData: average audio level=%.2f dBFS", level_dbfs);
   static const float kSilenceThresholdDBFS = -72.24719896f;
@@ skipping 153 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;
+    // Don't log this here, AudioInputRendererHost will log instead.

[Max Morin, 2017/06/02 09:56:04]

Does AIRH actually log this?

[ossu-chromium, 2017/06/02 10:48:00]

Aww, shucks. It did until I removed that. I think that, since we're delegating
the logging to that class anyways, we might as well log this there directly,
rather than imposing a second PostTask etc. just to get the message out. Will
add it back in in AIRH::DoNotifyMutedState.

+    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