APM move: Add AudioSourceParameters to AudioDeviceFactory et al

Putting parameters in a struct like this will make it easier to change
parameters going forward, as it should be less necessary to update
implementations that don't care about certain parameters.

This CL also adds processing configuration as a new, optional
audio source parameter to this struct. It is used to configure audio
processing when it's supported directly in the source, as will be the
case in the audio service.

For an outline of the project this CL is part of, see: https://docs.google.com/document/d/1u4POff_ts_1LE3WDLA_wDDFnUswdlsuHL5DsiTE0a3U/edit?usp=sharing
It's accessible to everyone @chromium.org.

Bug: 851959

Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;luci.chromium.try:linux_optional_gpu_tests_rel;luci.chromium.try:mac_optional_gpu_tests_rel;luci.chromium.try:win_optional_gpu_tests_rel
Change-Id: Ibdcddf1bfc741467dcab68776872c6fcda0f43ad
Reviewed-on: https://chromium-review.googlesource.com/1167849
Commit-Queue: Oskar Sundbom <ossu@chromium.org>
Reviewed-by: Nasko Oskov <nasko@chromium.org>
Reviewed-by: Dale Curtis <dalecurtis@chromium.org>
Reviewed-by: Yuri Wiitala <miu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#584025}

content/renderer/media/audio/audio_device_factory.cc

@@ -158,19 +158,19 @@ AudioDeviceFactory::NewSwitchableAudioRendererSink(
 
 // static
 scoped_refptr<media::AudioCapturerSource>
-AudioDeviceFactory::NewAudioCapturerSource(int render_frame_id,
-                                           int session_id) {
+AudioDeviceFactory::NewAudioCapturerSource(
+    int render_frame_id,
+    const media::AudioSourceParameters& params) {
   if (factory_) {
     // We don't pass on |session_id|, as this branch is only used for tests.
     scoped_refptr<media::AudioCapturerSource> source =
-        factory_->CreateAudioCapturerSource(render_frame_id);
+        factory_->CreateAudioCapturerSource(render_frame_id, params);
     if (source)
       return source;
   }
 
   return base::MakeRefCounted<media::AudioInputDevice>(
-      AudioInputIPCFactory::get()->CreateAudioInputIPC(render_frame_id,
-                                                       session_id),
+      AudioInputIPCFactory::get()->CreateAudioInputIPC(render_frame_id, params),
       base::ThreadPriority::REALTIME_AUDIO);
 }
 

content/renderer/media/audio/audio_device_factory.h

@@ -12,6 +12,7 @@
 #include "base/memory/ref_counted.h"
 #include "content/common/content_export.h"
 #include "media/audio/audio_sink_parameters.h"
+#include "media/audio/audio_source_parameters.h"
 #include "media/base/audio_latency.h"
 #include "media/base/output_device_info.h"
 
@@ -86,7 +87,7 @@ class CONTENT_EXPORT AudioDeviceFactory {
   // consuming the audio.
   static scoped_refptr<media::AudioCapturerSource> NewAudioCapturerSource(
       int render_frame_id,
-      int session_id);
+      const media::AudioSourceParameters& params);
 
  protected:
   AudioDeviceFactory();
@@ -115,7 +116,8 @@ class CONTENT_EXPORT AudioDeviceFactory {
       const media::AudioSinkParameters& params) = 0;
 
   virtual scoped_refptr<media::AudioCapturerSource> CreateAudioCapturerSource(
-      int render_frame_id) = 0;
+      int render_frame_id,
+      const media::AudioSourceParameters& params) = 0;
 
  private:
   // The current globally registered factory. This is NULL when we should

content/renderer/media/audio/audio_input_ipc_factory.cc

@@ -20,31 +20,33 @@ namespace {
 
 void CreateMojoAudioInputStreamOnMainThread(
     int frame_id,
-    int32_t session_id,
+    const media::AudioSourceParameters& source_params,
     mojom::RendererAudioInputStreamFactoryClientPtr client,
     const media::AudioParameters& params,
     bool automatic_gain_control,
     uint32_t total_segments) {
+  // TODO(ossu): Make an AudioProcessingConfig from params and send that along.
   RenderFrameImpl* frame = RenderFrameImpl::FromRoutingID(frame_id);
   if (frame) {
     frame->GetAudioInputStreamFactory()->CreateStream(
-        std::move(client), session_id, params, automatic_gain_control,
-        total_segments);
+        std::move(client), source_params.session_id, params,
+        automatic_gain_control, total_segments);
   }
 }
 
 void CreateMojoAudioInputStream(
     scoped_refptr<base::SequencedTaskRunner> main_task_runner,
     int frame_id,
-    int32_t session_id,
+    const media::AudioSourceParameters& source_params,
     mojom::RendererAudioInputStreamFactoryClientPtr client,
     const media::AudioParameters& params,
     bool automatic_gain_control,
     uint32_t total_segments) {
   main_task_runner->PostTask(
-      FROM_HERE, base::BindOnce(&CreateMojoAudioInputStreamOnMainThread,
-                                frame_id, session_id, std::move(client), params,
-                                automatic_gain_control, total_segments));
+      FROM_HERE,
+      base::BindOnce(&CreateMojoAudioInputStreamOnMainThread, frame_id,
+                     source_params, std::move(client), params,
+                     automatic_gain_control, total_segments));
 }
 
 void AssociateInputAndOutputForAec(
@@ -86,11 +88,11 @@ AudioInputIPCFactory::~AudioInputIPCFactory() {
 
 std::unique_ptr<media::AudioInputIPC> AudioInputIPCFactory::CreateAudioInputIPC(
     int frame_id,
-    int session_id) const {
-  DCHECK_NE(0, session_id);
+    const media::AudioSourceParameters& source_params) const {
+  DCHECK_NE(0, source_params.session_id);
   return std::make_unique<MojoAudioInputIPC>(
       base::BindRepeating(&CreateMojoAudioInputStream, main_task_runner_,
-                          frame_id, session_id),
+                          frame_id, source_params),
       base::BindRepeating(&AssociateInputAndOutputForAec, main_task_runner_,
                           frame_id));
 }

content/renderer/media/audio/audio_input_ipc_factory.h

@@ -10,6 +10,7 @@
 #include "base/containers/flat_map.h"
 #include "base/memory/ref_counted.h"
 #include "content/common/content_export.h"
+#include "media/audio/audio_source_parameters.h"
 
 namespace base {
 class SequencedTaskRunner;
@@ -43,7 +44,7 @@ class CONTENT_EXPORT AudioInputIPCFactory {
   // The returned object may only be used on io_task_runner().
   std::unique_ptr<media::AudioInputIPC> CreateAudioInputIPC(
       int frame_id,
-      int session_id) const;
+      const media::AudioSourceParameters& source_params) const;
 
  private:
   const scoped_refptr<base::SequencedTaskRunner> main_task_runner_;

content/renderer/media/audio/mock_audio_device_factory.cc

@@ -22,7 +22,9 @@ MockAudioDeviceFactory::MockAudioDeviceFactory()
 MockAudioDeviceFactory::~MockAudioDeviceFactory() {}
 
 scoped_refptr<media::AudioCapturerSource>
-MockAudioDeviceFactory::CreateAudioCapturerSource(int render_frame_id) {
+MockAudioDeviceFactory::CreateAudioCapturerSource(
+    int render_frame_id,
+    const media::AudioSourceParameters& params) {
   CHECK(!did_create_once_);
   did_create_once_ = true;
   return scoped_refptr<media::AudioCapturerSource>(mock_capturer_source_);

content/renderer/media/audio/mock_audio_device_factory.h

@@ -64,7 +64,8 @@ class MockAudioDeviceFactory : public AudioDeviceFactory {
   // Returns mock_capturer_source_ once. If called a second time, the process
   // will crash.
   scoped_refptr<media::AudioCapturerSource> CreateAudioCapturerSource(
-      int render_frame_id) override;
+      int render_frame_id,
+      const media::AudioSourceParameters& params) override;
 
  private:
   scoped_refptr<MockCapturerSource> mock_capturer_source_;

content/renderer/media/renderer_webaudiodevice_impl_unittest.cc

@@ -80,8 +80,10 @@ class RendererWebAudioDeviceImplTest
     webaudio_device_->SetMediaTaskRunnerForTesting(message_loop_.task_runner());
   }
 
-  MOCK_METHOD1(CreateAudioCapturerSource,
-               scoped_refptr<media::AudioCapturerSource>(int));
+  MOCK_METHOD2(CreateAudioCapturerSource,
+               scoped_refptr<media::AudioCapturerSource>(
+                   int,
+                   const media::AudioSourceParameters&));
   MOCK_METHOD2(CreateFinalAudioRendererSink,
                scoped_refptr<media::AudioRendererSink>(
                    int,

content/renderer/media/stream/local_media_stream_audio_source.cc

@@ -66,7 +66,8 @@ bool LocalMediaStreamAudioSource::EnsureSourceIsStarted() {
           << GetAudioParameters().AsHumanReadableString() << "}.";
 
   source_ = AudioDeviceFactory::NewAudioCapturerSource(
-      consumer_render_frame_id_, device().session_id);
+      consumer_render_frame_id_,
+      media::AudioSourceParameters(device().session_id));
   source_->Initialize(GetAudioParameters(), this);
   source_->Start();
   return true;

content/renderer/media/stream/processed_local_audio_source.cc

@@ -203,8 +203,9 @@ bool ProcessedLocalAudioSource::EnsureSourceIsStarted() {
           << params.AsHumanReadableString() << "} and output parameters={"
           << GetAudioParameters().AsHumanReadableString() << '}';
   scoped_refptr<media::AudioCapturerSource> new_source =
-      AudioDeviceFactory::NewAudioCapturerSource(consumer_render_frame_id_,
-                                                 device().session_id);
+      AudioDeviceFactory::NewAudioCapturerSource(
+          consumer_render_frame_id_,
+          media::AudioSourceParameters(device().session_id));
   new_source->Initialize(params, this);
   // We need to set the AGC control before starting the stream.
   new_source->SetAutomaticGainControl(true);

content/renderer/media/webrtc/webrtc_audio_renderer_unittest.cc

@@ -83,8 +83,10 @@ class WebRtcAudioRendererTest : public testing::Test,
 
     renderer_proxy_ = renderer_->CreateSharedAudioRendererProxy(stream_);
   }
-  MOCK_METHOD1(CreateAudioCapturerSource,
-               scoped_refptr<media::AudioCapturerSource>(int));
+  MOCK_METHOD2(CreateAudioCapturerSource,
+               scoped_refptr<media::AudioCapturerSource>(
+                   int,
+                   const media::AudioSourceParameters&));
   MOCK_METHOD2(CreateFinalAudioRendererSink,
                scoped_refptr<media::AudioRendererSink>(
                    int,

content/renderer/pepper/pepper_platform_audio_input.cc

@@ -176,8 +176,8 @@ void PepperPlatformAudioInput::InitializeOnIOThread(int session_id) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (ipc_startup_state_ != kStopped)
-    ipc_ = AudioInputIPCFactory::get()->CreateAudioInputIPC(render_frame_id_,
-                                                            session_id);
+    ipc_ = AudioInputIPCFactory::get()->CreateAudioInputIPC(
+        render_frame_id_, media::AudioSourceParameters(session_id));
   if (!ipc_)
     return;
 

media/audio/BUILD.gn

@@ -127,6 +127,8 @@ source_set("audio") {
     "audio_sink_parameters.cc",
     "audio_sink_parameters.h",
     "audio_source_diverter.h",
+    "audio_source_parameters.cc",
+    "audio_source_parameters.h",
     "audio_sync_reader.cc",
     "audio_sync_reader.h",
     "audio_system.cc",

media/audio/audio_input_device.cc

@@ -218,6 +218,9 @@ void AudioInputDevice::OnStreamCreated(
   if (initially_muted)
     callback_->OnCaptureMuted(true);
 
+  if (auto* controls = ipc_->GetProcessorControls())
+    callback_->OnCaptureProcessorCreated(controls);
+
   if (output_device_id_for_aec_)
     ipc_->SetOutputDeviceForAec(*output_device_id_for_aec_);
 

media/audio/audio_input_ipc.cc

@@ -10,4 +10,8 @@ AudioInputIPCDelegate::~AudioInputIPCDelegate() = default;
 
 AudioInputIPC::~AudioInputIPC() = default;
 
+AudioProcessorControls* AudioInputIPC::GetProcessorControls() {
+  return nullptr;
+}
+
 }  // namespace media

media/audio/audio_input_ipc.h

@@ -14,6 +14,8 @@
 
 namespace media {
 
+class AudioProcessorControls;
+
 // Contains IPC notifications for the state of the server side
 // (AudioInputController) audio state changes and when an AudioInputController
 // has been created.  Implemented by AudioInputDevice.
@@ -72,6 +74,10 @@ class MEDIA_EXPORT AudioInputIPC {
   // called before the stream has been successfully created.
   virtual void SetOutputDeviceForAec(const std::string& output_device_id) = 0;
 
+  // If the input has built-in processing, returns a pointer to processing
+  // controls. Valid after the stream has been created.
+  virtual AudioProcessorControls* GetProcessorControls();
+
   // Closes the audio stream, which should shut down the corresponding
   // AudioInputController in the peer process.
   virtual void CloseStream() = 0;

media/audio/audio_source_parameters.cc

+// Copyright 2018 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_source_parameters.h"
+
+namespace media {
+
+AudioSourceParameters::AudioSourceParameters() = default;
+AudioSourceParameters::AudioSourceParameters(int session_id)
+    : session_id(session_id) {}
+AudioSourceParameters::AudioSourceParameters(
+    const AudioSourceParameters& params) = default;
+AudioSourceParameters::~AudioSourceParameters() = default;
+
+AudioSourceParameters::ProcessingConfig::ProcessingConfig(
+    base::UnguessableToken id,
+    AudioProcessingSettings settings)
+    : id(id), settings(settings) {
+  DCHECK(!id.is_empty());
+}
+
+}  // namespace media

media/audio/audio_source_parameters.h

+// Copyright 2018 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_SOURCE_PARAMETERS_H_
+#define MEDIA_AUDIO_AUDIO_SOURCE_PARAMETERS_H_
+
+#include <string>
+
+#include "base/optional.h"
+#include "base/unguessable_token.h"
+#include "media/audio/audio_processing.h"
+#include "media/base/media_export.h"
+
+namespace media {
+
+// The set of parameters used to create an AudioInputDevice.
+// If |session_id| is nonzero, it is used by the browser
+// to select the correct input device ID. If |session_id| is zero, the default
+// input device will be selected. This is the state when default constructed.
+struct MEDIA_EXPORT AudioSourceParameters final {
+  AudioSourceParameters();
+  explicit AudioSourceParameters(int session_id);
+  AudioSourceParameters(const AudioSourceParameters& params);
+  ~AudioSourceParameters();
+
+  int session_id = 0;
+
+  struct ProcessingConfig {
+    ProcessingConfig(base::UnguessableToken id,
+                     AudioProcessingSettings settings);
+    base::UnguessableToken id;
+    AudioProcessingSettings settings;
+  };
+
+  base::Optional<ProcessingConfig> processing;
+};
+
+}  // namespace media
+
+#endif  // MEDIA_AUDIO_AUDIO_SOURCE_PARAMETERS_H_

media/base/audio_capturer_source.h

@@ -14,6 +14,8 @@
 
 namespace media {
 
+class AudioProcessorControls;
+
 // AudioCapturerSource is an interface representing the source for
 // captured audio.  An implementation will periodically call Capture() on a
 // callback object.
@@ -45,6 +47,10 @@ class AudioCapturerSource
     // OnCaptureStarted.
     virtual void OnCaptureMuted(bool is_muted) = 0;
 
+    // For streams created with audio processing, signals that a controllable
+    // audio processor has been created.
+    virtual void OnCaptureProcessorCreated(AudioProcessorControls* controls) {}
+
    protected:
     virtual ~CaptureCallback() {}
   };