Factor out AudioOutputDelegate from AudioRendererHost.

content/browser/renderer_host/media/audio_output_delegate.cc

Index: content/browser/renderer_host/media/audio_output_delegate.cc
diff --git a/content/browser/renderer_host/media/audio_output_delegate.cc b/content/browser/renderer_host/media/audio_output_delegate.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8978d49d070286633285a92d03c65d8459388fc3
--- /dev/null
+++ b/content/browser/renderer_host/media/audio_output_delegate.cc
@@ -0,0 +1,201 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/browser/renderer_host/media/audio_output_delegate.h"
+
+#include <utility>
+
+#include "base/bind.h"
+#include "content/browser/media/audio_stream_monitor.h"
+#include "content/browser/media/media_internals.h"
+#include "content/public/browser/browser_thread.h"
+
+namespace content {
+
+AudioOutputDelegate::AudioOutputDelegate(
+    EventHandler* handler,
+    media::AudioManager* audio_manager,
+    std::unique_ptr<media::AudioLog> audio_log,
+    int stream_id,
+    int render_frame_id,
+    int render_process_id,
+    const media::AudioParameters& params,
+    const std::string& output_device_id)
+    : handler_(handler),
+      audio_log_(std::move(audio_log)),
+      reader_(AudioSyncReader::Create(params)),
+      controller_(media::AudioOutputController::Create(audio_manager,
+                                                       this,
+                                                       params,
+                                                       output_device_id,
+                                                       reader_.get())),
+      stream_id_(stream_id),
+      render_frame_id_(render_frame_id),
+      render_process_id_(render_process_id),
+      weak_factory_(this) {
+  DCHECK(handler_);
+  DCHECK(audio_log_);
+  DCHECK(controller_);
+  audio_log_->OnCreated(stream_id, params, output_device_id);
+}
+
+AudioOutputDelegate::~AudioOutputDelegate() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(!playing_);
+  DCHECK(!handler_);
+}
+
+void AudioOutputDelegate::Deleter::operator()(AudioOutputDelegate* delegate) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  delegate->UpdatePlayingState(false);
+  delegate->handler_ = nullptr;
+  delegate->audio_log_->OnClosed(delegate->stream_id_);
+
+  scoped_refptr<media::AudioOutputController> controller =
+      delegate->controller_;
+
+  // |controller| will call the closure (on IO thread) when it's done closing,
+  // and it is only after that call that we can delete |delegate|. By giving the
+  // closure ownership of |delegate|, we keep delegate alive until |controller|
+  // is closed.
+  //
+  // The mirroring manager is a singleton, so Unretained is fine.
+  delegate->controller_->Close(base::Bind(
+      [](AudioOutputDelegate*, AudioMirroringManager* mirroring_manager,
+         scoped_refptr<media::AudioOutputController> controller) {
+        // De-register the controller from the AudioMirroringManager now that
+        // the controller has closed the AudioOutputStream and shut itself down.
+        // This ensures that calling RemoveDiverter() here won't trigger the
+        // controller to re-start the default AudioOutputStream and cause a
+        // brief audio blip to come out the user's speakers.
+        // http://crbug.com/474432
+        if (mirroring_manager)

[o1ka, 2016/11/22 21:48:16]

We need more comments :)
It's ok that RemoveDiverter() won't be called if the callback is destroyed on
message loop destruction
- because |mirroring_manager| is leaky and does not care if there are
unregistered diverters.

[Max Morin, 2016/11/25 15:32:35]

Done.

+          mirroring_manager->RemoveDiverter(controller.get());
+      },
+      base::Owned(delegate), base::Unretained(mirroring_manager_), controller));
+}
+
+// static
+AudioOutputDelegate::UniquePtr AudioOutputDelegate::Create(
+    EventHandler* handler,
+    media::AudioManager* audio_manager,
+    std::unique_ptr<media::AudioLog> audio_log,
+    AudioMirroringManager* mirroring_manager,
+    MediaObserver* media_observer,
+    int stream_id,
+    int render_frame_id,
+    int render_process_id,
+    const media::AudioParameters& params,
+    const std::string& output_device_id) {
+  if (media_observer)
+    media_observer->OnCreatingAudioStream(render_process_id, render_frame_id);
+  UniquePtr delegate = UniquePtr(
+      new AudioOutputDelegate(handler, audio_manager, std::move(audio_log),
+                              stream_id, render_frame_id, render_process_id,
+                              params, output_device_id),
+      Deleter(mirroring_manager));
+  if (mirroring_manager)
+    mirroring_manager->AddDiverter(render_process_id, render_frame_id,
+                                   delegate->controller_.get());
+  return delegate;
+}
+
+void AudioOutputDelegate::OnPlayStream() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  controller_->Play();
+  audio_log_->OnStarted(stream_id_);
+}
+
+void AudioOutputDelegate::OnPauseStream() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  controller_->Pause();
+  audio_log_->OnStopped(stream_id_);
+}
+
+void AudioOutputDelegate::OnSetVolume(double volume) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(volume >= 0 || volume <= 1);

[o1ka, 2016/11/22 21:48:16]

&& ?

[Max Morin, 2016/11/25 15:32:35]

Yes

+  controller_->SetVolume(volume);
+  audio_log_->OnSetVolume(stream_id_, volume);
+}
+
+void AudioOutputDelegate::OnControllerCreated() {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&AudioOutputDelegate::OnControllerCreated,
+                   weak_factory_.GetWeakPtr()));
+    return;
+  }
+  if (!handler_)
+    return;
+
+  handler_->OnStreamCreated(stream_id_, reader_->shared_memory(),
+                            reader_->foreign_socket());
+}
+
+void AudioOutputDelegate::OnControllerPlaying() {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&AudioOutputDelegate::OnControllerPlaying,
+                   weak_factory_.GetWeakPtr()));
+    return;
+  }
+  if (!handler_)
+    return;
+
+  UpdatePlayingState(true);
+}
+
+void AudioOutputDelegate::OnControllerPaused() {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                            base::Bind(&AudioOutputDelegate::OnControllerPaused,
+                                       weak_factory_.GetWeakPtr()));
+    return;
+  }
+  if (!handler_)
+    return;
+
+  UpdatePlayingState(false);
+}
+
+void AudioOutputDelegate::OnControllerError() {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                            base::Bind(&AudioOutputDelegate::OnControllerError,
+                                       weak_factory_.GetWeakPtr()));
+    return;
+  }
+  audio_log_->OnError(stream_id_);
+
+  if (!handler_)
+    return;
+
+  handler_->OnStreamError(stream_id_);
+}
+
+void AudioOutputDelegate::UpdatePlayingState(bool playing) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(handler_);
+  if (playing != playing_) {
+    playing_ = playing;
+    handler_->OnStreamStateChanged(playing_);
+    if (playing) {
+      // Note that this takes a reference to |controller_|, and
+      // (Start|Stop)MonitoringStream calls are async, so we don't have a
+      // guarantee for when the controller is destroyed.
+      AudioStreamMonitor::StartMonitoringStream(
+          render_process_id_, render_frame_id_, stream_id_,
+          base::Bind(&media::AudioOutputController::ReadCurrentPowerAndClip,
+                     controller_));
+    } else {
+      AudioStreamMonitor::StopMonitoringStream(render_process_id_,
+                                               render_frame_id_, stream_id_);
+    }
+  }
+}
+
+}  // namespace content