Strip out stream counting from AudioRendererHost.

content/browser/renderer_host/media/audio_renderer_host.cc

 // Copyright (c) 2012 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_renderer_host.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram_macros.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/browser_main_loop.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_input_device_manager.h"
 #include "content/browser/renderer_host/media/audio_sync_reader.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/common/media/audio_messages.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/media_device_id.h"
 #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_streams_tracker.h"
 #include "media/base/audio_bus.h"
 #include "media/base/limits.h"
 
 using media::AudioBus;
 using media::AudioManager;
 
 namespace content {
 
 namespace {
 
-// Tracks the maximum number of simultaneous output streams browser-wide.
-// Accessed on IO thread.
-base::LazyInstance<media::AudioStreamsTracker> g_audio_streams_tracker =
-    LAZY_INSTANCE_INITIALIZER;
-
-void NotifyRenderProcessHostThatAudioStateChanged(int render_process_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  RenderProcessHost* render_process_host =
-      RenderProcessHost::FromID(render_process_id);
-
-  if (render_process_host)
-    render_process_host->AudioStateChanged();
-}
-
 void UMALogDeviceAuthorizationTime(base::TimeTicks auth_start_time) {
   UMA_HISTOGRAM_CUSTOM_TIMES("Media.Audio.OutputDeviceAuthorizationTime",
                              base::TimeTicks::Now() - auth_start_time,
                              base::TimeDelta::FromMilliseconds(1),
                              base::TimeDelta::FromMilliseconds(5000), 50);
 }
 
 // Check that the routing ID references a valid RenderFrameHost, and run
 // |callback| on the IO thread with true if the ID is valid.
 void ValidateRenderFrameId(int render_process_id,
@@ skipping 14 matching lines @@
 AudioRendererHost::AudioRendererHost(int render_process_id,
                                      media::AudioManager* audio_manager,
                                      AudioMirroringManager* mirroring_manager,
                                      MediaStreamManager* media_stream_manager,
                                      const std::string& salt)
     : BrowserMessageFilter(AudioMsgStart),
       render_process_id_(render_process_id),
       audio_manager_(audio_manager),
       mirroring_manager_(mirroring_manager),
       media_stream_manager_(media_stream_manager),
-      num_playing_streams_(0),
       salt_(salt),
       validate_render_frame_id_function_(&ValidateRenderFrameId),
-      max_simultaneous_streams_(0),
       authorization_handler_(audio_manager_,
                              media_stream_manager,
                              render_process_id_,
                              salt) {
   DCHECK(audio_manager_);
 }
 
 AudioRendererHost::~AudioRendererHost() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(delegates_.empty());
-
-  // If we had any streams, report UMA stats for the maximum number of
-  // simultaneous streams for this render process and for the whole browser
-  // process since last reported.
-  if (max_simultaneous_streams_ > 0) {
-    UMA_HISTOGRAM_CUSTOM_COUNTS("Media.AudioRendererIpcStreams",
-                                max_simultaneous_streams_, 1, 50, 51);
-    UMA_HISTOGRAM_CUSTOM_COUNTS(
-        "Media.AudioRendererIpcStreamsTotal",
-        g_audio_streams_tracker.Get().max_stream_count(),
-        1, 100, 101);
-    g_audio_streams_tracker.Get().ResetMaxStreamCount();
-  }
 }
 
 void AudioRendererHost::GetOutputControllers(
     const RenderProcessHost::GetAudioOutputControllersCallback&
         callback) const {
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&AudioRendererHost::DoGetOutputControllers, this), callback);
 }
 
 void AudioRendererHost::OnChannelClosing() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  // Since the IPC sender is gone, close all requested audio streams.
-  // The audio streams tracker isn't automatically decremented since the
-  // removal isn't done through OnCloseStream.
-  g_audio_streams_tracker.Get().DecreaseStreamCount(delegates_.size());
   delegates_.clear();
 
   // Remove any authorizations for streams that were not yet created
   authorizations_.clear();
 }
 
 void AudioRendererHost::OnDestruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
 
@@ skipping 200 matching lines @@
 
   MediaInternals* const media_internals = MediaInternals::GetInstance();
   std::unique_ptr<media::AudioLog> audio_log = media_internals->CreateAudioLog(
       media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER);
   media_internals->SetWebContentsTitleForAudioLogEntry(
       stream_id, render_process_id_, render_frame_id, audio_log.get());
   delegates_.push_back(AudioOutputDelegate::Create(
       this, audio_manager_, std::move(audio_log), mirroring_manager_,
       media_observer, stream_id, render_frame_id, render_process_id_, params,
       device_unique_id));
-
-  g_audio_streams_tracker.Get().IncreaseStreamCount();
-
-  if (delegates_.size() > max_simultaneous_streams_)
-    max_simultaneous_streams_ = delegates_.size();
 }
 
 void AudioRendererHost::OnPlayStream(int stream_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   AudioOutputDelegate* delegate = LookupById(stream_id);
   if (!delegate) {
     SendErrorMessage(stream_id);
     return;
   }
@@ skipping 38 matching lines @@
 
   auto i = LookupIteratorById(stream_id);
 
   // Prevent oustanding callbacks from attempting to close/delete the same
   // AudioOutputDelegate twice.
   if (i == delegates_.end())
     return;
 
   std::swap(*i, delegates_.back());
   delegates_.pop_back();
-
-  g_audio_streams_tracker.Get().DecreaseStreamCount();
 }
 
 AudioRendererHost::AudioOutputDelegateVector::iterator
 AudioRendererHost::LookupIteratorById(int stream_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   return std::find_if(delegates_.begin(), delegates_.end(),
                       [stream_id](const AudioOutputDelegate::UniquePtr& d) {
                         return d->stream_id() == stream_id;
                       });
 }
 
 AudioOutputDelegate* AudioRendererHost::LookupById(int stream_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   auto i = LookupIteratorById(stream_id);
   return i != delegates_.end() ? i->get() : nullptr;
 }
 
-void AudioRendererHost::OnStreamStateChanged(bool is_playing) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (is_playing) {
-    base::AtomicRefCountInc(&num_playing_streams_);
-
-    // Inform the RenderProcessHost when audio starts playing for the first
-    // time. The nonatomic increment-and-read is ok since this is the only
-    // thread that |num_plaing_streams_| may be updated on.
-    if (base::AtomicRefCountIsOne(&num_playing_streams_)) {
-      BrowserThread::PostTask(
-          BrowserThread::UI, FROM_HERE,
-          base::Bind(&NotifyRenderProcessHostThatAudioStateChanged,
-                     render_process_id_));
-    }
-  } else {
-    // Inform the RenderProcessHost when there is no more audio playing.
-    if (!base::AtomicRefCountDec(&num_playing_streams_)) {
-      BrowserThread::PostTask(
-          BrowserThread::UI, FROM_HERE,
-          base::Bind(&NotifyRenderProcessHostThatAudioStateChanged,
-                     render_process_id_));
-    }
-  }
-}
-
 bool AudioRendererHost::IsAuthorizationStarted(int stream_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return authorizations_.find(stream_id) != authorizations_.end();
 }
 
-bool AudioRendererHost::HasActiveAudio() {
-  return !base::AtomicRefCountIsZero(&num_playing_streams_);
-}
-
 void AudioRendererHost::OverrideDevicePermissionsForTesting(bool has_access) {
   authorization_handler_.OverridePermissionsForTesting(has_access);
 }
 }  // namespace content