Audio input debug recording refactoring to reduce thread hops and simplify object ownership

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 <algorithm>
 #include <limits>
 #include <utility>
 
@@ skipping 67 matching lines @@
 }
 #endif  // AUDIO_POWER_MONITORING
 
 }  // namespace
 
 namespace media {
 
 // static
 AudioInputController::Factory* AudioInputController::factory_ = nullptr;
 
-AudioInputController::AudioInputController(EventHandler* handler,
-                                           SyncWriter* sync_writer,
-                                           UserInputMonitor* user_input_monitor,
-                                           const bool agc_is_enabled)
+AudioInputController::AudioInputController(
+    EventHandler* handler,
+    SyncWriter* sync_writer,
+    std::unique_ptr<AudioInputWriter> debug_writer,
+    UserInputMonitor* user_input_monitor,
+    const bool agc_is_enabled)
     : creator_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       handler_(handler),
       stream_(nullptr),
       should_report_stats(0),
       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),
 #endif
       prev_key_down_count_(0),
-      input_writer_(nullptr) {
+      debug_writer_(std::move(debug_writer)) {
   DCHECK(creator_task_runner_.get());
 }
 
 AudioInputController::~AudioInputController() {
   DCHECK_EQ(state_, CLOSED);
 }
 
 // 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 nullptr;
 
   if (factory_) {
     return factory_->Create(
         audio_manager, event_handler, params, user_input_monitor);
   }
   scoped_refptr<AudioInputController> controller(new AudioInputController(
-      event_handler, nullptr, user_input_monitor, false));
+      event_handler, nullptr, 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 = 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,
+    std::unique_ptr<AudioInputWriter> debug_writer,
     UserInputMonitor* user_input_monitor,
     const bool agc_is_enabled) {
   DCHECK(audio_manager);
   DCHECK(sync_writer);
 
   if (!params.IsValid() || (params.channels() > kMaxInputChannels))
     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));
+      event_handler, sync_writer, std::move(debug_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 = nullptr;
   }
 
   return controller;
 }
 
 // static
 scoped_refptr<AudioInputController> AudioInputController::CreateForStream(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     EventHandler* event_handler,
     AudioInputStream* stream,
     SyncWriter* sync_writer,
+    std::unique_ptr<AudioInputWriter> debug_writer,
     UserInputMonitor* user_input_monitor) {
   DCHECK(sync_writer);
   DCHECK(stream);
 
   // 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, false));
+      event_handler, sync_writer, std::move(debug_writer), user_input_monitor,
+      false));
   controller->task_runner_ = task_runner;
 
   if (!controller->task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&AudioInputController::DoCreateForStream,
                      controller,
                      stream))) {
     controller = nullptr;
   }
 
@@ skipping 156 matching lines @@
   if (user_input_monitor_)
     user_input_monitor_->DisableKeyPressMonitoring();
 
 #if defined(AUDIO_POWER_MONITORING)
   // Send UMA stats if enabled.
   if (log_silence_state_)
     LogSilenceState(silence_state_);
   log_silence_state_ = false;
 #endif
 
-  input_writer_ = nullptr;
+  if (debug_writer_)
+    debug_writer_->Stop();
 
   state_ = CLOSED;
 }
 
 void AudioInputController::DoReportError() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (handler_)
     handler_->OnError(this, STREAM_ERROR);
 }
 
@@ skipping 17 matching lines @@
   }
 
   // Set the stream volume and scale to a range matched to the platform.
   stream_->SetVolume(max_volume_ * volume);
 }
 
 void AudioInputController::OnData(AudioInputStream* stream,
                                   const AudioBus* source,
                                   uint32_t hardware_delay_bytes,
                                   double volume) {
-  // |input_writer_| should only be accessed on the audio thread, but as a means
-  // to avoid copying data and posting on the audio thread, we just check for
-  // non-null here.
-  if (input_writer_) {
+  if (debug_writer_ && debug_writer_->WillWrite()) {
     std::unique_ptr<AudioBus> source_copy =
         AudioBus::Create(source->channels(), source->frames());
     source->CopyTo(source_copy.get());
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(
             &AudioInputController::WriteInputDataForDebugging,
             this,
             base::Passed(&source_copy)));
   }
@@ skipping 108 matching lines @@
 #endif
 }
 
 void AudioInputController::OnError(AudioInputStream* stream) {
   // Handle error on the audio-manager thread.
   task_runner_->PostTask(FROM_HERE, base::Bind(
       &AudioInputController::DoReportError, this));
 }
 
 void AudioInputController::EnableDebugRecording(
-    AudioInputWriter* input_writer) {
-  task_runner_->PostTask(FROM_HERE, base::Bind(
-      &AudioInputController::DoEnableDebugRecording,
-      this,
-      input_writer));
+    const base::FilePath& file_name) {
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&AudioInputController::DoEnableDebugRecording, this,
+                            file_name));
 }
 
-void AudioInputController::DisableDebugRecording(
-    const base::Closure& callback) {
+void AudioInputController::DisableDebugRecording() {
   DCHECK(creator_task_runner_->BelongsToCurrentThread());
-  DCHECK(!callback.is_null());
-
-  task_runner_->PostTaskAndReply(
+  task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&AudioInputController::DoDisableDebugRecording,
-                 this),
-      callback);
+      base::Bind(&AudioInputController::DoDisableDebugRecording, this));
 }
 
 void AudioInputController::DoStopCloseAndClearStream() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Allow calling unconditionally and bail if we don't have a stream to close.
   if (stream_ != nullptr) {
     stream_->Stop();
     stream_->Close();
     stream_ = nullptr;
@@ skipping 40 matching lines @@
   // after initialization. To avoid underflow, we
   // also check if should_report_stats is one before decrementing.
   if (base::AtomicRefCountIsOne(&should_report_stats) &&
       !base::AtomicRefCountDec(&should_report_stats)) {
     UMA_HISTOGRAM_ENUMERATION("Media.AudioInputControllerCaptureStartupSuccess",
                               result, CAPTURE_STARTUP_RESULT_MAX + 1);
   }
 }
 
 void AudioInputController::DoEnableDebugRecording(
-    AudioInputWriter* input_writer) {
+    const base::FilePath& file_name) {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK(!input_writer_);
-  input_writer_ = input_writer;
+  if (debug_writer_)
+    debug_writer_->Start(file_name);
 }
 
 void AudioInputController::DoDisableDebugRecording() {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  input_writer_ = nullptr;
+  if (debug_writer_)
+    debug_writer_->Stop();
 }
 
 void AudioInputController::WriteInputDataForDebugging(
     std::unique_ptr<AudioBus> data) {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  if (input_writer_)
-    input_writer_->Write(std::move(data));
+  if (debug_writer_)
+    debug_writer_->Write(std::move(data));
 }
 
 void AudioInputController::LogMessage(const std::string& message) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   handler_->OnLog(this, message);
 }
 
 }  // namespace media