Don't background processes with active audio output.

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"
@@ skipping 43 matching lines @@
   media::AudioOutputController* controller() const { return controller_.get(); }
 
   base::SharedMemory* shared_memory() {
     return shared_memory_.get();
   }
 
   media::AudioOutputController::SyncReader* reader() const {
     return reader_.get();
   }
 
+  bool playing() const { return playing_; }
+  void set_playing(bool playing) { playing_ = playing; }
+
  private:
   // media::AudioOutputController::EventHandler implementation.
   virtual void OnCreated() OVERRIDE;
   virtual void OnPlaying() OVERRIDE;
   virtual void OnPaused() OVERRIDE;
   virtual void OnError() OVERRIDE;
   virtual void OnDeviceChange(int new_buffer_size, int new_sample_rate)
       OVERRIDE;
 
   AudioRendererHost* const host_;
   const int stream_id_;
 
   // The routing ID of the source render view/frame.
   const int render_view_id_;
   const int render_frame_id_;
 
   // Shared memory for transmission of the audio data.  Used by |reader_|.
   const scoped_ptr<base::SharedMemory> shared_memory_;
 
   // The synchronous reader to be used by |controller_|.
   const scoped_ptr<media::AudioOutputController::SyncReader> reader_;
 
   // The AudioOutputController that manages the audio stream.
   const scoped_refptr<media::AudioOutputController> controller_;
+
+  bool playing_;
 };
 
 AudioRendererHost::AudioEntry::AudioEntry(
     AudioRendererHost* host,
     int stream_id,
     int render_view_id,
     int render_frame_id,
     const media::AudioParameters& params,
     const std::string& output_device_id,
     scoped_ptr<base::SharedMemory> shared_memory,
     scoped_ptr<media::AudioOutputController::SyncReader> reader)
     : host_(host),
       stream_id_(stream_id),
       render_view_id_(render_view_id),
       render_frame_id_(render_frame_id),
       shared_memory_(shared_memory.Pass()),
       reader_(reader.Pass()),
       controller_(media::AudioOutputController::Create(host->audio_manager_,
                                                        this,
                                                        params,
                                                        output_device_id,
-                                                       reader_.get())) {
+                                                       reader_.get())),
+      playing_(false) {
   DCHECK(controller_.get());
 }
 
 AudioRendererHost::AudioEntry::~AudioEntry() {}
 
 ///////////////////////////////////////////////////////////////////////////////
 // AudioRendererHost implementations.
 
 AudioRendererHost::AudioRendererHost(
     int render_process_id,
     media::AudioManager* audio_manager,
     AudioMirroringManager* mirroring_manager,
     MediaInternals* media_internals,
     MediaStreamManager* media_stream_manager)
     : BrowserMessageFilter(AudioMsgStart),
       render_process_id_(render_process_id),
       audio_manager_(audio_manager),
       mirroring_manager_(mirroring_manager),
       audio_log_(media_internals->CreateAudioLog(
           media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER)),
-      media_stream_manager_(media_stream_manager) {
+      media_stream_manager_(media_stream_manager),
+      num_playing_streams_(0) {
   DCHECK(audio_manager_);
   DCHECK(media_stream_manager_);
 }
 
 AudioRendererHost::~AudioRendererHost() {
   DCHECK(audio_entries_.empty());
 }
 
 void AudioRendererHost::GetOutputControllers(
     int render_view_id,
@@ skipping 127 matching lines @@
   MediaObserver* const media_observer =
       GetContentClient()->browser()->GetMediaObserver();
   if (media_observer) {
     if (is_playing) {
       media_observer->OnAudioStreamPlaying(
           render_process_id_,
           entry->render_frame_id(),
           entry->stream_id(),
           base::Bind(&media::AudioOutputController::ReadCurrentPowerAndClip,
                      entry->controller()));
+      if (!entry->playing()) {
+        entry->set_playing(true);
+        base::AtomicRefCountInc(&num_playing_streams_);
+      }
     } else {
       media_observer->OnAudioStreamStopped(render_process_id_,
                                            entry->render_frame_id(),
                                            entry->stream_id());
+      if (entry->playing()) {
+        entry->set_playing(false);
+        base::AtomicRefCountDec(&num_playing_streams_);
+      }
     }
   }
 }
 
 RenderViewHost::AudioOutputControllerList
 AudioRendererHost::DoGetOutputControllers(int render_view_id) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   RenderViewHost::AudioOutputControllerList controllers;
   AudioEntryMap::const_iterator it = audio_entries_.begin();
@@ skipping 159 matching lines @@
 void AudioRendererHost::DeleteEntry(scoped_ptr<AudioEntry> entry) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // At this point, make the final "say" in audio playback state.
   MediaObserver* const media_observer =
       GetContentClient()->browser()->GetMediaObserver();
   if (media_observer) {
     media_observer->OnAudioStreamStopped(render_process_id_,
                                          entry->render_frame_id(),
                                          entry->stream_id());
+    if (entry->playing())
+      base::AtomicRefCountDec(&num_playing_streams_);
   }
 }
 
 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;
 }
 
+bool AudioRendererHost::HasActiveAudio() {
+  return !base::AtomicRefCountIsZero(&num_playing_streams_);
+}
+
 }  // namespace content