Move AudioDebugFileWriter from content/ to media/.

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 "media/audio/audio_file_writer.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"
 
 // 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
 // alternative factory methods, Create() or CreateForStream().
 //
@@ skipping 126 matching lines @@
   };
 
   // Sets the factory used by the static method Create(). AudioInputController
   // does not take ownership of |factory|. A value of NULL results in an
   // AudioInputController being created directly.
   static void set_factory_for_testing(Factory* factory) { factory_ = factory; }
   AudioInputStream* stream_for_testing() { return stream_; }
 
   // The audio device will be created on the audio thread, and when that is
   // done, the event handler will receive an OnCreated() call from that same
-  // thread. |user_input_monitor| is used for typing detection and can be NULL,
-  // and |debug_writer| can be null if debug recording is not required.
+  // thread. |user_input_monitor| is used for typing detection and can be NULL.
+  // |file_task_runner| is used for debug recordings.
+  // TODO(grunell): Move handling of debug recording to AudioManager.
   static scoped_refptr<AudioInputController> Create(
       AudioManager* audio_manager,
       EventHandler* event_handler,
       SyncWriter* sync_writer,
       UserInputMonitor* user_input_monitor,
-      std::unique_ptr<AudioFileWriter> debug_writer,
       const AudioParameters& params,
       const std::string& device_id,
       // External synchronous writer for audio controller.
-      bool agc_is_enabled);
+      bool agc_is_enabled,
+      scoped_refptr<base::SingleThreadTaskRunner> file_task_runner);
 
   // Factory method for creating an AudioInputController with an existing
   // |stream|. The stream will be opened on the audio thread, and when that is
   // done, the event  handler will receive an OnCreated() call from that same
   // thread. |user_input_monitor| is used for typing detection and can be NULL.
+  // |file_task_runner| and |params| are used for debug recordings.
   static scoped_refptr<AudioInputController> CreateForStream(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       EventHandler* event_handler,
       AudioInputStream* stream,
       // External synchronous writer for audio controller.
       SyncWriter* sync_writer,
-      std::unique_ptr<AudioFileWriter> debug_writer,
-      UserInputMonitor* user_input_monitor);
+      UserInputMonitor* user_input_monitor,
+      scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
+      const AudioParameters& params);
 
   // Starts recording using the created audio input stream.
   // This method is called on the creator thread.
   virtual void Record();
 
   // Closes the audio input stream. The state is changed and the resources
   // are freed on the audio thread. |closed_task| is then executed on the thread
   // that called Close().
   // Callbacks (EventHandler and SyncWriter) must exist until |closed_task|
   // is called.
@@ skipping 48 matching lines @@
   //            SILENCE_STATE_NO_MEASUREMENT
   enum SilenceState {
     SILENCE_STATE_NO_MEASUREMENT = 0,
     SILENCE_STATE_ONLY_AUDIO = 1,
     SILENCE_STATE_ONLY_SILENCE = 2,
     SILENCE_STATE_AUDIO_AND_SILENCE = 3,
     SILENCE_STATE_MAX = SILENCE_STATE_AUDIO_AND_SILENCE
   };
 #endif
 
-  AudioInputController(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-                       EventHandler* handler,
-                       SyncWriter* sync_writer,
-                       std::unique_ptr<AudioFileWriter> debug_writer,
-                       UserInputMonitor* user_input_monitor,
-                       StreamType type);
+  AudioInputController(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+      EventHandler* handler,
+      SyncWriter* sync_writer,
+      UserInputMonitor* user_input_monitor,
+      const AudioParameters& params,
+      StreamType type,
+      scoped_refptr<base::SingleThreadTaskRunner> file_task_runner);

[o1ka, 2017/02/21 12:07:45]

It may look more comprehensive to have two task runner parameters one after
another, but up to you.

[Henrik Grunell, 2017/02/21 14:10:52]

:) I actually started to move it that way when working on the original patch but
changed my mind and reverted. The rationale for the current ordering is that
debug recording related parameters come last. (|params| should be moved last as
the CreateForStream().)

However, I don't have strong opinions and can do either way.

I'll wait for Dale's review before possibly changing this.

[DaleCurtis, 2017/02/21 18:01:52]

This is just going to be deleted in the next CL, so doesn't matter?

[Henrik Grunell, 2017/02/21 21:07:52]

Right, agree. (To be exact: the second next CL; not in the output debug
recording CL.)

   virtual ~AudioInputController();
 
   const scoped_refptr<base::SingleThreadTaskRunner>& GetTaskRunnerForTesting()
       const {
     return task_runner_;
   }
 
   EventHandler* GetHandlerForTesting() const { return handler_; }
 
  private:
@@ skipping 88 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_;
 
   // Used for audio debug recordings. Accessed on audio thread.
-  const std::unique_ptr<AudioFileWriter> debug_writer_;
+  const std::unique_ptr<AudioDebugFileWriter> debug_writer_;
 
   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
   // the callbacks themselves occur on the hw callback thread. More details
   // in the AudioCallback class in the cc file.
   std::unique_ptr<AudioCallback> audio_callback_;
 
@@ skipping 10 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_