Stop source and fire MediaStreamTrack ended event if missing audio input callbacks are detected.

media/audio/audio_input_device.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_device.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/callback_forward.h"
 #include "base/macros.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/base/audio_bus.h"
 
 namespace media {
 
+namespace {
+
 // The number of shared memory buffer segments indicated to browser process
 // in order to avoid data overwriting. This number can be any positive number,
 // dependent how fast the renderer process can pick up captured data from
 // shared memory.
-static const int kRequestedSharedMemoryCount = 10;
+const int kRequestedSharedMemoryCount = 10;
+
+// The number of seconds with missing callbacks before we report a capture
+// error. The value is based on that the Mac audio implementation can defer
+// start for 5 seconds when resuming after standby, and has a startup success
+// check 5 seconds after actually starting, where stats is logged. We must allow
+// enough time for this. See AUAudioInputStream::CheckInputStartupSuccess().
+const int kMissingCallbacksTimeBeforeErrorSeconds = 12;
+
+// The interval for checking missing callbacks.
+const int kCheckMissingCallbacksIntervalSeconds = 5;
+
+// How often AudioInputDevice::AudioThreadCallback informs that it has gotten
+// data from the source.
+const int kGotDataCallbackIntervalSeconds = 1;
+
+}  // namespace
 
 // Takes care of invoking the capture callback on the audio thread.
 // An instance of this class is created for each capture stream in
 // OnLowLatencyCreated().
 class AudioInputDevice::AudioThreadCallback
     : public AudioDeviceThread::Callback {
  public:
   AudioThreadCallback(const AudioParameters& audio_parameters,
                       base::SharedMemoryHandle memory,
                       int memory_length,
                       int total_segments,
-                      CaptureCallback* capture_callback);
+                      CaptureCallback* capture_callback,
+                      base::RepeatingClosure got_data_callback);
   ~AudioThreadCallback() override;
 
   void MapSharedMemory() override;
 
   // Called whenever we receive notifications about pending data.
   void Process(uint32_t pending_data) override;
 
  private:
   const double bytes_per_ms_;
   int current_segment_id_;
   uint32_t last_buffer_id_;
   std::vector<std::unique_ptr<media::AudioBus>> audio_buses_;
   CaptureCallback* capture_callback_;
 
+  // Used for informing AudioInputDevice that we have gotten data, i.e. the
+  // stream is alive. |got_data_callback_| is run every
+  // |got_data_callback_interval_in_frames_| frames, calculated from
+  // kGotDataCallbackIntervalSeconds.
+  const int got_data_callback_interval_in_frames_;
+  int frames_since_last_got_data_callback_;
+  base::RepeatingClosure got_data_callback_;
+
   DISALLOW_COPY_AND_ASSIGN(AudioThreadCallback);
 };
 
 AudioInputDevice::AudioInputDevice(
     std::unique_ptr<AudioInputIPC> ipc,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
     : ScopedTaskRunnerObserver(io_task_runner),
       callback_(NULL),
       ipc_(std::move(ipc)),
       state_(IDLE),
       session_id_(0),
       agc_is_enabled_(false),
-      stopping_hack_(false) {
+      stopping_hack_(false),
+      missing_callbacks_detected_(false) {
   CHECK(ipc_);
 
   // The correctness of the code depends on the relative values assigned in the
   // State enum.
   static_assert(IPC_CLOSED < IDLE, "invalid enum value assignment 0");
   static_assert(IDLE < CREATING_STREAM, "invalid enum value assignment 1");
   static_assert(CREATING_STREAM < RECORDING, "invalid enum value assignment 2");
 }
 
 void AudioInputDevice::Initialize(const AudioParameters& params,
@@ skipping 64 matching lines @@
   base::AutoLock auto_lock(audio_thread_lock_);
   // TODO(miu): See TODO in OnStreamCreated method for AudioOutputDevice.
   // Interface changes need to be made; likely, after AudioInputDevice is merged
   // into AudioOutputDevice (http://crbug.com/179597).
   if (stopping_hack_)
     return;
 
   DCHECK(!audio_callback_);
   DCHECK(!audio_thread_);
   audio_callback_.reset(new AudioInputDevice::AudioThreadCallback(
-      audio_parameters_, handle, length, total_segments, callback_));
+      audio_parameters_, handle, length, total_segments, callback_,
+      base::BindRepeating(&AudioInputDevice::SetLastCallbackTimeToNow, this)));
   audio_thread_.reset(new AudioDeviceThread(audio_callback_.get(),
                                             socket_handle, "AudioInputDevice"));
 
   state_ = RECORDING;
   ipc_->RecordStream();
+
+  // Start detecting missing callbacks.
+  SetLastCallbackTimeToNowOnIOThread();
+  check_alive_timer_.Start(
+      FROM_HERE,
+      base::TimeDelta::FromSeconds(kCheckMissingCallbacksIntervalSeconds), this,
+      &AudioInputDevice::CheckIfInputStreamIsAlive);
+  DCHECK(check_alive_timer_.IsRunning());
 }
 
 void AudioInputDevice::OnError() {
   DCHECK(task_runner()->BelongsToCurrentThread());
 
   // Do nothing if the stream has been closed.
   if (state_ < CREATING_STREAM)
     return;
 
   DLOG(WARNING) << "AudioInputDevice::OnStateChanged(ERROR)";
@@ skipping 50 matching lines @@
   }
 
   state_ = CREATING_STREAM;
   ipc_->CreateStream(this, session_id_, audio_parameters_,
                      agc_is_enabled_, kRequestedSharedMemoryCount);
 }
 
 void AudioInputDevice::ShutDownOnIOThread() {
   DCHECK(task_runner()->BelongsToCurrentThread());
 
+  check_alive_timer_.Stop();
+
+  UMA_HISTOGRAM_BOOLEAN("Media.Audio.Capture.DetectedMissingCallbacks",
+                        missing_callbacks_detected_);
+  missing_callbacks_detected_ = false;
+
   // Close the stream, if we haven't already.
   if (state_ >= CREATING_STREAM) {
     ipc_->CloseStream();
     state_ = IDLE;
     agc_is_enabled_ = false;
   }
 
   // We can run into an issue where ShutDownOnIOThread is called right after
   // OnStreamCreated is called in cases where Start/Stop are called before we
   // get the OnStreamCreated callback.  To handle that corner case, we call
@@ skipping 26 matching lines @@
   // We simply store the new AGC setting here. This value will be used when
   // a new stream is initialized and by GetAutomaticGainControl().
   agc_is_enabled_ = enabled;
 }
 
 void AudioInputDevice::WillDestroyCurrentMessageLoop() {
   LOG(ERROR) << "IO loop going away before the input device has been stopped";
   ShutDownOnIOThread();
 }
 
+void AudioInputDevice::CheckIfInputStreamIsAlive() {
+  DCHECK(task_runner()->BelongsToCurrentThread());
+  if (base::TimeTicks::Now() - last_callback_time_ >

[ossu-chromium, 2017/05/24 15:52:00]

nit: Should probably be >=, but I'm not going to enforce it . :)

[Henrik Grunell, 2017/05/24 17:18:10]

Maybe so, maybe so. Everything in this mechanism is low precision anyway, and
the likelihood of hitting equals here...

+      base::TimeDelta::FromSeconds(kMissingCallbacksTimeBeforeErrorSeconds)) {
+    callback_->OnCaptureError("No audio received from audio capture device.");
+    missing_callbacks_detected_ = true;
+  }
+}
+
+void AudioInputDevice::SetLastCallbackTimeToNow() {
+  task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&AudioInputDevice::SetLastCallbackTimeToNowOnIOThread, this));
+}
+
+void AudioInputDevice::SetLastCallbackTimeToNowOnIOThread() {
+  last_callback_time_ = base::TimeTicks::Now();
+}
+
 // AudioInputDevice::AudioThreadCallback
 AudioInputDevice::AudioThreadCallback::AudioThreadCallback(
     const AudioParameters& audio_parameters,
     base::SharedMemoryHandle memory,
     int memory_length,
     int total_segments,
-    CaptureCallback* capture_callback)
+    CaptureCallback* capture_callback,
+    base::RepeatingClosure got_data_callback_)
     : AudioDeviceThread::Callback(audio_parameters,
                                   memory,
                                   memory_length,
                                   total_segments),
       bytes_per_ms_(static_cast<double>(audio_parameters.GetBytesPerSecond()) /
                     base::Time::kMillisecondsPerSecond),
       current_segment_id_(0),
       last_buffer_id_(UINT32_MAX),
-      capture_callback_(capture_callback) {}
+      capture_callback_(capture_callback),
+      got_data_callback_interval_in_frames_(kGotDataCallbackIntervalSeconds *
+                                            audio_parameters.sample_rate()),
+      frames_since_last_got_data_callback_(0),
+      got_data_callback_(std::move(got_data_callback_)) {}
 
 AudioInputDevice::AudioThreadCallback::~AudioThreadCallback() {
 }
 
 void AudioInputDevice::AudioThreadCallback::MapSharedMemory() {
   shared_memory_.Map(memory_length_);
 
   // Create vector of audio buses by wrapping existing blocks of memory.
   uint8_t* ptr = static_cast<uint8_t*>(shared_memory_.memory());
   for (int i = 0; i < total_segments_; ++i) {
@@ skipping 37 matching lines @@
         "Segment id not matching. Remote = %u. Local = %d.",
         pending_data, current_segment_id_);
     LOG(ERROR) << message;
     capture_callback_->OnCaptureError(message);
   }
   last_buffer_id_ = buffer->params.id;
 
   // Use pre-allocated audio bus wrapping existing block of shared memory.
   media::AudioBus* audio_bus = audio_buses_[current_segment_id_].get();
 
+  // Regularly inform that we have gotten data.
+  frames_since_last_got_data_callback_ += audio_bus->frames();
+  if (frames_since_last_got_data_callback_ >=
+      got_data_callback_interval_in_frames_) {
+    got_data_callback_.Run();
+    frames_since_last_got_data_callback_ = 0;
+  }
+
   // Deliver captured data to the client in floating point format and update
   // the audio delay measurement.
   capture_callback_->Capture(
       audio_bus,
       buffer->params.hardware_delay_bytes / bytes_per_ms_,  // Delay in ms
       buffer->params.volume, buffer->params.key_pressed);
 
   if (++current_segment_id_ >= total_segments_)
     current_segment_id_ = 0;
 }
 
 }  // namespace media