Forward output glitch information from stream WebRTC log

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 <utility>
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 99 matching lines @@
 void LogCaptureStartupResult(CaptureStartupResult result) {
   UMA_HISTOGRAM_ENUMERATION("Media.AudioInputControllerCaptureStartupSuccess",
                             result,
                             CAPTURE_STARTUP_RESULT_MAX + 1);
 
 }
 
 namespace media {
 
 // static
-AudioInputController::Factory* AudioInputController::factory_ = NULL;
+AudioInputController::Factory* AudioInputController::factory_ = nullptr;
 
 AudioInputController::AudioInputController(EventHandler* handler,
                                            SyncWriter* sync_writer,
                                            UserInputMonitor* user_input_monitor,
                                            const bool agc_is_enabled)
     : creator_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       handler_(handler),
-      stream_(NULL),
+      stream_(nullptr),
       data_is_active_(false),
       state_(CLOSED),
       sync_writer_(sync_writer),
       max_volume_(0.0),
       user_input_monitor_(user_input_monitor),
       agc_is_enabled_(agc_is_enabled),
 #if defined(AUDIO_POWER_MONITORING)
       power_measurement_is_enabled_(false),
       log_silence_state_(false),
       silence_state_(SILENCE_STATE_NO_MEASUREMENT),
@@ skipping 10 matching lines @@
 // static
 scoped_refptr<AudioInputController> AudioInputController::Create(
     AudioManager* audio_manager,
     EventHandler* event_handler,
     const AudioParameters& params,
     const std::string& device_id,
     UserInputMonitor* user_input_monitor) {
   DCHECK(audio_manager);
 
   if (!params.IsValid() || (params.channels() > kMaxInputChannels))
-    return NULL;
+    return nullptr;
 
   if (factory_) {
     return factory_->Create(
         audio_manager, event_handler, params, user_input_monitor);
   }
-  scoped_refptr<AudioInputController> controller(
-      new AudioInputController(event_handler, NULL, user_input_monitor, false));
+  scoped_refptr<AudioInputController> controller(new AudioInputController(
+      event_handler, nullptr, user_input_monitor, false));
 
   controller->task_runner_ = audio_manager->GetTaskRunner();
 
   // Create and open a new audio input stream from the existing
   // audio-device thread.
   if (!controller->task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&AudioInputController::DoCreate,
                      controller,
                      base::Unretained(audio_manager),
                      params,
                      device_id))) {
-    controller = NULL;
+    controller = nullptr;
   }
 
   return controller;
 }
 
 // static
 scoped_refptr<AudioInputController> AudioInputController::CreateLowLatency(
     AudioManager* audio_manager,
     EventHandler* event_handler,
     const AudioParameters& params,
     const std::string& device_id,
     SyncWriter* sync_writer,
     UserInputMonitor* user_input_monitor,
     const bool agc_is_enabled) {
   DCHECK(audio_manager);
   DCHECK(sync_writer);
 
   if (!params.IsValid() || (params.channels() > kMaxInputChannels))
-    return NULL;
+    return nullptr;
 
   // Create the AudioInputController object and ensure that it runs on
   // the audio-manager thread.
   scoped_refptr<AudioInputController> controller(new AudioInputController(
       event_handler, sync_writer, user_input_monitor, agc_is_enabled));
   controller->task_runner_ = audio_manager->GetTaskRunner();
 
   // Create and open a new audio input stream from the existing
   // audio-device thread. Use the provided audio-input device.
   if (!controller->task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&AudioInputController::DoCreateForLowLatency,
                      controller,
                      base::Unretained(audio_manager),
                      params,
                      device_id))) {
-    controller = NULL;
+    controller = nullptr;
   }
 
   return controller;
 }
 
 // static
 scoped_refptr<AudioInputController> AudioInputController::CreateForStream(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     EventHandler* event_handler,
     AudioInputStream* stream,
@@ skipping 11 matching lines @@
   // TODO(miu): See TODO at top of file.  Until that's resolved, we need to
   // disable the error auto-detection here (since the audio mirroring
   // implementation will reliably report error and close events).  Note, of
   // course, that we're assuming CreateForStream() has been called for the audio
   // mirroring use case only.
   if (!controller->task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&AudioInputController::DoCreateForStream,
                      controller,
                      stream))) {
-    controller = NULL;
+    controller = nullptr;
   }
 
   return controller;
 }
 
 void AudioInputController::Record() {
   task_runner_->PostTask(FROM_HERE, base::Bind(
       &AudioInputController::DoRecord, this));
 }
 
@@ skipping 23 matching lines @@
   // avoid adding logs and UMA for non-WebRTC clients.
   power_measurement_is_enabled_ = agc_is_enabled_;
   last_audio_level_log_time_ = base::TimeTicks::Now();
   silence_state_ = SILENCE_STATE_NO_MEASUREMENT;
 #endif
 
   // TODO(miu): See TODO at top of file.  Until that's resolved, assume all
   // platform audio input requires the |no_data_timer_| be used to auto-detect
   // errors.  In reality, probably only Windows needs to be treated as
   // unreliable here.
-  DoCreateForStream(audio_manager->MakeAudioInputStream(params, device_id));
+  DoCreateForStream(audio_manager->MakeAudioInputStream(
+      params, device_id, base::Bind(&AudioInputController::LogMessage, this)));
 }
 
 void AudioInputController::DoCreateForLowLatency(AudioManager* audio_manager,
                                                  const AudioParameters& params,
                                                  const std::string& device_id) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
 #if defined(AUDIO_POWER_MONITORING)
   // We only log silence state UMA stats for low latency mode and if we use a
   // real device.
@@ skipping 14 matching lines @@
 
   if (!stream_) {
     if (handler_)
       handler_->OnError(this, STREAM_CREATE_ERROR);
     LogCaptureStartupResult(CAPTURE_STARTUP_CREATE_STREAM_FAILED);
     return;
   }
 
   if (stream_ && !stream_->Open()) {
     stream_->Close();
-    stream_ = NULL;
+    stream_ = nullptr;
     if (handler_)
       handler_->OnError(this, STREAM_OPEN_ERROR);
     LogCaptureStartupResult(CAPTURE_STARTUP_OPEN_STREAM_FAILED);
     return;
   }
 
   DCHECK(!no_data_timer_.get());
 
   // Set AGC state using mode in |agc_is_enabled_| which can only be enabled in
   // CreateLowLatency().
@@ skipping 324 matching lines @@
       FROM_HERE,
       base::Bind(&AudioInputController::DoDisableDebugRecording,
                  this),
       callback);
 }
 
 void AudioInputController::DoStopCloseAndClearStream() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Allow calling unconditionally and bail if we don't have a stream to close.
-  if (stream_ != NULL) {
+  if (stream_ != nullptr) {
     stream_->Stop();
     stream_->Close();
-    stream_ = NULL;
+    stream_ = nullptr;
   }
 
   // The event handler should not be touched after the stream has been closed.
-  handler_ = NULL;
+  handler_ = nullptr;
 }
 
 void AudioInputController::SetDataIsActive(bool enabled) {
   base::subtle::Release_Store(&data_is_active_, enabled);
 }
 
 bool AudioInputController::GetDataIsActive() {
   return (base::subtle::Acquire_Load(&data_is_active_) != false);
 }
 
@@ skipping 39 matching lines @@
   input_writer_ = nullptr;
 }
 
 void AudioInputController::WriteInputDataForDebugging(
     std::unique_ptr<AudioBus> data) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (input_writer_)
     input_writer_->Write(std::move(data));
 }
 
+void AudioInputController::LogMessage(const std::string& message) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  handler_->OnLog(this, message);
+}
+
 }  // namespace media