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

content/browser/renderer_host/media/audio_input_renderer_host.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 "content/browser/renderer_host/media/audio_input_renderer_host.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 33 matching lines @@
 void LogMessage(int stream_id, const std::string& msg, bool add_prefix) {
   std::ostringstream oss;
   oss << "[stream_id=" << stream_id << "] ";
   if (add_prefix)
     oss << "AIRH::";
   oss << msg;
   content::MediaStreamManager::SendMessageToNativeLog(oss.str());
   DVLOG(1) << oss.str();
 }
 
-#ifdef ENABLE_WEBRTC
-base::File CreateDebugRecordingFile(base::FilePath file_path) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
-  base::File recording_file(
-      file_path, base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
-  PLOG_IF(ERROR, !recording_file.IsValid())
-      << "Could not open debug recording file, error="
-      << recording_file.error_details();
-  return recording_file;
-}
-
-void CloseFile(base::File file) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
-  // |file| must be closed and destroyed on FILE thread.
-}
-
-void DeleteInputDebugWriterOnFileThread(
-    std::unique_ptr<AudioInputDebugWriter> writer) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
-  // |writer| must be closed and destroyed on FILE thread.
-}
-#endif  // ENABLE_WEBRTC
-
 }  // namespace
 
 struct AudioInputRendererHost::AudioEntry {
   AudioEntry();
   ~AudioEntry();
 
   // The AudioInputController that manages the audio input stream.
   scoped_refptr<media::AudioInputController> controller;
 
   // The audio input stream ID in the RenderFrame.
   int stream_id;
 
   // Shared memory for transmission of the audio data. It has
   // |shared_memory_segment_count| equal lengthed segments.
   base::SharedMemory shared_memory;
   int shared_memory_segment_count;
 
   // The synchronous writer to be used by the controller. We have the
   // ownership of the writer.
   std::unique_ptr<AudioInputSyncWriter> writer;
 
-  // Must be deleted on the file thread. Must be posted for deletion and nulled
-  // before the AudioEntry is deleted.
-  std::unique_ptr<AudioInputDebugWriter> input_debug_writer;
-
   // Set to true after we called Close() for the controller.
   bool pending_close;
 
   // If this entry's layout has a keyboard mic channel.
   bool has_keyboard_mic;
-
-#ifdef ENABLE_WEBRTC
-  // Stream audio parameters, used to build wave header for debug recording.
-  media::AudioParameters audio_params;
-#endif  // ENABLE_WEBRTC
 };
 
 AudioInputRendererHost::AudioEntry::AudioEntry()
     : stream_id(0),
       shared_memory_segment_count(0),
       pending_close(false),
       has_keyboard_mic(false) {
 }
 
 AudioInputRendererHost::AudioEntry::~AudioEntry() {
-  DCHECK(!input_debug_writer.get());
 }
 
 AudioInputRendererHost::AudioInputRendererHost(
     int render_process_id,
     int32_t renderer_pid,
     media::AudioManager* audio_manager,
     MediaStreamManager* media_stream_manager,
     AudioMirroringManager* audio_mirroring_manager,
     media::UserInputMonitor* user_input_monitor)
     : BrowserMessageFilter(AudioMsgStart),
@@ skipping 16 matching lines @@
 void AudioInputRendererHost::EnableDebugRecording(const base::FilePath& file) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   base::FilePath file_with_extensions =
       GetDebugRecordingFilePathWithExtensions(file);
   for (const auto& entry : audio_entries_)
     EnableDebugRecordingForId(file_with_extensions, entry.first);
 }
 
 void AudioInputRendererHost::DisableDebugRecording() {
   for (const auto& entry : audio_entries_) {
-    entry.second->controller->DisableDebugRecording(
-        base::Bind(&AudioInputRendererHost::DeleteDebugWriter,
-                   this,
-                   entry.first));
+    entry.second->controller->DisableDebugRecording();
   }
 }
 #endif  // ENABLE_WEBRTC
 
 void AudioInputRendererHost::OnChannelClosing() {
   // Since the IPC sender is gone, close all requested audio streams.
   DeleteEntries();
 }
 
 void AudioInputRendererHost::OnDestruct() const {
@@ skipping 244 matching lines @@
   std::unique_ptr<AudioInputSyncWriter> writer(new AudioInputSyncWriter(
       entry->shared_memory.memory(), entry->shared_memory.requested_size(),
       entry->shared_memory_segment_count, audio_params));
 
   if (!writer->Init()) {
     SendErrorMessage(stream_id, SYNC_WRITER_INIT_FAILED);
     MaybeUnregisterKeyboardMicStream(config);
     return;
   }
 
+#if defined(ENABLE_WEBRTC)
+  std::unique_ptr<media::AudioInputWriter> debug_writer(
+      new AudioInputDebugWriter(audio_params));
+#else
+  std::unique_ptr<media::AudioInputWriter> debug_writer(nullptr);
+#endif
+
   // If we have successfully created the SyncWriter then assign it to the
   // entry and construct an AudioInputController.
   entry->writer.reset(writer.release());
   if (WebContentsMediaCaptureId::IsWebContentsDeviceId(device_id)) {
     // For MEDIA_DESKTOP_AUDIO_CAPTURE, the source is selected from picker
     // window, we do not mute the source audio.
     // For MEDIA_TAB_AUDIO_CAPTURE, the probable use case is Cast, we mute
     // the source audio.
     // TODO(qiangchen): Analyze audio constraints to make a duplicating or
     // diverting decision. It would give web developer more flexibility.
     entry->controller = media::AudioInputController::CreateForStream(
         audio_manager_->GetTaskRunner(), this,
         WebContentsAudioInputStream::Create(
             device_id, audio_params, audio_manager_->GetWorkerTaskRunner(),
             audio_mirroring_manager_, type == MEDIA_DESKTOP_AUDIO_CAPTURE),
-        entry->writer.get(), user_input_monitor_);
+        entry->writer.get(), std::move(debug_writer), user_input_monitor_);
     // Only count for captures from desktop media picker dialog.
     if (entry->controller.get() && type == MEDIA_DESKTOP_AUDIO_CAPTURE)
       IncrementDesktopCaptureCounter(TAB_AUDIO_CAPTURER_CREATED);
   } else {
     // We call CreateLowLatency regardless of the value of
     // |audio_params.format|. Low latency can currently mean different things in
     // different parts of the stack.
     // TODO(grunell): Clean up the low latency terminology so that it's less
     // confusing.
     entry->controller = media::AudioInputController::CreateLowLatency(
-        audio_manager_,
-        this,
-        audio_params,
-        device_id,
-        entry->writer.get(),
-        user_input_monitor_,
+        audio_manager_, this, audio_params, device_id, entry->writer.get(),
+        std::move(debug_writer), user_input_monitor_,
         config.automatic_gain_control);
     oss << ", AGC=" << config.automatic_gain_control;
 
     // Only count for captures from desktop media picker dialog and system loop
     // back audio.
     if (entry->controller.get() && type == MEDIA_DESKTOP_AUDIO_CAPTURE &&
         (device_id == media::AudioDeviceDescription::kLoopbackInputDeviceId ||
          device_id ==
              media::AudioDeviceDescription::kLoopbackWithMuteDeviceId)) {
       IncrementDesktopCaptureCounter(SYSTEM_LOOPBACK_AUDIO_CAPTURER_CREATED);
     }
   }
 
   if (!entry->controller.get()) {
     SendErrorMessage(stream_id, STREAM_CREATE_ERROR);
     MaybeUnregisterKeyboardMicStream(config);
     return;
   }
 
 #if defined(OS_CHROMEOS)
   if (config.params.channel_layout() ==
           media::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC) {
     entry->has_keyboard_mic = true;
   }
 #endif
 
-#if defined(ENABLE_WEBRTC)
-  entry->audio_params = audio_params;
-#endif  // ENABLE_WEBRTC
-
   MediaStreamManager::SendMessageToNativeLog(oss.str());
   DVLOG(1) << oss.str();
 
   // Since the controller was created successfully, create an entry and add it
   // to the map.
   entry->stream_id = stream_id;
   audio_entries_.insert(std::make_pair(stream_id, entry.release()));
   audio_log_->OnCreated(stream_id, audio_params, device_id);
   MediaInternals::GetInstance()->SetWebContentsTitleForAudioLogEntry(
       stream_id, render_process_id_, render_frame_id, audio_log_.get());
@@ skipping 81 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   LogMessage(entry->stream_id, "DeleteEntry: stream is now closed", true);
 
 #if defined(OS_CHROMEOS)
   if (entry->has_keyboard_mic) {
     media_stream_manager_->audio_input_device_manager()
         ->UnregisterKeyboardMicStream();
   }
 #endif
 
-#if defined(ENABLE_WEBRTC)
-  if (entry->input_debug_writer.get()) {
-    BrowserThread::PostTask(
-        BrowserThread::FILE, FROM_HERE,
-        base::Bind(&DeleteInputDebugWriterOnFileThread,
-                   base::Passed(std::move(entry->input_debug_writer))));
-  }
-#endif
-
   // Delete the entry when this method goes out of scope.
   std::unique_ptr<AudioEntry> entry_deleter(entry);
 
   // Erase the entry from the map.
   audio_entries_.erase(entry->stream_id);
 }
 
 void AudioInputRendererHost::DeleteEntryOnError(AudioEntry* entry,
     ErrorCode error_code) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 62 matching lines @@
 #define IntToStringType base::IntToString
 #endif
 
 base::FilePath AudioInputRendererHost::GetDebugRecordingFilePathWithExtensions(
     const base::FilePath& file) {
   return file.AddExtension(IntToStringType(renderer_pid_))
              .AddExtension(kDebugRecordingFileNameAddition);
 }
 
 void AudioInputRendererHost::EnableDebugRecordingForId(
-    const base::FilePath& file,
+    const base::FilePath& file_name,
     int stream_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  BrowserThread::PostTaskAndReplyWithResult(
-      BrowserThread::FILE,
-      FROM_HERE,
-      base::Bind(
-          &CreateDebugRecordingFile,
-          file.AddExtension(IntToStringType(stream_id))
-              .AddExtension(kDebugRecordingFileNameExtension)),
-      base::Bind(
-          &AudioInputRendererHost::DoEnableDebugRecording,
-          weak_factory_.GetWeakPtr(),
-          stream_id));
+  AudioEntry* entry = LookupById(stream_id);
+  if (!entry)
+    return;
+  entry->controller->EnableDebugRecording(
+      file_name.AddExtension(IntToStringType(stream_id))
+          .AddExtension(kDebugRecordingFileNameExtension));
 }
 
 #undef IntToStringType
 
-void AudioInputRendererHost::DoEnableDebugRecording(
-    int stream_id,
-    base::File file) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (!file.IsValid())
-    return;
-  AudioEntry* entry = LookupById(stream_id);
-  if (!entry) {
-    BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-                            base::Bind(&CloseFile, Passed(std::move(file))));
-    return;
-  }
-  entry->input_debug_writer.reset(
-      new AudioInputDebugWriter(std::move(file), entry->audio_params));
-  entry->controller->EnableDebugRecording(entry->input_debug_writer.get());
-}
-
-void AudioInputRendererHost::DeleteDebugWriter(int stream_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  AudioEntry* entry = LookupById(stream_id);
-  if (!entry) {
-    // This happens if DisableDebugRecording is called right after
-    // DeleteEntries.
-    return;
-  }
-
-  if (entry->input_debug_writer.get()) {
-    BrowserThread::PostTask(
-        BrowserThread::FILE, FROM_HERE,
-        base::Bind(&DeleteInputDebugWriterOnFileThread,
-                   base::Passed(std::move(entry->input_debug_writer))));
-  }
-}
 #endif  // defined(ENABLE_WEBRTC)
 
 }  // namespace content