Add AudioStreamRegistry. Move stream counting logic

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/capture/audio_mirroring_manager.h"
 #include "content/browser/media/media_internals.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"
 
 namespace content {
 
 AudioOutputDelegate::AudioOutputDelegate(
     EventHandler* handler,
+    AudioStreamRegistry* stream_registry,
     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),
+      stream_registry_(stream_registry),
       audio_log_(std::move(audio_log)),
       reader_(AudioSyncReader::Create(params)),
       stream_id_(stream_id),
       render_frame_id_(render_frame_id),
       render_process_id_(render_process_id),
       weak_factory_(this) {
   DCHECK(handler_);
   DCHECK(audio_manager);
   DCHECK(audio_log_);
   weak_this_ = weak_factory_.GetWeakPtr();
   audio_log_->OnCreated(stream_id, params, output_device_id);
+  stream_registry_->RegisterOutputStream(this);
   controller_ = media::AudioOutputController::Create(
       audio_manager, this, params, output_device_id, reader_.get());
   DCHECK(controller_);
 }
 
 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->stream_registry_->DeregisterOutputStream(delegate);
   delegate->handler_ = nullptr;
   delegate->audio_log_->OnClosed(delegate->stream_id_);
 
   // |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 leaky singleton, so Unretained is fine.
   delegate->controller_->Close(base::Bind(
@@ skipping 11 matching lines @@
         // removed.
         if (mirroring_manager)
           mirroring_manager->RemoveDiverter(delegate->controller_.get());
       },
       base::Owned(delegate), base::Unretained(mirroring_manager_)));
 }
 
 // static
 AudioOutputDelegate::UniquePtr AudioOutputDelegate::Create(
     EventHandler* handler,
+    AudioStreamRegistry* stream_registry,
     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(
-      new AudioOutputDelegate(handler, audio_manager, std::move(audio_log),
-                              stream_id, render_frame_id, render_process_id,
-                              params, output_device_id),
+      new AudioOutputDelegate(handler, stream_registry, 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;
 }
 
+#if BUILDFLAG(ENABLE_WEBRTC)
+void AudioOutputDelegate::EnableDebugRecording(
+    const base::FilePath& base_file_name) {}
+
+void AudioOutputDelegate::DisableDebugRecording() {}
+#endif
+
 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_);
@@ skipping 38 matching lines @@
                               reader_->foreign_socket());
   }
 }
 
 void AudioOutputDelegate::UpdatePlayingState(bool playing) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!handler_ || playing == playing_)
     return;
 
   playing_ = playing;
-  handler_->OnStreamStateChanged(playing);
+  stream_registry_->OutputStreamStateChanged(this, 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_);
   }
 }
 
 void AudioOutputDelegate::OnError() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!handler_)
     return;
 
   audio_log_->OnError(stream_id_);
   handler_->OnStreamError(stream_id_);
 }
 
 }  // namespace content