Use AudioStreamMonitor to control power save blocking.

content/browser/web_contents/web_contents_impl.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/web_contents/web_contents_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 93 matching lines @@
 #include "content/browser/android/date_time_chooser_android.h"
 #include "content/browser/media/android/browser_media_player_manager.h"
 #include "content/browser/web_contents/web_contents_android.h"
 #include "content/public/browser/android/content_view_core.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include "base/mac/foundation_util.h"
 #endif
 
+// 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

[jam, 2014/09/02 19:50:33]

nit: use a boolean member in this class that is initialized through
'!defined(OS_ANDROID) && !defined(OS_IOS)', but don't define ifdef's and use it
through the file. that is confusing and not a standard way of enabling stuff per
platform

[DaleCurtis, 2014/09/04 21:59:06]

I instead plumbing a bit which is defined where this decision is made, so we
don't have multiple clients reimplementing this.  AudioOutputController now
decides whether or not it will monitor and the audio stream monitor keys off of
that.

+#include "content/browser/media/audio_stream_monitor.h"
+#endif
+
 // Cross-Site Navigations
 //
 // If a WebContentsImpl is told to navigate to a different web site (as
 // determined by SiteInstance), it will replace its current RenderViewHost with
 // a new RenderViewHost dedicated to the new SiteInstance.  This works as
 // follows:
 //
 // - RVHM::Navigate determines whether the destination is cross-site, and if so,
 //   it creates a pending_render_view_host_.
 // - The pending RVH is "suspended," so that no navigation messages are sent to
@@ skipping 911 matching lines @@
   last_active_time_ = base::TimeTicks::Now();
 
   // The resize rect might have changed while this was inactive -- send the new
   // one to make sure it's up to date.
   RenderViewHostImpl* rvh =
       static_cast<RenderViewHostImpl*>(GetRenderViewHost());
   if (rvh) {
     rvh->ResizeRectChanged(GetRootWindowResizerRect());
   }
 
+  // Restore power save blocker if there are active video players running.
+  if (!active_media_players_.empty())
+    CreatePowerSaveBlocker();
+
   FOR_EACH_OBSERVER(WebContentsObserver, observers_, WasShown());
 
   should_normally_be_visible_ = true;
 }
 
 void WebContentsImpl::WasHidden() {
   // If there are entities capturing screenshots or video (e.g., mirroring),
   // don't activate the "disable rendering" optimization.
   if (capturer_count_ == 0) {
     // |GetRenderViewHost()| can be NULL if the user middle clicks a link to
     // open a tab in the background, then closes the tab before selecting it.
     // This is because closing the tab calls WebContentsImpl::Destroy(), which
     // removes the |GetRenderViewHost()|; then when we actually destroy the
     // window, OnWindowPosChanged() notices and calls WasHidden() (which
     // calls us).
     std::set<RenderWidgetHostView*> widgets = GetRenderWidgetHostViewsInTree();
     for (std::set<RenderWidgetHostView*>::iterator iter = widgets.begin();
          iter != widgets.end();
          iter++) {
       if (*iter)
         (*iter)->Hide();
     }
   }
 
+  // Release any video power save blockers held as video is not visible.
+  power_save_blocker_.reset();
+
   FOR_EACH_OBSERVER(WebContentsObserver, observers_, WasHidden());
 
   should_normally_be_visible_ = false;
 }
 
 bool WebContentsImpl::NeedToFireBeforeUnload() {
   // TODO(creis): Should we fire even for interstitial pages?
   return WillNotifyDisconnection() &&
       !ShowingInterstitialPage() &&
       !static_cast<RenderViewHostImpl*>(
@@ skipping 1302 matching lines @@
 
 void WebContentsImpl::StopFinding(StopFindAction action) {
   Send(new ViewMsg_StopFinding(GetRoutingID(), action));
 }
 
 void WebContentsImpl::InsertCSS(const std::string& css) {
   GetMainFrame()->Send(new FrameMsg_CSSInsertRequest(
       GetMainFrame()->GetRoutingID(), css));
 }
 
+bool WebContentsImpl::WasRecentlyAudible() {
+#if !defined(AUDIO_STREAM_MONITORING)
+  return false;
+#else
+  AudioStreamMonitor* const monitor = AudioStreamMonitor::FromWebContents(this);
+  return monitor ? monitor->WasRecentlyAudible() : false;
+#endif
+}
+
 bool WebContentsImpl::FocusLocationBarByDefault() {
   NavigationEntry* entry = controller_.GetVisibleEntry();
   if (entry && entry->GetURL() == GURL(url::kAboutBlankURL))
     return true;
   return delegate_ && delegate_->ShouldFocusLocationBarByDefault(this);
 }
 
 void WebContentsImpl::SetFocusToLocationBar(bool select_all) {
   if (delegate_)
     delegate_->SetFocusToLocationBar(select_all);
@@ skipping 591 matching lines @@
   }
   image_download_map_.erase(id);
 }
 
 void WebContentsImpl::OnUpdateFaviconURL(
     const std::vector<FaviconURL>& candidates) {
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                     DidUpdateFaviconURL(candidates));
 }
 
+void WebContentsImpl::CreatePowerSaveBlocker() {
+  DCHECK(!power_save_blocker_);
+  DCHECK(!active_media_players_.empty());
+  power_save_blocker_ = PowerSaveBlocker::Create(
+      PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep, "Playing Video");
+#if defined(OS_ANDROID)
+  static_cast<PowerSaveBlockerImpl*>(power_save_blocker_.get())
+      ->InitDisplaySleepBlocker(GetView()->GetNativeView());
+#endif
+}
+
 void WebContentsImpl::OnMediaPlayingNotification(int64 player_cookie,
                                                  bool has_video,
                                                  bool has_audio) {
 #if !defined(OS_CHROMEOS)
-  scoped_ptr<PowerSaveBlocker> blocker;
-  if (has_video) {
-    blocker = PowerSaveBlocker::Create(
-        PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep, "Playing video");
-#if defined(OS_ANDROID)
-    static_cast<PowerSaveBlockerImpl*>(blocker.get())
-        ->InitDisplaySleepBlocker(GetView()->GetNativeView());
+#if defined(AUDIO_STREAM_MONITORING)
+  // Don't handle audio if audio level analysis is available.
+  if (!has_video)
+    return;
 #endif
-  } else if (has_audio) {
-    blocker = PowerSaveBlocker::Create(

[miu, 2014/09/02 21:04:39]

I'm not sure the blocker is set up correctly for platforms where
AUDIO_STREAM_MONITORING is not defined.  It seems like if only audio is playing,
we will be creating a "PreventDisplaySleep" blocker.  Also, the !IsHidden()
check (a dozen LOC down) isn't relevant for audio, right?

Given my comments elsewhere (in ASM.cc about moving the PowerSaveBlocker into
WebContentsImpl), perhaps you might retain this code and call this method (with
has_audio=true) from WCImpl::NotifyNavigationStateChanged()?

[DaleCurtis, 2014/09/03 18:48:55]

It ends up being correct since Androids PowerSaveBlocker is the same regardless
of type, but I agree that it's hacky. I'll see what I can do about making this
clearer.

-        PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension, "Playing audio");
-  }
 
-  if (blocker) {
-    uintptr_t key = reinterpret_cast<uintptr_t>(render_frame_message_source_);
-    if (!power_save_blockers_.contains(key)) {
-      power_save_blockers_.add(key,
-                               make_scoped_ptr(new PowerSaveBlockerMapEntry));
-    }
-    PowerSaveBlockerMapEntry* map_entry =
-        power_save_blockers_.get(key);
-    map_entry->set(player_cookie, blocker.Pass());
-  }
+  // Track current status to see if we need to create a new blocker.
+  const bool had_no_player = active_media_players_.empty();
+
+  // Store tracking entries based on the RenderFrameHost.
+  const uintptr_t key =
+      reinterpret_cast<uintptr_t>(render_frame_message_source_);
+
+  ActiveMediaPlayerMap::iterator it = active_media_players_.find(key);
+  if (it != active_media_players_.end())
+    it->second++;
+  else
+    active_media_players_[key] = 1;
+
+  // If we're not hidden and just created a new video player, create a blocker.
+  if (had_no_player && !active_media_players_.empty() && !IsHidden())
+    CreatePowerSaveBlocker();
 #endif  // !defined(OS_CHROMEOS)
 }
 
 void WebContentsImpl::OnMediaPausedNotification(int64 player_cookie) {
 #if !defined(OS_CHROMEOS)
-  uintptr_t key = reinterpret_cast<uintptr_t>(render_frame_message_source_);
-  PowerSaveBlockerMapEntry* map_entry = power_save_blockers_.get(key);
-  if (map_entry)
-    map_entry->erase(player_cookie);
+  ActiveMediaPlayerMap::iterator it = active_media_players_.find(
+      reinterpret_cast<uintptr_t>(render_frame_message_source_));
+  if (it == active_media_players_.end())
+    return;
+  it->second--;
+  DCHECK_GE(it->second, 0);
+  // If there are no more active players in this RenderFrameHost, remove entry.
+  if (!it->second)
+    active_media_players_.erase(it);
+  // If there are no more active players at all, clear the power blocker.
+  if (active_media_players_.empty()) {
+    power_save_blocker_.reset();
+  }
 #endif  // !defined(OS_CHROMEOS)
 }
 
 void WebContentsImpl::OnFirstVisuallyNonEmptyPaint() {
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                     DidFirstVisuallyNonEmptyPaint());
 }
 
 void WebContentsImpl::DidChangeVisibleSSLState() {
   if (delegate_)
@@ skipping 1148 matching lines @@
   browser_plugin_guest_.reset(guest);
 }
 
 BrowserPluginEmbedder* WebContentsImpl::GetBrowserPluginEmbedder() const {
   return browser_plugin_embedder_.get();
 }
 
 void WebContentsImpl::ClearPowerSaveBlockers(
     RenderFrameHost* render_frame_host) {
 #if !defined(OS_CHROMEOS)
-  uintptr_t key = reinterpret_cast<uintptr_t>(render_frame_host);
-  scoped_ptr<PowerSaveBlockerMapEntry> map_entry =
-      power_save_blockers_.take_and_erase(key);
-  if (map_entry)
-    map_entry->clear();
+  ActiveMediaPlayerMap::iterator it = active_media_players_.find(
+      reinterpret_cast<uintptr_t>(render_frame_message_source_));
+  if (it == active_media_players_.end())
+    return;
+  active_media_players_.erase(it);
+
+  // If there are no more active players at all, clear the power blocker.
+  if (active_media_players_.empty())
+    power_save_blocker_.reset();
 #endif
 }
 
 void WebContentsImpl::ClearAllPowerSaveBlockers() {
 #if !defined(OS_CHROMEOS)
-  power_save_blockers_.clear();
+  active_media_players_.clear();
+  power_save_blocker_.reset();
 #endif
 }
 
 gfx::Size WebContentsImpl::GetSizeForNewRenderView() {
   gfx::Size size;
   if (delegate_)
     size = delegate_->GetSizeForNewRenderView(this);
   if (size.IsEmpty())
     size = GetContainerBounds().size();
   return size;
@@ skipping 17 matching lines @@
   node->render_manager()->ResumeResponseDeferredAtStart();
 }
 
 void WebContentsImpl::SetForceDisableOverscrollContent(bool force_disable) {
   force_disable_overscroll_content_ = force_disable;
   if (view_)
     view_->SetOverscrollControllerEnabled(CanOverscrollContent());
 }
 
 }  // namespace content