Detect AudioInputStream muting and propagate to MediaStreamAudioSource.

media/audio/audio_input_controller.h

 // 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.
 
 #ifndef MEDIA_AUDIO_AUDIO_INPUT_CONTROLLER_H_
 #define MEDIA_AUDIO_AUDIO_INPUT_CONTROLLER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 
 #include "base/files/file.h"
 #include "base/memory/weak_ptr.h"
+#include "base/optional.h"
 #include "base/single_thread_task_runner.h"
+#include "base/timer/timer.h"
 #include "media/audio/audio_debug_file_writer.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/media_switches.h"
 
 // An AudioInputController controls an AudioInputStream and records data
 // from this input stream. The two main methods are Record() and Close() and
 // they are both executed on the audio thread which is injected by the two
@@ skipping 73 matching lines @@
 
   // An event handler that receives events from the AudioInputController. The
   // following methods are all called on the audio thread.
   class MEDIA_EXPORT EventHandler {
    public:
     virtual void OnCreated(AudioInputController* controller) = 0;
     virtual void OnError(AudioInputController* controller,
                          ErrorCode error_code) = 0;
     virtual void OnLog(AudioInputController* controller,
                        const std::string& message) = 0;
+    // Initially, an AudioInputController is considered not muted. If the
+    // underlying stream is actually muted, an OnMuted callback will follow
+    // shortly after OnCreated. It is also called whenever the muted state of
+    // the underlying stream changes.
+    virtual void OnMuted(AudioInputController* controller, bool is_muted) = 0;
 
    protected:
     virtual ~EventHandler() {}
   };
 
   // A synchronous writer interface used by AudioInputController for
   // synchronous writing.
   class MEDIA_EXPORT SyncWriter {
    public:
     virtual ~SyncWriter() {}
@@ skipping 196 matching lines @@
   // Called on the hw callback thread.
   // Returns true iff average power and mic volume was returned and should
   // be posted to DoLogAudioLevels on the audio thread.
   // Returns false if either power measurements are disabled or aren't needed
   // right now (they're done periodically).
   bool CheckAudioPower(const AudioBus* source,
                        double volume,
                        float* average_power_dbfs,
                        int* mic_volume_percent);
 
+  void CheckMutedState();
+
   static StreamType ParamsToStreamType(const AudioParameters& params);
 
   // Gives access to the task runner of the creating thread.
   scoped_refptr<base::SingleThreadTaskRunner> const creator_task_runner_;
 
   // The task runner of audio-manager thread that this object runs on.
   scoped_refptr<base::SingleThreadTaskRunner> const task_runner_;
 
   // Contains the AudioInputController::EventHandler which receives state
   // notifications from this class.
@@ skipping 24 matching lines @@
 
   // The silence report sent as UMA stat at the end of a session.
   SilenceState silence_state_ = SILENCE_STATE_NO_MEASUREMENT;
 #endif
 
   size_t prev_key_down_count_ = 0;
 
   // Time when the stream started recording.
   base::TimeTicks stream_create_time_;
 
+  bool is_muted_ = false;
+
+  // The timer needs to be destroyed on the correct thread, so we can't leave
+  // that to our destructor.
+  base::Optional<base::RepeatingTimer> check_muted_state_timer_;

[DaleCurtis, 2017/06/15 18:44:00]

Drop Optional in favor of just IsRunning().

[ossu-chromium, 2017/06/20 12:25:15]

I was quite sure I was unable to get the timer to work properly as a regular
member: I was hitting a thread check in the destructor. I've not been able to
replicate it now, though, so I'll put up a version which avoids the Optional,
see if one of the bots find anything.

+
 #if BUILDFLAG(ENABLE_WEBRTC)
   // Used for audio debug recordings. Accessed on audio thread.
   AudioDebugRecordingHelper debug_recording_helper_;
 #endif
 
   class AudioCallback;
   // Holds a pointer to the callback object that receives audio data from
   // the lower audio layer. Valid only while 'recording' (between calls to
   // stream_->Start() and stream_->Stop()).
   // The value of this pointer is only set and read on the audio thread while
@@ skipping 14 matching lines @@
   // The weak_ptr_factory_ and all outstanding weak pointers, are invalidated
   // at the end of DoClose.
   base::WeakPtrFactory<AudioInputController> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioInputController);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_AUDIO_AUDIO_INPUT_CONTROLLER_H_