Factor out AudioOutputDelegate from AudioRendererHost.

content/browser/renderer_host/media/audio_output_delegate.cc

+// 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,
+    std::unique_ptr<media::AudioLog> audio_log,
+    AudioMirroringManager* mirroring_manager,
+    MediaObserver* media_observer,
+    int stream_id,
+    int render_frame_id,
+    int render_process_id,
+    media::AudioParameters params,
+    const std::string& output_device_id)
+    : handler_(handler),
+      audio_log_(std::move(audio_log)),
+      mirroring_manager_(mirroring_manager),
+      reader_(AudioSyncReader::Create(params)),
+      controller_(
+          media::AudioOutputController::Create(media::AudioManager::Get(),
+                                               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(controller_);
+  if (media_observer)
+    media_observer->OnCreatingAudioStream(render_process_id_, render_frame_id_);
+  if (mirroring_manager_)
+    mirroring_manager_->AddDiverter(render_process_id_, render_frame_id_,
+                                    controller_.get());
+  audio_log_->OnCreated(stream_id, params, output_device_id);
+  MediaInternals::GetInstance()->SetWebContentsTitleForAudioLogEntry(
+      stream_id_, render_process_id_, render_frame_id_, audio_log_.get());
+}
+
+AudioOutputDelegate::~AudioOutputDelegate() {}
+
+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);
+  controller_->SetVolume(volume);
+  audio_log_->OnSetVolume(stream_id_, volume);
+}
+
+void AudioOutputDelegate::OnCloseStream(
+    std::unique_ptr<AudioOutputDelegate> owned_this) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  weak_factory_.InvalidateWeakPtrs();

[o1ka, 2016/10/25 15:59:41]

Why do you want to do it at this very moment?

[Max Morin, 2016/10/26 09:20:18]

I'll just add a flag instead.

+  if (playing_) {
+    handler_->OnStreamStateChanged(false);
+    playing_ = false;
+  }
+  audio_log_->OnClosed(stream_id_);
+  controller_->Close(base::Bind(&AudioOutputDelegate::FinishClosing,
+                                base::Owned(owned_this.release())));
+}
+
+void AudioOutputDelegate::FinishClosing() {
+  AudioStreamMonitor::StopMonitoringStream(render_process_id_, render_frame_id_,
+                                           stream_id_);
+
+  mirroring_manager_->RemoveDiverter(controller_.get());
+}
+
+void AudioOutputDelegate::OnControllerCreated() {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&AudioOutputDelegate::OnControllerCreated,
+                   weak_factory_.GetWeakPtr()));
+    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 (!playing_) {
+    handler_->OnStreamStateChanged(true);
+    playing_ = true;
+  }
+  AudioStreamMonitor::StartMonitoringStream(
+      render_process_id_, render_frame_id_, stream_id_,
+      base::Bind(&media::AudioOutputController::ReadCurrentPowerAndClip,
+                 controller_));
+}
+
+void AudioOutputDelegate::OnControllerPaused() {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                            base::Bind(&AudioOutputDelegate::OnControllerPaused,
+                                       weak_factory_.GetWeakPtr()));
+    return;
+  }
+
+  if (playing_) {
+    handler_->OnStreamStateChanged(false);
+    playing_ = false;
+  }
+  AudioStreamMonitor::StopMonitoringStream(render_process_id_, render_frame_id_,
+                                           stream_id_);
+}
+
+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_);
+  handler_->OnStreamError(stream_id_);
+}
+
+}  // namespace content