Move AudioSyncReader and AudioInputSyncWriter to media/.

Only mechanical changes in this CL. Presubmit (correctly) complains
about Time::Now() usage AudioInputSyncWriter. This is pre-existing,
but only for logging, and will be fixed in a followup to keep this CL
completely trivial.

Bug: 803102
Cq-Include-Trybots: master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
Change-Id: I422f80e376f89428ed8f69a1de1a5751c31bf4bb
Reviewed-on: https://chromium-review.googlesource.com/886345
Commit-Queue: Max Morin <maxmorin@chromium.org>
Reviewed-by: Dale Curtis <dalecurtis@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#532383}

content/browser/BUILD.gn

@@ -1322,8 +1322,6 @@ jumbo_source_set("browser") {
     "renderer_host/media/audio_input_renderer_host.h",
     "renderer_host/media/audio_input_stream_handle.cc",
     "renderer_host/media/audio_input_stream_handle.h",
-    "renderer_host/media/audio_input_sync_writer.cc",
-    "renderer_host/media/audio_input_sync_writer.h",
     "renderer_host/media/audio_output_authorization_handler.cc",
     "renderer_host/media/audio_output_authorization_handler.h",
     "renderer_host/media/audio_output_delegate_impl.cc",
@@ -1332,8 +1330,6 @@ jumbo_source_set("browser") {
     "renderer_host/media/audio_output_stream_observer_impl.h",
     "renderer_host/media/audio_renderer_host.cc",
     "renderer_host/media/audio_renderer_host.h",
-    "renderer_host/media/audio_sync_reader.cc",
-    "renderer_host/media/audio_sync_reader.h",
     "renderer_host/media/in_process_launched_video_capture_device.cc",
     "renderer_host/media/in_process_launched_video_capture_device.h",
     "renderer_host/media/in_process_video_capture_device_launcher.cc",

content/browser/renderer_host/media/audio_input_delegate_impl.cc

@@ -18,12 +18,12 @@
 #include "content/browser/media/capture/web_contents_audio_input_stream.h"
 #include "content/browser/media/media_internals.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
-#include "content/browser/renderer_host/media/audio_input_sync_writer.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents_media_capture_id.h"
 #include "media/audio/audio_input_controller.h"
+#include "media/audio/audio_input_sync_writer.h"
 #include "media/audio/audio_logging.h"
 #include "media/audio/audio_manager.h"
 #include "media/base/media_switches.h"
@@ -133,9 +133,10 @@ std::unique_ptr<media::AudioInputDelegate> AudioInputDelegateImpl::Create(
 
   auto foreign_socket = std::make_unique<base::CancelableSyncSocket>();
 
-  std::unique_ptr<AudioInputSyncWriter> writer = AudioInputSyncWriter::Create(
-      base::BindRepeating(&LogMessage, stream_id), shared_memory_count,
-      possibly_modified_parameters, foreign_socket.get());
+  std::unique_ptr<media::AudioInputSyncWriter> writer =
+      media::AudioInputSyncWriter::Create(
+          base::BindRepeating(&LogMessage, stream_id), shared_memory_count,
+          possibly_modified_parameters, foreign_socket.get());
 
   if (!writer) {
     LogMessage(stream_id, "Failed to set up sync writer.");
@@ -170,7 +171,7 @@ AudioInputDelegateImpl::AudioInputDelegateImpl(
     bool automatic_gain_control,
     EventHandler* subscriber,
     const MediaStreamDevice* device,
-    std::unique_ptr<AudioInputSyncWriter> writer,
+    std::unique_ptr<media::AudioInputSyncWriter> writer,
     std::unique_ptr<base::CancelableSyncSocket> foreign_socket)
     : subscriber_(subscriber),
       controller_event_handler_(),
@@ -244,7 +245,7 @@ AudioInputDelegateImpl::~AudioInputDelegateImpl() {
   // stay alive until |controller_| has finished closing.
   controller_->Close(base::BindOnce(
       [](int stream_id, std::unique_ptr<ControllerEventHandler>,
-         std::unique_ptr<AudioInputSyncWriter>) {
+         std::unique_ptr<media::AudioInputSyncWriter>) {
         LogMessage(stream_id, "Stream is now closed");
       },
       stream_id_, std::move(controller_event_handler_), std::move(writer_)));

content/browser/renderer_host/media/audio_input_delegate_impl.h

@@ -18,13 +18,13 @@ namespace media {
 class AudioLog;
 class AudioManager;
 class AudioInputController;
+class AudioInputSyncWriter;
 class AudioParameters;
 class UserInputMonitor;
 }  // namespace media
 
 namespace content {
 
-class AudioInputSyncWriter;
 class AudioInputDeviceManager;
 class AudioMirroringManager;
 struct MediaStreamDevice;
@@ -73,7 +73,7 @@ class CONTENT_EXPORT AudioInputDelegateImpl : public media::AudioInputDelegate {
       bool automatic_gain_control,
       EventHandler* subscriber,
       const MediaStreamDevice* device,
-      std::unique_ptr<AudioInputSyncWriter> writer,
+      std::unique_ptr<media::AudioInputSyncWriter> writer,
       std::unique_ptr<base::CancelableSyncSocket> foreign_socket);
 
   void SendCreatedNotification(bool initially_muted);
@@ -89,7 +89,7 @@ class CONTENT_EXPORT AudioInputDelegateImpl : public media::AudioInputDelegate {
   // |controller_event_handler_| and |writer_| outlive |this|, see the
   // destructor for details.
   std::unique_ptr<ControllerEventHandler> controller_event_handler_;
-  std::unique_ptr<AudioInputSyncWriter> writer_;
+  std::unique_ptr<media::AudioInputSyncWriter> writer_;
   std::unique_ptr<base::CancelableSyncSocket> foreign_socket_;
   media::AudioLog* const audio_log_;
   scoped_refptr<media::AudioInputController> controller_;

content/browser/renderer_host/media/audio_input_delegate_impl_unittest.cc

@@ -21,7 +21,6 @@
 #include "build/build_config.h"
 #include "content/browser/media/capture/audio_mirroring_manager.h"
 #include "content/browser/media/media_internals.h"
-#include "content/browser/renderer_host/media/audio_sync_reader.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/media_observer.h"

content/browser/renderer_host/media/audio_output_delegate_impl.cc

@@ -13,11 +13,11 @@
 #include "content/browser/media/audio_stream_monitor.h"
 #include "content/browser/media/capture/audio_mirroring_manager.h"
 #include "content/browser/media/media_internals.h"
-#include "content/browser/renderer_host/media/audio_sync_reader.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/media_observer.h"
 #include "media/audio/audio_output_controller.h"
+#include "media/audio/audio_sync_reader.h"
 
 namespace content {
 
@@ -109,7 +109,7 @@ std::unique_ptr<media::AudioOutputDelegate> AudioOutputDelegateImpl::Create(
     media::mojom::AudioOutputStreamObserverPtr observer,
     const std::string& output_device_id) {
   auto socket = std::make_unique<base::CancelableSyncSocket>();
-  auto reader = AudioSyncReader::Create(
+  auto reader = media::AudioSyncReader::Create(
       base::BindRepeating(&AudioOutputLogMessage, stream_id), params,
       socket.get());
   if (!reader)
@@ -122,7 +122,7 @@ std::unique_ptr<media::AudioOutputDelegate> AudioOutputDelegateImpl::Create(
 }
 
 AudioOutputDelegateImpl::AudioOutputDelegateImpl(
-    std::unique_ptr<AudioSyncReader> reader,
+    std::unique_ptr<media::AudioSyncReader> reader,
     std::unique_ptr<base::CancelableSyncSocket> foreign_socket,
     EventHandler* handler,
     media::AudioManager* audio_manager,
@@ -181,7 +181,7 @@ AudioOutputDelegateImpl::~AudioOutputDelegateImpl() {
   controller_->Close(base::BindOnce(
       [](AudioMirroringManager* mirroring_manager,
          std::unique_ptr<ControllerEventHandler> event_handler,
-         std::unique_ptr<AudioSyncReader> reader,
+         std::unique_ptr<media::AudioSyncReader> reader,
          scoped_refptr<media::AudioOutputController> controller) {
         // De-register the controller from the AudioMirroringManager now that
         // the controller has closed the AudioOutputStream and shut itself down.

content/browser/renderer_host/media/audio_output_delegate_impl.h

@@ -16,7 +16,6 @@
 
 namespace content {
 class AudioMirroringManager;
-class AudioSyncReader;
 class MediaObserver;
 }
 
@@ -25,6 +24,7 @@ class AudioLog;
 class AudioManager;
 class AudioOutputController;
 class AudioParameters;
+class AudioSyncReader;
 }
 
 namespace content {
@@ -48,7 +48,7 @@ class CONTENT_EXPORT AudioOutputDelegateImpl
       const std::string& output_device_id);
 
   AudioOutputDelegateImpl(
-      std::unique_ptr<AudioSyncReader> reader,
+      std::unique_ptr<media::AudioSyncReader> reader,
       std::unique_ptr<base::CancelableSyncSocket> foreign_socket,
       EventHandler* handler,
       media::AudioManager* audio_manager,
@@ -88,7 +88,7 @@ class CONTENT_EXPORT AudioOutputDelegateImpl
   // |controller_event_handler_|, |reader_| and |mirroring_manager_| will
   // outlive |this|, see the destructor for details.
   std::unique_ptr<ControllerEventHandler> controller_event_handler_;
-  std::unique_ptr<AudioSyncReader> reader_;
+  std::unique_ptr<media::AudioSyncReader> reader_;
   std::unique_ptr<base::CancelableSyncSocket> foreign_socket_;
   AudioMirroringManager* mirroring_manager_;
   scoped_refptr<media::AudioOutputController> controller_;

content/browser/renderer_host/media/audio_output_delegate_impl_unittest.cc

@@ -16,11 +16,11 @@
 #include "base/run_loop.h"
 #include "base/sync_socket.h"
 #include "content/browser/media/capture/audio_mirroring_manager.h"
-#include "content/browser/renderer_host/media/audio_sync_reader.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/media_observer.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "media/audio/audio_output_controller.h"
+#include "media/audio/audio_sync_reader.h"
 #include "media/audio/audio_thread_impl.h"
 #include "media/audio/fake_audio_log_factory.h"
 #include "media/audio/fake_audio_manager.h"
@@ -170,8 +170,8 @@ class AudioOutputDelegateTest : public testing::Test {
 
     {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
-      auto reader = AudioSyncReader::Create(base::BindRepeating(&NoLog),
-                                            Params(), socket.get());
+      auto reader = media::AudioSyncReader::Create(base::BindRepeating(&NoLog),
+                                                   Params(), socket.get());
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), audio_log_.get(),
@@ -205,8 +205,8 @@ class AudioOutputDelegateTest : public testing::Test {
 
     {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
-      auto reader = AudioSyncReader::Create(base::BindRepeating(&NoLog),
-                                            Params(), socket.get());
+      auto reader = media::AudioSyncReader::Create(base::BindRepeating(&NoLog),
+                                                   Params(), socket.get());
       media::mojom::AudioOutputStreamObserverPtr observer_ptr;
       auto observer_binding = CreateObserverBinding(&observer_ptr);
       if (use_bound_observer) {
@@ -249,8 +249,8 @@ class AudioOutputDelegateTest : public testing::Test {
 
     {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
-      auto reader = AudioSyncReader::Create(base::BindRepeating(&NoLog),
-                                            Params(), socket.get());
+      auto reader = media::AudioSyncReader::Create(base::BindRepeating(&NoLog),
+                                                   Params(), socket.get());
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), audio_log_.get(),
@@ -278,8 +278,8 @@ class AudioOutputDelegateTest : public testing::Test {
 
     {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
-      auto reader = AudioSyncReader::Create(base::BindRepeating(&NoLog),
-                                            Params(), socket.get());
+      auto reader = media::AudioSyncReader::Create(base::BindRepeating(&NoLog),
+                                                   Params(), socket.get());
       media::mojom::AudioOutputStreamObserverPtr observer_ptr;
       auto observer_binding = CreateObserverBinding(&observer_ptr);
       InSequence s;
@@ -317,8 +317,8 @@ class AudioOutputDelegateTest : public testing::Test {
 
     {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
-      auto reader = AudioSyncReader::Create(base::BindRepeating(&NoLog),
-                                            Params(), socket.get());
+      auto reader = media::AudioSyncReader::Create(base::BindRepeating(&NoLog),
+                                                   Params(), socket.get());
       media::mojom::AudioOutputStreamObserverPtr observer_ptr;
       auto observer_binding = CreateObserverBinding(&observer_ptr);
       InSequence s;
@@ -358,8 +358,8 @@ class AudioOutputDelegateTest : public testing::Test {
     DummyAudioOutputStream stream;
     {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
-      auto reader = AudioSyncReader::Create(base::BindRepeating(&NoLog),
-                                            Params(), socket.get());
+      auto reader = media::AudioSyncReader::Create(base::BindRepeating(&NoLog),
+                                                   Params(), socket.get());
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), audio_log_.get(),
@@ -388,8 +388,8 @@ class AudioOutputDelegateTest : public testing::Test {
     DummyAudioOutputStream stream;
     {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
-      auto reader = AudioSyncReader::Create(base::BindRepeating(&NoLog),
-                                            Params(), socket.get());
+      auto reader = media::AudioSyncReader::Create(base::BindRepeating(&NoLog),
+                                                   Params(), socket.get());
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), audio_log_.get(),
@@ -425,8 +425,8 @@ class AudioOutputDelegateTest : public testing::Test {
     DummyAudioOutputStream stream;
     {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
-      auto reader = AudioSyncReader::Create(base::BindRepeating(&NoLog),
-                                            Params(), socket.get());
+      auto reader = media::AudioSyncReader::Create(base::BindRepeating(&NoLog),
+                                                   Params(), socket.get());
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), audio_log_.get(),
@@ -467,8 +467,8 @@ class AudioOutputDelegateTest : public testing::Test {
     EXPECT_CALL(GetMockObserver(&observer_binding), DidStopPlaying());
 
     auto socket = std::make_unique<base::CancelableSyncSocket>();
-    auto reader = AudioSyncReader::Create(base::BindRepeating(&NoLog), Params(),
-                                          socket.get());
+    auto reader = media::AudioSyncReader::Create(base::BindRepeating(&NoLog),
+                                                 Params(), socket.get());
     auto delegate = std::make_unique<AudioOutputDelegateImpl>(
         std::move(reader), std::move(socket), &event_handler_,
         audio_manager_.get(), audio_log_.get(), &mirroring_manager_,
@@ -500,8 +500,8 @@ class AudioOutputDelegateTest : public testing::Test {
 
     {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
-      auto reader = AudioSyncReader::Create(base::BindRepeating(&NoLog),
-                                            Params(), socket.get());
+      auto reader = media::AudioSyncReader::Create(base::BindRepeating(&NoLog),
+                                                   Params(), socket.get());
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), audio_log_.get(), &mirroring_manager_,
@@ -526,8 +526,8 @@ class AudioOutputDelegateTest : public testing::Test {
 
     {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
-      auto reader = AudioSyncReader::Create(base::BindRepeating(&NoLog),
-                                            Params(), socket.get());
+      auto reader = media::AudioSyncReader::Create(base::BindRepeating(&NoLog),
+                                                   Params(), socket.get());
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), audio_log_.get(),
@@ -558,8 +558,8 @@ class AudioOutputDelegateTest : public testing::Test {
 
     {
       auto socket = std::make_unique<base::CancelableSyncSocket>();
-      auto reader = AudioSyncReader::Create(base::BindRepeating(&NoLog),
-                                            Params(), socket.get());
+      auto reader = media::AudioSyncReader::Create(base::BindRepeating(&NoLog),
+                                                   Params(), socket.get());
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
           audio_manager_.get(), audio_log_.get(),

content/browser/renderer_host/media/audio_renderer_host.cc

@@ -20,7 +20,6 @@
 #include "content/browser/renderer_host/media/audio_output_authorization_handler.h"
 #include "content/browser/renderer_host/media/audio_output_delegate_impl.h"
 #include "content/browser/renderer_host/media/audio_output_stream_observer_impl.h"
-#include "content/browser/renderer_host/media/audio_sync_reader.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/common/media/audio_messages.h"
 #include "content/public/browser/content_browser_client.h"

content/test/BUILD.gn

@@ -1384,11 +1384,9 @@ test("content_unittests") {
     "../browser/renderer_host/media/audio_input_device_manager_unittest.cc",
     "../browser/renderer_host/media/audio_input_renderer_host_unittest.cc",
     "../browser/renderer_host/media/audio_input_stream_handle_unittest.cc",
-    "../browser/renderer_host/media/audio_input_sync_writer_unittest.cc",
     "../browser/renderer_host/media/audio_output_authorization_handler_unittest.cc",
     "../browser/renderer_host/media/audio_output_delegate_impl_unittest.cc",
     "../browser/renderer_host/media/audio_renderer_host_unittest.cc",
-    "../browser/renderer_host/media/audio_sync_reader_unittest.cc",
     "../browser/renderer_host/media/fake_video_capture_device_launcher.cc",
     "../browser/renderer_host/media/fake_video_capture_device_launcher.h",
     "../browser/renderer_host/media/fake_video_capture_provider.cc",

media/audio/BUILD.gn

@@ -93,6 +93,8 @@ source_set("audio") {
     "audio_input_device.h",
     "audio_input_ipc.cc",
     "audio_input_ipc.h",
+    "audio_input_sync_writer.cc",
+    "audio_input_sync_writer.h",
     "audio_io.h",
     "audio_manager.cc",
     "audio_manager.h",
@@ -119,6 +121,8 @@ source_set("audio") {
     "audio_power_monitor.cc",
     "audio_power_monitor.h",
     "audio_source_diverter.h",
+    "audio_sync_reader.cc",
+    "audio_sync_reader.h",
     "audio_system.cc",
     "audio_system.h",
     "audio_system_helper.cc",
@@ -376,6 +380,7 @@ source_set("unit_tests") {
     "audio_debug_recording_session_impl_unittest.cc",
     "audio_input_controller_unittest.cc",
     "audio_input_device_unittest.cc",
+    "audio_input_sync_writer_unittest.cc",
     "audio_input_unittest.cc",
     "audio_manager_unittest.cc",
     "audio_output_controller_unittest.cc",
@@ -383,6 +388,7 @@ source_set("unit_tests") {
     "audio_output_proxy_unittest.cc",
     "audio_output_unittest.cc",
     "audio_power_monitor_unittest.cc",
+    "audio_sync_reader_unittest.cc",
     "audio_system_impl_unittest.cc",
     "power_observer_helper_unittest.cc",
     "simple_sources_unittest.cc",

content/browser/renderer_host/media/audio_input_sync_writer.cc → media/audio/audio_input_sync_writer.cc

@@ -2,7 +2,7 @@
 // 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_sync_writer.h"
+#include "media/audio/audio_input_sync_writer.h"
 
 #include <algorithm>
 #include <utility>
@@ -14,11 +14,7 @@
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 
-using media::AudioBus;
-using media::AudioInputBuffer;
-using media::AudioInputBufferParameters;
-
-namespace content {
+namespace media {
 
 namespace {
 
@@ -36,7 +32,7 @@ AudioInputSyncWriter::OverflowData::OverflowData(
     double volume,
     bool key_pressed,
     base::TimeTicks capture_time,
-    std::unique_ptr<media::AudioBus> audio_bus)
+    std::unique_ptr<AudioBus> audio_bus)
     : volume_(volume),
       key_pressed_(key_pressed),
       capture_time_(capture_time),
@@ -52,7 +48,7 @@ AudioInputSyncWriter::AudioInputSyncWriter(
     std::unique_ptr<base::SharedMemory> shared_memory,
     std::unique_ptr<base::CancelableSyncSocket> socket,
     uint32_t shared_memory_segment_count,
-    const media::AudioParameters& params)
+    const AudioParameters& params)
     : log_callback_(std::move(log_callback)),
       socket_(std::move(socket)),
       shared_memory_(std::move(shared_memory)),
@@ -105,24 +101,22 @@ AudioInputSyncWriter::~AudioInputSyncWriter() {
 
   write_to_fifo_count_ -= trailing_write_to_fifo_count_;
   write_error_count_ -= trailing_write_error_count_;
-  write_count_ -= std::max(trailing_write_to_fifo_count_,
-                           trailing_write_error_count_);
+  write_count_ -=
+      std::max(trailing_write_to_fifo_count_, trailing_write_error_count_);
 
   if (write_count_ == 0)
     return;
 
-  UMA_HISTOGRAM_PERCENTAGE(
-      "Media.AudioCapturerMissedReadDeadline",
-      100.0 * write_to_fifo_count_ / write_count_);
+  UMA_HISTOGRAM_PERCENTAGE("Media.AudioCapturerMissedReadDeadline",
+                           100.0 * write_to_fifo_count_ / write_count_);
 
-  UMA_HISTOGRAM_PERCENTAGE(
-      "Media.AudioCapturerDroppedData",
-      100.0 * write_error_count_ / write_count_);
+  UMA_HISTOGRAM_PERCENTAGE("Media.AudioCapturerDroppedData",
+                           100.0 * write_error_count_ / write_count_);
 
   UMA_HISTOGRAM_ENUMERATION("Media.AudioCapturerAudioGlitches",
-                            write_error_count_ == 0 ?
-                                AUDIO_CAPTURER_NO_AUDIO_GLITCHES :
-                                AUDIO_CAPTURER_AUDIO_GLITCHES,
+                            write_error_count_ == 0
+                                ? AUDIO_CAPTURER_NO_AUDIO_GLITCHES
+                                : AUDIO_CAPTURER_AUDIO_GLITCHES,
                             AUDIO_CAPTURER_AUDIO_GLITCHES_MAX + 1);
 
   std::string log_string = base::StringPrintf(
@@ -135,15 +129,14 @@ AudioInputSyncWriter::~AudioInputSyncWriter() {
 std::unique_ptr<AudioInputSyncWriter> AudioInputSyncWriter::Create(
     base::RepeatingCallback<void(const std::string&)> log_callback,
     uint32_t shared_memory_segment_count,
-    const media::AudioParameters& params,
+    const AudioParameters& params,
     base::CancelableSyncSocket* foreign_socket) {
   // Having no shared memory doesn't make sense, so fail creation in that case.
   if (shared_memory_segment_count == 0)
     return nullptr;
 
   base::CheckedNumeric<uint32_t> requested_memory_size =
-      media::ComputeAudioInputBufferSizeChecked(params,
-                                                shared_memory_segment_count);
+      ComputeAudioInputBufferSizeChecked(params, shared_memory_segment_count);
 
   if (!requested_memory_size.IsValid())
     return nullptr;
@@ -185,8 +178,7 @@ void AudioInputSyncWriter::Write(const AudioBus* data,
   if (number_of_indices_available > 0) {
     auto indices = std::make_unique<uint32_t[]>(number_of_indices_available);
     size_t bytes_received = socket_->Receive(
-        &indices[0],
-        number_of_indices_available * sizeof(indices[0]));
+        &indices[0], number_of_indices_available * sizeof(indices[0]));
     CHECK_EQ(number_of_indices_available * sizeof(indices[0]), bytes_received);
     for (size_t i = 0; i < number_of_indices_available; ++i) {
       ++next_read_buffer_index_;
@@ -234,7 +226,6 @@ void AudioInputSyncWriter::Close() {
   socket_->Close();
 }
 
-
 void AudioInputSyncWriter::CheckTimeSinceLastWrite() {
 #if !defined(OS_ANDROID)
   static const base::TimeDelta kLogDelayThreadhold =
@@ -245,7 +236,8 @@ void AudioInputSyncWriter::CheckTimeSinceLastWrite() {
     // This is the first time Write is called.
     base::TimeDelta interval = base::Time::Now() - creation_time_;
     oss << "AISW::Write: audio input data received for the first time: delay "
-           "= " << interval.InMilliseconds() << "ms";
+           "= "
+        << interval.InMilliseconds() << "ms";
   } else {
     base::TimeDelta interval = base::Time::Now() - last_write_time_;
     if (interval > kLogDelayThreadhold) {
@@ -389,4 +381,4 @@ bool AudioInputSyncWriter::SignalDataWrittenAndUpdateCounters() {
   return true;
 }
 
-}  // namespace content
+}  // namespace media

content/browser/renderer_host/media/audio_input_sync_writer.h → media/audio/audio_input_sync_writer.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_INPUT_SYNC_WRITER_H_
-#define CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_INPUT_SYNC_WRITER_H_
+#ifndef MEDIA_AUDIO_AUDIO_INPUT_SYNC_WRITER_H_
+#define MEDIA_AUDIO_AUDIO_INPUT_SYNC_WRITER_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -18,10 +18,10 @@
 #include "base/sync_socket.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
-#include "content/common/content_export.h"
 #include "media/audio/audio_input_controller.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_parameters.h"
+#include "media/base/media_export.h"
 
 #if defined(OS_POSIX)
 #include "base/file_descriptor_posix.h"
@@ -31,14 +31,14 @@ namespace base {
 class SharedMemory;
 }
 
-namespace content {
+namespace media {
 
 // A AudioInputController::SyncWriter implementation using SyncSocket. This
 // is used by AudioInputController to provide a low latency data source for
 // transmitting audio packets between the browser process and the renderer
 // process.
-class CONTENT_EXPORT AudioInputSyncWriter
-    : public media::AudioInputController::SyncWriter {
+class MEDIA_EXPORT AudioInputSyncWriter
+    : public AudioInputController::SyncWriter {
  public:
   // Maximum fifo size (|overflow_buses_| and |overflow_params_|) in number of
   // AudioBuses.
@@ -51,14 +51,14 @@ class CONTENT_EXPORT AudioInputSyncWriter
       std::unique_ptr<base::SharedMemory> shared_memory,
       std::unique_ptr<base::CancelableSyncSocket> socket,
       uint32_t shared_memory_segment_count,
-      const media::AudioParameters& params);
+      const AudioParameters& params);
 
   ~AudioInputSyncWriter() override;
 
   static std::unique_ptr<AudioInputSyncWriter> Create(
       base::RepeatingCallback<void(const std::string&)> log_callback,
       uint32_t shared_memory_segment_count,
-      const media::AudioParameters& params,
+      const AudioParameters& params,
       base::CancelableSyncSocket* foreign_socket);
 
   const base::SharedMemory* shared_memory() const {
@@ -67,8 +67,8 @@ class CONTENT_EXPORT AudioInputSyncWriter
 
   size_t shared_memory_segment_count() const { return audio_buses_.size(); }
 
-  // media::AudioInputController::SyncWriter implementation.
-  void Write(const media::AudioBus* data,
+  // AudioInputController::SyncWriter implementation.
+  void Write(const AudioBus* data,
              double volume,
              bool key_pressed,
              base::TimeTicks capture_time) override;
@@ -85,7 +85,7 @@ class CONTENT_EXPORT AudioInputSyncWriter
   // Push |data| and metadata to |audio_buffer_fifo_|. Returns true if
   // successful. Logs error and returns false if the fifo already reached the
   // maximum size.
-  bool PushDataToFifo(const media::AudioBus* data,
+  bool PushDataToFifo(const AudioBus* data,
                       double volume,
                       bool key_pressed,
                       base::TimeTicks capture_time);
@@ -163,7 +163,7 @@ class CONTENT_EXPORT AudioInputSyncWriter
 
   // Vector of audio buses allocated during construction and deleted in the
   // destructor.
-  std::vector<std::unique_ptr<media::AudioBus>> audio_buses_;
+  std::vector<std::unique_ptr<AudioBus>> audio_buses_;
 
   // Fifo for audio that is used in case there isn't room in the shared memory.
   // This can for example happen under load when the consumer side is starved.
@@ -174,14 +174,14 @@ class CONTENT_EXPORT AudioInputSyncWriter
     OverflowData(double volume,
                  bool key_pressed,
                  base::TimeTicks capture_time,
-                 std::unique_ptr<media::AudioBus> audio_bus);
+                 std::unique_ptr<AudioBus> audio_bus);
     ~OverflowData();
     OverflowData(OverflowData&&);
     OverflowData& operator=(OverflowData&& other);
     double volume_;
     bool key_pressed_;
     base::TimeTicks capture_time_;
-    std::unique_ptr<media::AudioBus> audio_bus_;
+    std::unique_ptr<AudioBus> audio_bus_;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(OverflowData);
@@ -192,6 +192,6 @@ class CONTENT_EXPORT AudioInputSyncWriter
   DISALLOW_IMPLICIT_CONSTRUCTORS(AudioInputSyncWriter);
 };
 
-}  // namespace content
+}  // namespace media
 
-#endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_INPUT_SYNC_WRITER_H_
+#endif  // MEDIA_AUDIO_AUDIO_INPUT_SYNC_WRITER_H_

content/browser/renderer_host/media/audio_input_sync_writer_unittest.cc → media/audio/audio_input_sync_writer_unittest.cc

@@ -2,7 +2,7 @@
 // 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_sync_writer.h"
+#include "media/audio/audio_input_sync_writer.h"
 
 #include <stddef.h>
 #include <stdint.h>
@@ -27,10 +27,8 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
-using media::AudioBus;
-using media::AudioParameters;
 
-namespace content {
+namespace media {
 
 namespace {
 
@@ -78,9 +76,7 @@ class MockCancelableSyncSocket : public base::CancelableSyncSocket {
     return received * sizeof(uint32_t);
   }
 
-  size_t Peek() override {
-    return (reads_ - receives_) * sizeof(uint32_t);
-  }
+  size_t Peek() override { return (reads_ - receives_) * sizeof(uint32_t); }
 
   // Simluates reading |buffers| number of buffers from the ring buffer.
   void Read(int buffers) {
@@ -113,10 +109,10 @@ class AudioInputSyncWriterTest : public testing::Test {
     const int frames = sampling_frequency_hz / 100;  // 10 ms
     const int bits_per_sample = 16;
     const AudioParameters audio_params(
-        AudioParameters::AUDIO_FAKE, media::CHANNEL_LAYOUT_MONO,
-        sampling_frequency_hz, bits_per_sample, frames);
+        AudioParameters::AUDIO_FAKE, CHANNEL_LAYOUT_MONO, sampling_frequency_hz,
+        bits_per_sample, frames);
     const uint32_t data_size =
-        media::ComputeAudioInputBufferSize(audio_params, kSegments);
+        ComputeAudioInputBufferSize(audio_params, kSegments);
 
     auto shared_memory = std::make_unique<base::SharedMemory>();
     EXPECT_TRUE(shared_memory->CreateAndMapAnonymous(data_size));
@@ -129,8 +125,7 @@ class AudioInputSyncWriterTest : public testing::Test {
     audio_bus_ = AudioBus::Create(audio_params);
   }
 
-  ~AudioInputSyncWriterTest() override {
-  }
+  ~AudioInputSyncWriterTest() override {}
 
   // Get total number of expected log calls. On non-Android we expect one log
   // call at first Write() call, zero on Android. We also expect all call in the
@@ -221,9 +216,8 @@ TEST_F(AudioInputSyncWriterTest, FillAndEmptyRingBuffer) {
   // Empty half of the ring buffer.
   const int buffers_to_read = kSegments / 2;
   socket_->Read(buffers_to_read);
-  EXPECT_TRUE(TestSocketAndFifoExpectations(kSegments - buffers_to_read,
-                                            buffers_to_read * sizeof(uint32_t),
-                                            0));
+  EXPECT_TRUE(TestSocketAndFifoExpectations(
+      kSegments - buffers_to_read, buffers_to_read * sizeof(uint32_t), 0));
 
   // Fill up again. The first write should do receive until that queue is
   // empty.
@@ -337,4 +331,4 @@ TEST_F(AudioInputSyncWriterTest, MultipleFillAndEmptyRingBufferAndPartOfFifo) {
   EXPECT_TRUE(TestSocketAndFifoExpectations(0, 3 * sizeof(uint32_t), 0));
 }
 
-}  // namespace content
+}  // namespace media

content/browser/renderer_host/media/audio_sync_reader.cc → media/audio/audio_sync_reader.cc

@@ -2,7 +2,7 @@
 // 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_sync_reader.h"
+#include "media/audio/audio_sync_reader.h"
 
 #include <algorithm>
 #include <limits>
@@ -22,9 +22,6 @@
 #include "media/base/audio_parameters.h"
 #include "media/base/media_switches.h"
 
-using media::AudioBus;
-using media::AudioOutputBuffer;
-
 namespace {
 
 // Used to log if any audio glitches have been detected during an audio session.
@@ -36,18 +33,17 @@ enum AudioGlitchResult {
 };
 
 void LogAudioGlitchResult(AudioGlitchResult result) {
-  UMA_HISTOGRAM_ENUMERATION("Media.AudioRendererAudioGlitches",
-                            result,
+  UMA_HISTOGRAM_ENUMERATION("Media.AudioRendererAudioGlitches", result,
                             AUDIO_RENDERER_AUDIO_GLITCHES_MAX + 1);
 }
 
 }  // namespace
 
-namespace content {
+namespace media {
 
 AudioSyncReader::AudioSyncReader(
     base::RepeatingCallback<void(const std::string&)> log_callback,
-    const media::AudioParameters& params,
+    const AudioParameters& params,
     std::unique_ptr<base::SharedMemory> shared_memory,
     std::unique_ptr<base::CancelableSyncSocket> socket)
     : log_callback_(std::move(log_callback)),
@@ -71,7 +67,7 @@ AudioSyncReader::AudioSyncReader(
 #endif
       buffer_index_(0) {
   DCHECK_EQ(base::checked_cast<uint32_t>(shared_memory_->requested_size()),
-            media::ComputeAudioOutputBufferSize(params));
+            ComputeAudioOutputBufferSize(params));
   AudioOutputBuffer* buffer =
       reinterpret_cast<AudioOutputBuffer*>(shared_memory_->memory());
   output_bus_ = AudioBus::WrapMemory(params, buffer->audio);
@@ -105,15 +101,15 @@ AudioSyncReader::~AudioSyncReader() {
   // how many users might be running into audio glitches.
   int percentage_missed =
       100.0 * renderer_missed_callback_count_ / renderer_callback_count_;
-  UMA_HISTOGRAM_PERCENTAGE(
-      "Media.AudioRendererMissedDeadline", percentage_missed);
+  UMA_HISTOGRAM_PERCENTAGE("Media.AudioRendererMissedDeadline",
+                           percentage_missed);
 
   // Add more detailed information regarding detected audio glitches where
   // a non-zero value of |renderer_missed_callback_count_| is added to the
   // AUDIO_RENDERER_AUDIO_GLITCHES bin.
-  renderer_missed_callback_count_ > 0 ?
-      LogAudioGlitchResult(AUDIO_RENDERER_AUDIO_GLITCHES) :
-      LogAudioGlitchResult(AUDIO_RENDERER_NO_AUDIO_GLITCHES);
+  renderer_missed_callback_count_ > 0
+      ? LogAudioGlitchResult(AUDIO_RENDERER_AUDIO_GLITCHES)
+      : LogAudioGlitchResult(AUDIO_RENDERER_NO_AUDIO_GLITCHES);
   log_callback_.Run(base::StringPrintf(
       "ASR: number of detected audio glitches: %" PRIuS " out of %" PRIuS,
       renderer_missed_callback_count_, renderer_callback_count_));
@@ -122,10 +118,10 @@ AudioSyncReader::~AudioSyncReader() {
 // static
 std::unique_ptr<AudioSyncReader> AudioSyncReader::Create(
     base::RepeatingCallback<void(const std::string&)> log_callback,
-    const media::AudioParameters& params,
+    const AudioParameters& params,
     base::CancelableSyncSocket* foreign_socket) {
   base::CheckedNumeric<size_t> memory_size =
-      media::ComputeAudioOutputBufferSizeChecked(params);
+      ComputeAudioOutputBufferSizeChecked(params);
 
   auto shared_memory = std::make_unique<base::SharedMemory>();
   auto socket = std::make_unique<base::CancelableSyncSocket>();
@@ -141,7 +137,7 @@ std::unique_ptr<AudioSyncReader> AudioSyncReader::Create(
                                            std::move(socket));
 }
 
-// media::AudioOutputController::SyncReader implementations.
+// AudioOutputController::SyncReader implementations.
 void AudioSyncReader::RequestMoreData(base::TimeDelta delay,
                                       base::TimeTicks delay_timestamp,
                                       int prior_frames_skipped) {
@@ -153,8 +149,8 @@ void AudioSyncReader::RequestMoreData(base::TimeDelta delay,
   // Increase the number of skipped frames stored in shared memory.
   buffer->params.frames_skipped += prior_frames_skipped;
   buffer->params.delay = delay.InMicroseconds();
-  buffer->params.delay_timestamp
-      = (delay_timestamp - base::TimeTicks()).InMicroseconds();
+  buffer->params.delay_timestamp =
+      (delay_timestamp - base::TimeTicks()).InMicroseconds();
 
   // Zero out the entire output buffer to avoid stuttering/repeating-buffers
   // in the anomalous case if the renderer is unable to keep up with real-time.
@@ -281,12 +277,11 @@ bool AudioSyncReader::WaitUntilDataIsReady() {
     UMA_HISTOGRAM_CUSTOM_TIMES("Media.AudioOutputControllerDataNotReady",
                                time_since_start,
                                base::TimeDelta::FromMilliseconds(1),
-                               base::TimeDelta::FromMilliseconds(1000),
-                               50);
+                               base::TimeDelta::FromMilliseconds(1000), 50);
     return false;
   }
 
   return true;
 }
 
-}  // namespace content
+}  // namespace media

content/browser/renderer_host/media/audio_sync_reader.h → media/audio/audio_sync_reader.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_SYNC_READER_H_
-#define CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_SYNC_READER_H_
+#ifndef MEDIA_AUDIO_AUDIO_SYNC_READER_H_
+#define MEDIA_AUDIO_AUDIO_SYNC_READER_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -17,9 +17,9 @@
 #include "base/sync_socket.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
-#include "content/common/content_export.h"
 #include "media/audio/audio_output_controller.h"
 #include "media/base/audio_bus.h"
+#include "media/base/media_export.h"
 
 #if defined(OS_POSIX)
 #include "base/file_descriptor_posix.h"
@@ -29,20 +29,19 @@ namespace base {
 class SharedMemory;
 }
 
-namespace content {
+namespace media {
 
 // A AudioOutputController::SyncReader implementation using SyncSocket. This
 // is used by AudioOutputController to provide a low latency data source for
 // transmitting audio packets between the browser process and the renderer
 // process.
-class CONTENT_EXPORT AudioSyncReader
-    : public media::AudioOutputController::SyncReader {
+class MEDIA_EXPORT AudioSyncReader : public AudioOutputController::SyncReader {
  public:
   // Create() automatically initializes the AudioSyncReader correctly,
   // and should be strongly preferred over calling the constructor directly!
   AudioSyncReader(
       base::RepeatingCallback<void(const std::string&)> log_callback,
-      const media::AudioParameters& params,
+      const AudioParameters& params,
       std::unique_ptr<base::SharedMemory> shared_memory,
       std::unique_ptr<base::CancelableSyncSocket> socket);
 
@@ -51,18 +50,18 @@ class CONTENT_EXPORT AudioSyncReader
   // Returns null on failure.
   static std::unique_ptr<AudioSyncReader> Create(
       base::RepeatingCallback<void(const std::string&)> log_callback,
-      const media::AudioParameters& params,
+      const AudioParameters& params,
       base::CancelableSyncSocket* foreign_socket);
 
   const base::SharedMemory* shared_memory() const {
     return shared_memory_.get();
   }
 
-  // media::AudioOutputController::SyncReader implementations.
+  // AudioOutputController::SyncReader implementations.
   void RequestMoreData(base::TimeDelta delay,
                        base::TimeTicks delay_timestamp,
                        int prior_frames_skipped) override;
-  void Read(media::AudioBus* dest) override;
+  void Read(AudioBus* dest) override;
   void Close() override;
 
  private:
@@ -88,7 +87,7 @@ class CONTENT_EXPORT AudioSyncReader
   const uint32_t output_bus_buffer_size_;
 
   // Shared memory wrapper used for transferring audio data to Read() callers.
-  std::unique_ptr<media::AudioBus> output_bus_;
+  std::unique_ptr<AudioBus> output_bus_;
 
   // Track the number of times the renderer missed its real-time deadline and
   // report a UMA stat during destruction.
@@ -107,6 +106,6 @@ class CONTENT_EXPORT AudioSyncReader
   DISALLOW_COPY_AND_ASSIGN(AudioSyncReader);
 };
 
-}  // namespace content
+}  // namespace media
 
-#endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_SYNC_READER_H_
+#endif  // MEDIA_AUDIO_AUDIO_SYNC_READER_H_

content/browser/renderer_host/media/audio_sync_reader_unittest.cc → media/audio/audio_sync_reader_unittest.cc

@@ -2,7 +2,7 @@
 // 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_sync_reader.h"
+#include "media/audio/audio_sync_reader.h"
 
 #include <limits>
 #include <memory>
@@ -21,13 +21,13 @@
 
 using ::testing::TestWithParam;
 
-namespace content {
+namespace media {
 
 void NoLog(const std::string&) {}
 
 static_assert(
-    std::is_unsigned<decltype(
-        media::AudioOutputBufferParameters::bitstream_data_size)>::value,
+    std::is_unsigned<
+        decltype(AudioOutputBufferParameters::bitstream_data_size)>::value,
     "If |bitstream_data_size| is ever made signed, add tests for negative "
     "buffer sizes.");
 
@@ -55,17 +55,17 @@ TEST_P(AudioSyncReaderBitstreamTest, BitstreamBufferOverflow_DoesNotWriteOOB) {
   const int kSampleRate = 44100;
   const int kBitsPerSample = 32;
   const int kFramesPerBuffer = 1;
-  media::AudioParameters params(media::AudioParameters::AUDIO_BITSTREAM_AC3,
-                                media::CHANNEL_LAYOUT_STEREO, kSampleRate,
-                                kBitsPerSample, kFramesPerBuffer);
+  AudioParameters params(AudioParameters::AUDIO_BITSTREAM_AC3,
+                         CHANNEL_LAYOUT_STEREO, kSampleRate, kBitsPerSample,
+                         kFramesPerBuffer);
 
   auto socket = std::make_unique<base::CancelableSyncSocket>();
-  std::unique_ptr<media::AudioBus> output_bus = media::AudioBus::Create(params);
+  std::unique_ptr<AudioBus> output_bus = AudioBus::Create(params);
   std::unique_ptr<AudioSyncReader> reader = AudioSyncReader::Create(
       base::BindRepeating(&NoLog), params, socket.get());
   const base::SharedMemory* shmem = reader->shared_memory();
-  media::AudioOutputBuffer* buffer =
-      reinterpret_cast<media::AudioOutputBuffer*>(shmem->memory());
+  AudioOutputBuffer* buffer =
+      reinterpret_cast<AudioOutputBuffer*>(shmem->memory());
   reader->RequestMoreData(base::TimeDelta(), base::TimeTicks(), 0);
 
   uint32_t signal;
@@ -80,16 +80,15 @@ TEST_P(AudioSyncReaderBitstreamTest, BitstreamBufferOverflow_DoesNotWriteOOB) {
       break;
     case kNoOverflow:
       buffer->params.bitstream_data_size =
-          shmem->mapped_size() - sizeof(media::AudioOutputBufferParameters);
+          shmem->mapped_size() - sizeof(AudioOutputBufferParameters);
       break;
     case kOverflowByOne:
       buffer->params.bitstream_data_size =
-          shmem->mapped_size() - sizeof(media::AudioOutputBufferParameters) + 1;
+          shmem->mapped_size() - sizeof(AudioOutputBufferParameters) + 1;
       break;
     case kOverflowByOneThousand:
       buffer->params.bitstream_data_size =
-          shmem->mapped_size() - sizeof(media::AudioOutputBufferParameters) +
-          1000;
+          shmem->mapped_size() - sizeof(AudioOutputBufferParameters) + 1000;
       break;
     case kOverflowByMax:
       buffer->params.bitstream_data_size = std::numeric_limits<decltype(
@@ -109,4 +108,4 @@ INSTANTIATE_TEST_CASE_P(AudioSyncReaderTest,
                         AudioSyncReaderBitstreamTest,
                         ::testing::ValuesIn(overflow_test_case_values));
 
-}  // namespace content
+}  // namespace media