Change AudioLog in delegates to raw pointer.

Also rearrange parameter ordering in AIDI::Create. Both of these
changes are to simplify callback binding for the new factory in
https://chromium-review.googlesource.com/c/chromium/src/+/771196.

Bug: 653871
Change-Id: I825b519e664c0e4cafecff85f199d3bc145c8fda
Reviewed-on: https://chromium-review.googlesource.com/795970
Commit-Queue: Max Morin <maxmorin@chromium.org>
Reviewed-by: Olga Sharonova <olka@chromium.org>
Cr-Commit-Position: refs/heads/master@{#522074}

content/browser/renderer_host/media/audio_input_delegate_impl.cc

@@ -100,20 +100,20 @@ class AudioInputDelegateImpl::ControllerEventHandler
 };
 
 std::unique_ptr<media::AudioInputDelegate> AudioInputDelegateImpl::Create(
-    EventHandler* subscriber,
     media::AudioManager* audio_manager,
     AudioMirroringManager* mirroring_manager,
     media::UserInputMonitor* user_input_monitor,
+    int render_process_id,
+    int render_frame_id,
     AudioInputDeviceManager* audio_input_device_manager,
-    std::unique_ptr<media::AudioLog> audio_log,
+    media::AudioLog* audio_log,
     AudioInputDeviceManager::KeyboardMicRegistration keyboard_mic_registration,
     uint32_t shared_memory_count,
     int stream_id,
     int session_id,
-    int render_process_id,
-    int render_frame_id,
     bool automatic_gain_control,
-    const media::AudioParameters& audio_parameters) {
+    const media::AudioParameters& audio_parameters,
+    EventHandler* subscriber) {
   // Check if we have the permission to open the device and which device to use.
   const MediaStreamDevice* device =
       audio_input_device_manager->GetOpenedDeviceById(session_id);
@@ -148,34 +148,33 @@ std::unique_ptr<media::AudioInputDelegate> AudioInputDelegateImpl::Create(
                          automatic_gain_control));
 
   return base::WrapUnique(new AudioInputDelegateImpl(
-      subscriber, audio_manager, mirroring_manager, user_input_monitor,
-      possibly_modified_parameters, std::move(writer),
-      std::move(foreign_socket), std::move(audio_log),
-      std::move(keyboard_mic_registration),
-      stream_id, render_process_id, render_frame_id, automatic_gain_control,
-      device));
+      audio_manager, mirroring_manager, user_input_monitor,
+      possibly_modified_parameters, render_process_id, render_frame_id,
+      audio_log, std::move(keyboard_mic_registration), stream_id,
+      automatic_gain_control, subscriber, device, std::move(writer),
+      std::move(foreign_socket)));
 }
 
 AudioInputDelegateImpl::AudioInputDelegateImpl(
-    EventHandler* subscriber,
     media::AudioManager* audio_manager,
     AudioMirroringManager* mirroring_manager,
     media::UserInputMonitor* user_input_monitor,
     const media::AudioParameters& audio_parameters,
-    std::unique_ptr<AudioInputSyncWriter> writer,
-    std::unique_ptr<base::CancelableSyncSocket> foreign_socket,
-    std::unique_ptr<media::AudioLog> audio_log,
-    AudioInputDeviceManager::KeyboardMicRegistration keyboard_mic_registration,
-    int stream_id,
     int render_process_id,
     int render_frame_id,
+    media::AudioLog* audio_log,
+    AudioInputDeviceManager::KeyboardMicRegistration keyboard_mic_registration,
+    int stream_id,
     bool automatic_gain_control,
-    const MediaStreamDevice* device)
+    EventHandler* subscriber,
+    const MediaStreamDevice* device,
+    std::unique_ptr<AudioInputSyncWriter> writer,
+    std::unique_ptr<base::CancelableSyncSocket> foreign_socket)
     : subscriber_(subscriber),
       controller_event_handler_(),
       writer_(std::move(writer)),
       foreign_socket_(std::move(foreign_socket)),
-      audio_log_(std::move(audio_log)),
+      audio_log_(audio_log),
       controller_(),
       keyboard_mic_registration_(std::move(keyboard_mic_registration)),
       stream_id_(stream_id),
@@ -227,7 +226,7 @@ AudioInputDelegateImpl::AudioInputDelegateImpl(
 
   audio_log_->OnCreated(stream_id, audio_parameters, device_id);
   MediaInternals::GetInstance()->SetWebContentsTitleForAudioLogEntry(
-      stream_id, render_process_id_, render_frame_id, audio_log_.get());
+      stream_id, render_process_id_, render_frame_id, audio_log_);
 }
 
 AudioInputDelegateImpl::~AudioInputDelegateImpl() {

content/browser/renderer_host/media/audio_input_delegate_impl.h

@@ -37,21 +37,21 @@ class CONTENT_EXPORT AudioInputDelegateImpl : public media::AudioInputDelegate {
   ~AudioInputDelegateImpl() override;
 
   static std::unique_ptr<media::AudioInputDelegate> Create(
-      EventHandler* subscriber,
       media::AudioManager* audio_manager,
       AudioMirroringManager* mirroring_manager,
       media::UserInputMonitor* user_input_monitor,
+      int render_process_id,
+      int render_frame_id,
       AudioInputDeviceManager* audio_input_device_manager,
-      std::unique_ptr<media::AudioLog> audio_log,
+      media::AudioLog* audio_log,
       AudioInputDeviceManager::KeyboardMicRegistration
           keyboard_mic_registration,
       uint32_t shared_memory_count,
       int stream_id,
       int session_id,
-      int render_process_id,
-      int render_frame_id,
       bool automatic_gain_control,
-      const media::AudioParameters& audio_parameters);
+      const media::AudioParameters& audio_parameters,
+      EventHandler* subscriber);
 
   // AudioInputDelegate implementation.
   int GetStreamId() override;
@@ -60,21 +60,21 @@ class CONTENT_EXPORT AudioInputDelegateImpl : public media::AudioInputDelegate {
 
  private:
   AudioInputDelegateImpl(
-      EventHandler* subscriber,
       media::AudioManager* audio_manager,
       AudioMirroringManager* mirroring_manager,
       media::UserInputMonitor* user_input_monitor,
       const media::AudioParameters& audio_parameters,
-      std::unique_ptr<AudioInputSyncWriter> writer,
-      std::unique_ptr<base::CancelableSyncSocket> foreign_socket,
-      std::unique_ptr<media::AudioLog> audio_log,
+      int render_process_id,
+      int render_frame_id,
+      media::AudioLog* audio_log,
       AudioInputDeviceManager::KeyboardMicRegistration
           keyboard_mic_registration,
       int stream_id,
-      int render_process_id,
-      int render_frame_id,
       bool automatic_gain_control,
-      const MediaStreamDevice* device);
+      EventHandler* subscriber,
+      const MediaStreamDevice* device,
+      std::unique_ptr<AudioInputSyncWriter> writer,
+      std::unique_ptr<base::CancelableSyncSocket> foreign_socket);
 
   void SendCreatedNotification(bool initially_muted);
   void OnMuted(bool is_muted);
@@ -91,7 +91,7 @@ class CONTENT_EXPORT AudioInputDelegateImpl : public media::AudioInputDelegate {
   std::unique_ptr<ControllerEventHandler> controller_event_handler_;
   std::unique_ptr<AudioInputSyncWriter> writer_;
   std::unique_ptr<base::CancelableSyncSocket> foreign_socket_;
-  const std::unique_ptr<media::AudioLog> audio_log_;
+  media::AudioLog* const audio_log_;
   scoped_refptr<media::AudioInputController> controller_;
   const AudioInputDeviceManager::KeyboardMicRegistration
       keyboard_mic_registration_;

content/browser/renderer_host/media/audio_input_delegate_impl_unittest.cc

@@ -147,7 +147,9 @@ class AudioInputDelegateTest : public testing::Test {
       : thread_bundle_(base::in_place),
         audio_manager_(std::make_unique<media::TestAudioThread>()),
         audio_system_(&audio_manager_),
-        media_stream_manager_(&audio_system_, audio_manager_.GetTaskRunner()) {
+        media_stream_manager_(&audio_system_, audio_manager_.GetTaskRunner()),
+        audio_log_(MediaInternals::GetInstance()->CreateAudioLog(
+            media::AudioLogFactory::AUDIO_INPUT_CONTROLLER)) {
     audio_manager_.SetMakeInputStreamCB(
         base::BindRepeating(&ExpectNoInputStreamCreation));
     audio_manager_.SetMakeOutputStreamCB(
@@ -177,14 +179,12 @@ class AudioInputDelegateTest : public testing::Test {
       int session_id,
       bool enable_agc) {
     return AudioInputDelegateImpl::Create(
-        &event_handler_, &audio_manager_, AudioMirroringManager::GetInstance(),
-        &user_input_monitor_,
-        media_stream_manager_.audio_input_device_manager(),
-        MediaInternals::GetInstance()->CreateAudioLog(
-            media::AudioLogFactory::AudioComponent::AUDIO_INPUT_CONTROLLER),
-        AudioInputDeviceManager::KeyboardMicRegistration(),
-        shared_memory_count, kStreamId, session_id, kRenderProcessId,
-        kRenderFrameId, enable_agc, ValidAudioParameters());
+        &audio_manager_, AudioMirroringManager::GetInstance(),
+        &user_input_monitor_, kRenderProcessId, kRenderFrameId,
+        media_stream_manager_.audio_input_device_manager(), audio_log_.get(),
+        AudioInputDeviceManager::KeyboardMicRegistration(), shared_memory_count,
+        kStreamId, session_id, enable_agc, ValidAudioParameters(),
+        &event_handler_);
   }
 
   base::Optional<TestBrowserThreadBundle> thread_bundle_;
@@ -193,6 +193,7 @@ class AudioInputDelegateTest : public testing::Test {
   MediaStreamManager media_stream_manager_;
   NiceMock<MockUserInputMonitor> user_input_monitor_;
   StrictMock<MockEventHandler> event_handler_;
+  std::unique_ptr<media::AudioLog> audio_log_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AudioInputDelegateTest);

content/browser/renderer_host/media/audio_input_renderer_host.cc

@@ -171,13 +171,12 @@ void AudioInputRendererHost::DoCreateStream(
 
   std::unique_ptr<media::AudioInputDelegate> delegate =
       AudioInputDelegateImpl::Create(
-          this, audio_manager_, audio_mirroring_manager_, user_input_monitor_,
-          media_stream_manager_->audio_input_device_manager(),
-          MediaInternals::GetInstance()->CreateAudioLog(
-              media::AudioLogFactory::AUDIO_INPUT_CONTROLLER),
-          std::move(keyboard_mic_registration),
-          config.shared_memory_count, stream_id, session_id, render_process_id_,
-          render_frame_id, config.automatic_gain_control, config.params);
+          audio_manager_, audio_mirroring_manager_, user_input_monitor_,
+          render_process_id_, render_frame_id,
+          media_stream_manager_->audio_input_device_manager(), audio_log_.get(),
+          std::move(keyboard_mic_registration), config.shared_memory_count,
+          stream_id, session_id, config.automatic_gain_control, config.params,
+          this);
 
   if (!delegate) {
     // Error was logged by AudioInputDelegateImpl::Create.

content/browser/renderer_host/media/audio_input_renderer_host.h

@@ -190,14 +190,14 @@ class CONTENT_EXPORT AudioInputRendererHost
 
   AudioMirroringManager* audio_mirroring_manager_;
 
-  // A map of stream IDs to audio sources.
-  AudioInputDelegateMap delegates_;
-
   // Raw pointer of the UserInputMonitor.
   media::UserInputMonitor* const user_input_monitor_;
 
   std::unique_ptr<media::AudioLog> audio_log_;
 
+  // A map of stream IDs to audio sources.
+  AudioInputDelegateMap delegates_;
+
   DISALLOW_COPY_AND_ASSIGN(AudioInputRendererHost);
 };
 

content/browser/renderer_host/media/audio_output_delegate_impl.cc

@@ -91,7 +91,7 @@ void AudioOutputDelegateImpl::ControllerEventHandler::OnLog(
 std::unique_ptr<media::AudioOutputDelegate> AudioOutputDelegateImpl::Create(
     EventHandler* handler,
     media::AudioManager* audio_manager,
-    std::unique_ptr<media::AudioLog> audio_log,
+    media::AudioLog* audio_log,
     AudioMirroringManager* mirroring_manager,
     MediaObserver* media_observer,
     int stream_id,
@@ -106,10 +106,9 @@ std::unique_ptr<media::AudioOutputDelegate> AudioOutputDelegateImpl::Create(
     return nullptr;
 
   return std::make_unique<AudioOutputDelegateImpl>(
-      std::move(reader), std::move(socket), handler, audio_manager,
-      std::move(audio_log), mirroring_manager, media_observer, stream_id,
-      render_frame_id, render_process_id, params, std::move(observer),
-      output_device_id);
+      std::move(reader), std::move(socket), handler, audio_manager, audio_log,
+      mirroring_manager, media_observer, stream_id, render_frame_id,
+      render_process_id, params, std::move(observer), output_device_id);
 }
 
 AudioOutputDelegateImpl::AudioOutputDelegateImpl(
@@ -117,7 +116,7 @@ AudioOutputDelegateImpl::AudioOutputDelegateImpl(
     std::unique_ptr<base::CancelableSyncSocket> foreign_socket,
     EventHandler* handler,
     media::AudioManager* audio_manager,
-    std::unique_ptr<media::AudioLog> audio_log,
+    media::AudioLog* audio_log,
     AudioMirroringManager* mirroring_manager,
     MediaObserver* media_observer,
     int stream_id,
@@ -127,7 +126,7 @@ AudioOutputDelegateImpl::AudioOutputDelegateImpl(
     media::mojom::AudioOutputStreamObserverPtr observer,
     const std::string& output_device_id)
     : subscriber_(handler),
-      audio_log_(std::move(audio_log)),
+      audio_log_(audio_log),
       reader_(std::move(reader)),
       foreign_socket_(std::move(foreign_socket)),
       mirroring_manager_(mirroring_manager),

content/browser/renderer_host/media/audio_output_delegate_impl.h

@@ -37,7 +37,7 @@ class CONTENT_EXPORT AudioOutputDelegateImpl
   static std::unique_ptr<AudioOutputDelegate> Create(
       EventHandler* handler,
       media::AudioManager* audio_manager,
-      std::unique_ptr<media::AudioLog> audio_log,
+      media::AudioLog* audio_log,
       AudioMirroringManager* mirroring_manager,
       MediaObserver* media_observer,
       int stream_id,
@@ -52,7 +52,7 @@ class CONTENT_EXPORT AudioOutputDelegateImpl
       std::unique_ptr<base::CancelableSyncSocket> foreign_socket,
       EventHandler* handler,
       media::AudioManager* audio_manager,
-      std::unique_ptr<media::AudioLog> audio_log,
+      media::AudioLog* audio_log,
       AudioMirroringManager* mirroring_manager,
       MediaObserver* media_observer,
       int stream_id,
@@ -83,7 +83,7 @@ class CONTENT_EXPORT AudioOutputDelegateImpl
 
   // This is the event handler which |this| send notifications to.
   EventHandler* subscriber_;
-  std::unique_ptr<media::AudioLog> const audio_log_;
+  media::AudioLog* const audio_log_;
   // |controller_event_handler_| proxies events from controller to |this|.
   // |controller_event_handler_|, |reader_| and |mirroring_manager_| will
   // outlive |this|, see the destructor for details.

content/browser/renderer_host/media/audio_output_delegate_impl_unittest.cc

@@ -133,7 +133,10 @@ class AudioOutputDelegateTest : public testing::Test {
 
     audio_manager_.reset(new media::FakeAudioManager(
         std::make_unique<media::AudioThreadImpl>(), &log_factory_));
+    audio_log_ = log_factory_.CreateAudioLog(
+        media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER);
   }
+
   ~AudioOutputDelegateTest() { audio_manager_->Shutdown(); }
 
   mojo::StrongBindingPtr<media::mojom::AudioOutputStreamObserver>
@@ -168,9 +171,8 @@ class AudioOutputDelegateTest : public testing::Test {
       auto reader = AudioSyncReader::Create(Params(), socket.get());
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
-          audio_manager_.get(),
-          log_factory_.CreateAudioLog(
-              media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER),
+          audio_manager_.get(), audio_log_.get(),
+
           &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId,
           kRenderProcessId, Params(), std::move(observer_ptr),
           kDefaultDeviceId);
@@ -211,9 +213,8 @@ class AudioOutputDelegateTest : public testing::Test {
 
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
-          audio_manager_.get(),
-          log_factory_.CreateAudioLog(
-              media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER),
+          audio_manager_.get(), audio_log_.get(),
+
           &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId,
           kRenderProcessId, Params(), std::move(observer_ptr),
           kDefaultDeviceId);
@@ -247,9 +248,8 @@ class AudioOutputDelegateTest : public testing::Test {
       auto reader = AudioSyncReader::Create(Params(), socket.get());
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
-          audio_manager_.get(),
-          log_factory_.CreateAudioLog(
-              media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER),
+          audio_manager_.get(), audio_log_.get(),
+
           &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId,
           kRenderProcessId, Params(), std::move(observer_ptr),
           kDefaultDeviceId);
@@ -284,9 +284,8 @@ class AudioOutputDelegateTest : public testing::Test {
 
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
-          audio_manager_.get(),
-          log_factory_.CreateAudioLog(
-              media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER),
+          audio_manager_.get(), audio_log_.get(),
+
           &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId,
           kRenderProcessId, Params(), std::move(observer_ptr),
           kDefaultDeviceId);
@@ -321,9 +320,8 @@ class AudioOutputDelegateTest : public testing::Test {
 
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
-          audio_manager_.get(),
-          log_factory_.CreateAudioLog(
-              media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER),
+          audio_manager_.get(), audio_log_.get(),
+
           &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId,
           kRenderProcessId, Params(), std::move(observer_ptr),
           kDefaultDeviceId);
@@ -356,9 +354,8 @@ class AudioOutputDelegateTest : public testing::Test {
       auto reader = AudioSyncReader::Create(Params(), socket.get());
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
-          audio_manager_.get(),
-          log_factory_.CreateAudioLog(
-              media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER),
+          audio_manager_.get(), audio_log_.get(),
+
           &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId,
           kRenderProcessId, Params(), std::move(observer_ptr),
           kDefaultDeviceId);
@@ -386,9 +383,8 @@ class AudioOutputDelegateTest : public testing::Test {
       auto reader = AudioSyncReader::Create(Params(), socket.get());
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
-          audio_manager_.get(),
-          log_factory_.CreateAudioLog(
-              media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER),
+          audio_manager_.get(), audio_log_.get(),
+
           &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId,
           kRenderProcessId, Params(), nullptr, kDefaultDeviceId);
 
@@ -423,9 +419,8 @@ class AudioOutputDelegateTest : public testing::Test {
       auto reader = AudioSyncReader::Create(Params(), socket.get());
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
-          audio_manager_.get(),
-          log_factory_.CreateAudioLog(
-              media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER),
+          audio_manager_.get(), audio_log_.get(),
+
           &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId,
           kRenderProcessId, Params(), std::move(observer_ptr),
           kDefaultDeviceId);
@@ -465,11 +460,9 @@ class AudioOutputDelegateTest : public testing::Test {
     auto reader = AudioSyncReader::Create(Params(), socket.get());
     auto delegate = std::make_unique<AudioOutputDelegateImpl>(
         std::move(reader), std::move(socket), &event_handler_,
-        audio_manager_.get(),
-        log_factory_.CreateAudioLog(
-            media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER),
-        &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId,
-        kRenderProcessId, Params(), std::move(observer_ptr), kDefaultDeviceId);
+        audio_manager_.get(), audio_log_.get(), &mirroring_manager_,
+        &media_observer_, kStreamId, kRenderFrameId, kRenderProcessId, Params(),
+        std::move(observer_ptr), kDefaultDeviceId);
 
     delegate->OnPlayStream();
     delegate->GetControllerForTesting()->OnError();
@@ -499,12 +492,9 @@ class AudioOutputDelegateTest : public testing::Test {
       auto reader = AudioSyncReader::Create(Params(), socket.get());
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
-          audio_manager_.get(),
-          log_factory_.CreateAudioLog(
-              media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER),
-          &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId,
-          kRenderProcessId, Params(), std::move(observer_ptr),
-          kDefaultDeviceId);
+          audio_manager_.get(), audio_log_.get(), &mirroring_manager_,
+          &media_observer_, kStreamId, kRenderFrameId, kRenderProcessId,
+          Params(), std::move(observer_ptr), kDefaultDeviceId);
     }
     SyncWithAllThreads();
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done);
@@ -527,9 +517,8 @@ class AudioOutputDelegateTest : public testing::Test {
       auto reader = AudioSyncReader::Create(Params(), socket.get());
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
-          audio_manager_.get(),
-          log_factory_.CreateAudioLog(
-              media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER),
+          audio_manager_.get(), audio_log_.get(),
+
           &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId,
           kRenderProcessId, Params(), std::move(observer_ptr),
           kDefaultDeviceId);
@@ -559,9 +548,8 @@ class AudioOutputDelegateTest : public testing::Test {
       auto reader = AudioSyncReader::Create(Params(), socket.get());
       AudioOutputDelegateImpl delegate(
           std::move(reader), std::move(socket), &event_handler_,
-          audio_manager_.get(),
-          log_factory_.CreateAudioLog(
-              media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER),
+          audio_manager_.get(), audio_log_.get(),
+
           &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId,
           kRenderProcessId, Params(), std::move(observer_ptr),
           kDefaultDeviceId);
@@ -580,6 +568,7 @@ class AudioOutputDelegateTest : public testing::Test {
   StrictMock<MockEventHandler> event_handler_;
   StrictMock<MockObserver> media_observer_;
   media::FakeAudioLogFactory log_factory_;
+  std::unique_ptr<media::AudioLog> audio_log_;
 
  private:
   void SyncWithAllThreads() {

content/browser/renderer_host/media/audio_renderer_host.cc

@@ -27,6 +27,7 @@
 #include "content/public/browser/media_observer.h"
 #include "content/public/browser/render_frame_host.h"
 #include "media/audio/audio_device_description.h"
+#include "media/audio/audio_logging.h"
 #include "media/base/audio_bus.h"
 #include "media/base/limits.h"
 #include "media/mojo/interfaces/audio_output_stream.mojom.h"
@@ -68,8 +69,11 @@ AudioRendererHost::AudioRendererHost(int render_process_id,
       media_stream_manager_(media_stream_manager),
       authorization_handler_(audio_system,
                              media_stream_manager,
-                             render_process_id_) {
+                             render_process_id_),
+      audio_log_(MediaInternals::GetInstance()->CreateAudioLog(
+          media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER)) {
   DCHECK(audio_manager_);
+  DCHECK(audio_log_);
 }
 
 AudioRendererHost::~AudioRendererHost() {
@@ -272,19 +276,16 @@ void AudioRendererHost::OnCreateStream(int stream_id,
   MediaObserver* const media_observer =
       GetContentClient()->browser()->GetMediaObserver();
 
-  MediaInternals* const media_internals = MediaInternals::GetInstance();
-  std::unique_ptr<media::AudioLog> audio_log = media_internals->CreateAudioLog(
-      media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER);
-  audio_log->OnCreated(stream_id, params, device_unique_id);
-  media_internals->SetWebContentsTitleForAudioLogEntry(
-      stream_id, render_process_id_, render_frame_id, audio_log.get());
-
+  audio_log_->OnCreated(stream_id, params, device_unique_id);
+  MediaInternals::GetInstance()->SetWebContentsTitleForAudioLogEntry(
+      stream_id, render_process_id_, render_frame_id, audio_log_.get());
   media::mojom::AudioOutputStreamObserverPtr observer_ptr;
+
   mojo::MakeStrongBinding(std::make_unique<AudioOutputStreamObserverImpl>(
                               render_process_id_, render_frame_id, stream_id),
                           mojo::MakeRequest(&observer_ptr));
   auto delegate = AudioOutputDelegateImpl::Create(
-      this, audio_manager_, std::move(audio_log), mirroring_manager_,
+      this, audio_manager_, audio_log_.get(), mirroring_manager_,
       media_observer, stream_id, render_frame_id, render_process_id_, params,
       std::move(observer_ptr), device_unique_id);
   if (delegate)

content/browser/renderer_host/media/audio_renderer_host.h

@@ -58,6 +58,7 @@ class CancelableSyncSocket;
 }
 
 namespace media {
+class AudioLog;
 class AudioManager;
 class AudioParameters;
 class AudioSystem;
@@ -191,9 +192,6 @@ class CONTENT_EXPORT AudioRendererHost
   // Used to access to AudioInputDeviceManager.
   MediaStreamManager* media_stream_manager_;
 
-  // A list of the current open streams.
-  AudioOutputDelegateVector delegates_;
-
   // Map of device authorizations for streams that are not yet created
   // The key is the stream ID, and the value is a pair. The pair's first element
   // is a bool that is true if the authorization process completes successfully.
@@ -202,6 +200,11 @@ class CONTENT_EXPORT AudioRendererHost
 
   AudioOutputAuthorizationHandler authorization_handler_;
 
+  const std::unique_ptr<media::AudioLog> audio_log_;
+
+  // A list of the current open streams.
+  AudioOutputDelegateVector delegates_;
+
   DISALLOW_COPY_AND_ASSIGN(AudioRendererHost);
 };
 

content/browser/renderer_host/media/renderer_audio_output_stream_factory_context_impl.cc

@@ -30,6 +30,8 @@ RendererAudioOutputStreamFactoryContextImpl::
       authorization_handler_(audio_system_,
                              media_stream_manager_,
                              render_process_id),
+      audio_log_(MediaInternals::GetInstance()->CreateAudioLog(
+          media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER)),
       render_process_id_(render_process_id) {}
 
 RendererAudioOutputStreamFactoryContextImpl::
@@ -64,15 +66,12 @@ RendererAudioOutputStreamFactoryContextImpl::CreateDelegate(
   MediaObserver* const media_observer =
       GetContentClient()->browser()->GetMediaObserver();
 
-  MediaInternals* const media_internals = MediaInternals::GetInstance();
-  std::unique_ptr<media::AudioLog> audio_log = media_internals->CreateAudioLog(
-      media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER);
-  audio_log->OnCreated(stream_id, params, unique_device_id);
-  media_internals->SetWebContentsTitleForAudioLogEntry(
-      stream_id, render_process_id_, render_frame_id, audio_log.get());
+  audio_log_->OnCreated(stream_id, params, unique_device_id);
+  MediaInternals::GetInstance()->SetWebContentsTitleForAudioLogEntry(
+      stream_id, render_process_id_, render_frame_id, audio_log_.get());
 
   return AudioOutputDelegateImpl::Create(
-      handler, audio_manager_, std::move(audio_log),
+      handler, audio_manager_, audio_log_.get(),
       AudioMirroringManager::GetInstance(), media_observer, stream_id,
       render_frame_id, render_process_id_, params, std::move(stream_observer),
       unique_device_id);

content/browser/renderer_host/media/renderer_audio_output_stream_factory_context_impl.h

@@ -12,6 +12,7 @@
 #include "content/browser/renderer_host/media/render_frame_audio_output_stream_factory.h"
 #include "content/browser/renderer_host/media/renderer_audio_output_stream_factory_context.h"
 #include "content/public/browser/browser_thread.h"
+#include "media/audio/audio_logging.h"
 
 namespace media {
 class AudioManager;
@@ -77,6 +78,7 @@ class CONTENT_EXPORT RendererAudioOutputStreamFactoryContextImpl
   media::AudioManager* const audio_manager_;
   MediaStreamManager* const media_stream_manager_;
   const AudioOutputAuthorizationHandler authorization_handler_;
+  const std::unique_ptr<media::AudioLog> audio_log_;
   const int render_process_id_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererAudioOutputStreamFactoryContextImpl);