Gardening: Revert "Use AudioStreamMonitor to control power save blocking."

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/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
@@ skipping 36 matching lines @@
 #include "media/audio/audio_manager_base.h"
 #include "media/base/media_switches.h"
 #include "net/base/net_util.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capture_types.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "ash/shell.h"
 #endif  // defined(OS_CHROMEOS)
 
+// Only do audio stream monitoring for platforms that use it for the tab media
+// indicator UI or the OOM killer.
+#if !defined(OS_ANDROID) && !defined(OS_IOS)
+#define AUDIO_STREAM_MONITORING
+#include "chrome/browser/media/audio_stream_monitor.h"
+#endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
 
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/api/tab_capture/tab_capture_registry.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "extensions/browser/extension_system.h"
 #endif
 
 using content::BrowserThread;
@@ skipping 116 matching lines @@
       ui = ScreenCaptureNotificationUI::Create(l10n_util::GetStringFUTF16(
           IDS_MEDIA_SCREEN_CAPTURE_NOTIFICATION_TEXT_DELEGATED,
           registered_extension_name,
           application_title));
     }
   }
 
   return ui.Pass();
 }
 
+#if defined(AUDIO_STREAM_MONITORING)
+
+AudioStreamMonitor* AudioStreamMonitorFromRenderFrame(
+    int render_process_id,
+    int render_frame_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  content::WebContents* const web_contents =
+      content::WebContents::FromRenderFrameHost(
+          content::RenderFrameHost::FromID(render_process_id, render_frame_id));
+  if (!web_contents)
+    return NULL;
+  return AudioStreamMonitor::FromWebContents(web_contents);
+}
+
+void StartAudioStreamMonitoringOnUIThread(
+    int render_process_id,
+    int render_frame_id,
+    int stream_id,
+    const AudioStreamMonitor::ReadPowerAndClipCallback& read_power_callback) {
+  AudioStreamMonitor* const audio_stream_monitor =
+      AudioStreamMonitorFromRenderFrame(render_process_id, render_frame_id);
+  if (audio_stream_monitor)
+    audio_stream_monitor->StartMonitoringStream(stream_id, read_power_callback);
+}
+
+void StopAudioStreamMonitoringOnUIThread(
+    int render_process_id,
+    int render_frame_id,
+    int stream_id) {
+  AudioStreamMonitor* const audio_stream_monitor =
+      AudioStreamMonitorFromRenderFrame(render_process_id, render_frame_id);
+  if (audio_stream_monitor)
+    audio_stream_monitor->StopMonitoringStream(stream_id);
+}
+
+#endif  // defined(AUDIO_STREAM_MONITORING)
+
 #if !defined(OS_ANDROID)
 // Find browser or app window from a given |web_contents|.
 gfx::NativeWindow FindParentWindowForWebContents(
     content::WebContents* web_contents) {
   Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
   if (browser && browser->window())
     return browser->window()->GetNativeWindow();
 
   const extensions::AppWindowRegistry::AppWindowList& window_list =
       extensions::AppWindowRegistry::Get(
@@ skipping 684 matching lines @@
     content::MediaRequestState state) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &MediaCaptureDevicesDispatcher::UpdateMediaRequestStateOnUIThread,
           base::Unretained(this), render_process_id, render_frame_id,
           page_request_id, security_origin, stream_type, state));
 }
 
+void MediaCaptureDevicesDispatcher::OnAudioStreamPlaying(
+    int render_process_id,
+    int render_frame_id,
+    int stream_id,
+    const ReadPowerAndClipCallback& read_power_callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+#if defined(AUDIO_STREAM_MONITORING)
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&StartAudioStreamMonitoringOnUIThread,
+                 render_process_id,
+                 render_frame_id,
+                 stream_id,
+                 read_power_callback));
+#endif
+}
+
+void MediaCaptureDevicesDispatcher::OnAudioStreamStopped(
+    int render_process_id,
+    int render_frame_id,
+    int stream_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+#if defined(AUDIO_STREAM_MONITORING)
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&StopAudioStreamMonitoringOnUIThread,
+                 render_process_id,
+                 render_frame_id,
+                 stream_id));
+#endif
+}
+
 void MediaCaptureDevicesDispatcher::OnCreatingAudioStream(
     int render_process_id,
     int render_frame_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &MediaCaptureDevicesDispatcher::OnCreatingAudioStreamOnUIThread,
           base::Unretained(this), render_process_id, render_frame_id));
 }
@@ skipping 78 matching lines @@
                                     stream_type,
                                     state));
 }
 
 void MediaCaptureDevicesDispatcher::OnCreatingAudioStreamOnUIThread(
     int render_process_id,
     int render_frame_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnCreatingAudioStream(render_process_id, render_frame_id));
+#if defined(AUDIO_STREAM_MONITORING)
+  content::WebContents* const web_contents =
+      content::WebContents::FromRenderFrameHost(
+          content::RenderFrameHost::FromID(render_process_id, render_frame_id));
+  if (web_contents) {
+    // Note: Calling CreateForWebContents() multiple times is valid (see usage
+    // info for content::WebContentsUserData).
+    AudioStreamMonitor::CreateForWebContents(web_contents);
+  }
+#endif
 }
 
 bool MediaCaptureDevicesDispatcher::IsDesktopCaptureInProgress() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return desktop_capture_sessions_.size() > 0;
 }
 
+
 void MediaCaptureDevicesDispatcher::SetTestAudioCaptureDevices(
     const MediaStreamDevices& devices) {
   test_audio_devices_ = devices;
 }
 
 void MediaCaptureDevicesDispatcher::SetTestVideoCaptureDevices(
     const MediaStreamDevices& devices) {
   test_video_devices_ = devices;
 }