Add audio signal to the ResourceScheduler.

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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/shared_memory.h"
 #include "base/metrics/histogram.h"
 #include "base/process/process.h"
 #include "content/browser/browser_main_loop.h"
+#include "content/browser/loader/resource_dispatcher_host_impl.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_observer.h"
 #include "content/public/common/content_switches.h"
@@ skipping 227 matching lines @@
 
   Send(new AudioMsg_NotifyStreamCreated(
       entry->stream_id(), foreign_memory_handle, socket_descriptor,
       entry->shared_memory()->requested_size()));
 }
 
 void AudioRendererHost::DoNotifyStreamStateChanged(int stream_id,
                                                    bool is_playing) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  AudioEntry* const entry = LookupById(stream_id);
+  AudioEntry* const entry(LookupById(stream_id));
   if (!entry)
     return;
 
   Send(new AudioMsg_NotifyStreamStateChanged(
       stream_id,
       is_playing ? media::AudioOutputIPCDelegate::kPlaying
                  : media::AudioOutputIPCDelegate::kPaused));
 
   if (is_playing) {
     AudioStreamMonitor::StartMonitoringStream(
         render_process_id_,
         entry->render_frame_id(),
         entry->stream_id(),
         base::Bind(&media::AudioOutputController::ReadCurrentPowerAndClip,
                    entry->controller()));
-    // TODO(dalecurtis): See about using AudioStreamMonitor instead.
-    if (!entry->playing()) {
-      entry->set_playing(true);
-      base::AtomicRefCountInc(&num_playing_streams_);
-    }
   } else {
     AudioStreamMonitor::StopMonitoringStream(
         render_process_id_, entry->render_frame_id(), entry->stream_id());
-    // TODO(dalecurtis): See about using AudioStreamMonitor instead.
-    if (entry->playing()) {
-      entry->set_playing(false);
-      base::AtomicRefCountDec(&num_playing_streams_);
-    }
   }
+  UpdateNumPlayingStreams(entry, is_playing);
 }
 
 RenderViewHost::AudioOutputControllerList
 AudioRendererHost::DoGetOutputControllers(int render_view_id) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   RenderViewHost::AudioOutputControllerList controllers;
   AudioEntryMap::const_iterator it = audio_entries_.begin();
   for (; it != audio_entries_.end(); ++it) {
     AudioEntry* entry = it->second;
@@ skipping 147 matching lines @@
     mirroring_manager_->RemoveDiverter(controller);
   controller->Close(
       base::Bind(&AudioRendererHost::DeleteEntry, this, base::Passed(&entry)));
   audio_log_->OnClosed(stream_id);
 }
 
 void AudioRendererHost::DeleteEntry(scoped_ptr<AudioEntry> entry) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   AudioStreamMonitor::StopMonitoringStream(
       render_process_id_, entry->render_frame_id(), entry->stream_id());
-  if (entry->playing())
-    base::AtomicRefCountDec(&num_playing_streams_);
+  UpdateNumPlayingStreams(entry.get(), false);
 }
 
 void AudioRendererHost::ReportErrorAndClose(int stream_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Make sure this isn't a stray callback executing after the stream has been
   // closed, so error notifications aren't sent after clients believe the stream
   // is closed.
   if (!LookupById(stream_id))
     return;
 
   SendErrorMessage(stream_id);
 
   audio_log_->OnError(stream_id);
   OnCloseStream(stream_id);
 }
 
 AudioRendererHost::AudioEntry* AudioRendererHost::LookupById(int stream_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   AudioEntryMap::const_iterator i = audio_entries_.find(stream_id);
   return i != audio_entries_.end() ? i->second : NULL;
 }
 
+void AudioRendererHost::UpdateNumPlayingStreams(AudioEntry* entry,
+                                                bool is_playing) {
+  bool had_active_audio = HasActiveAudio();

[mmenke, 2014/09/18 21:55:51]

This is for the entire renderer process, not a particular RenderView, no? 
That's why the AudioRendererHost has a render_process_id_, but not render view
ID.  So we actually need to go through all entries, and see if we have any
playing with the given render_view_id(Don't technically have to do this if
is_playing is true, since |entry| is such an Entry.

[aiolos (Not reviewing), 2014/09/18 22:23:11]

Ah, good catch. Dale, is there a better way to tell if a specific render view is
playing audio than iterating through the entries or adding book keeping for it?
I don't see one atm.

[DaleCurtis, 2014/09/18 22:57:38]

Ah, no there isn't.  The list shouldn't be large and you can iterate over it on
the IO thread, so it's not a huge deal.

[aiolos (Not reviewing), 2014/09/19 00:37:36]

Done.

+  if (entry->playing() != is_playing) {
+    entry->set_playing(is_playing);
+    if (is_playing) {
+      base::AtomicRefCountInc(&num_playing_streams_);
+    } else {
+      base::AtomicRefCountDec(&num_playing_streams_);
+    }
+    if (had_active_audio != HasActiveAudio()) {
+      DCHECK_CURRENTLY_ON(BrowserThread::IO);
+      ResourceDispatcherHostImpl::Get()->OnAudioRenderHostStreamStateChanged(
+          render_process_id_, entry->render_view_id(), is_playing);
+    }
+  }
+}
+
 bool AudioRendererHost::HasActiveAudio() {
   return !base::AtomicRefCountIsZero(&num_playing_streams_);
 }
 
 }  // namespace content