Add a method to tab_utils.h to find out whether a tab is playing audio.

chrome/browser/media/media_capture_devices_dispatcher.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 "chrome/browser/media/media_capture_devices_dispatcher.h"
 
 #include "base/prefs/pref_service.h"
+#include "chrome/browser/media/audio_stream_indicator.h"
 #include "chrome/browser/media/media_stream_capture_indicator.h"
 #include "chrome/browser/prefs/pref_registry_syncable.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/media_devices_monitor.h"
 #include "content/public/common/media_stream_request.h"
 
 using content::BrowserThread;
@@ skipping 19 matching lines @@
 
 }  // namespace
 
 
 MediaCaptureDevicesDispatcher* MediaCaptureDevicesDispatcher::GetInstance() {
   return Singleton<MediaCaptureDevicesDispatcher>::get();
 }
 
 MediaCaptureDevicesDispatcher::MediaCaptureDevicesDispatcher()
     : devices_enumerated_(false),
-      media_stream_capture_indicator_(new MediaStreamCaptureIndicator()) {}
+      media_stream_capture_indicator_(new MediaStreamCaptureIndicator()),
+      audio_stream_indicator_(new AudioStreamIndicator()) {}
 
 MediaCaptureDevicesDispatcher::~MediaCaptureDevicesDispatcher() {}
 
 void MediaCaptureDevicesDispatcher::RegisterUserPrefs(
     PrefService* user_prefs,
     PrefRegistrySyncable* registry) {
   // TODO(joi): Get rid of the need for PrefService param above.
   if (!user_prefs->FindPreference(prefs::kDefaultAudioCaptureDevice)) {
     registry->RegisterStringPref(prefs::kDefaultAudioCaptureDevice,
                                  std::string(),
@@ skipping 84 matching lines @@
     if (device)
       devices->push_back(*device);
   }
 }
 
 scoped_refptr<MediaStreamCaptureIndicator>
     MediaCaptureDevicesDispatcher::GetMediaStreamCaptureIndicator() {
   return media_stream_capture_indicator_;
 }
 
+scoped_refptr<AudioStreamIndicator>
+MediaCaptureDevicesDispatcher::GetAudioStreamIndicator() {
+  return audio_stream_indicator_;
+}
+
 void MediaCaptureDevicesDispatcher::OnCaptureDevicesOpened(
     int render_process_id,
     int render_view_id,
     const content::MediaStreamDevices& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   media_stream_capture_indicator_->CaptureDevicesOpened(render_process_id,
                                                         render_view_id,
                                                         devices);
 }
 
@@ skipping 33 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &MediaCaptureDevicesDispatcher::UpdateMediaRequestStateOnUIThread,
           base::Unretained(this), render_process_id, render_view_id, device,
           state));
 
 }
 
+void MediaCaptureDevicesDispatcher::OnAudioStreamPlayingChanged(
+    int render_process_id, int render_view_id, int stream_id, bool playing) {
+  audio_stream_indicator_->UpdateWebContentsStatus(render_process_id,
+                                                   render_view_id,
+                                                   stream_id,
+                                                   playing);
+}
+
 void MediaCaptureDevicesDispatcher::UpdateAudioDevicesOnUIThread(
     const content::MediaStreamDevices& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   devices_enumerated_ = true;
   audio_devices_ = devices;
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnUpdateAudioDevices(audio_devices_));
 }
 
 void MediaCaptureDevicesDispatcher::UpdateVideoDevicesOnUIThread(
     const content::MediaStreamDevices& devices){
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   devices_enumerated_ = true;
   video_devices_ = devices;
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnUpdateVideoDevices(video_devices_));
 }
 
 void MediaCaptureDevicesDispatcher::UpdateMediaRequestStateOnUIThread(
     int render_process_id,
     int render_view_id,
     const content::MediaStreamDevice& device,
     content::MediaRequestState state) {
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnRequestUpdate(render_process_id,
                                     render_view_id,
                                     device,
                                     state));
 }