Defer media playback in background tabs.

chrome/renderer/chrome_content_renderer_client.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/renderer/chrome_content_renderer_client.h"
 
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
@@ skipping 323 matching lines @@
   return std::string();
 }
 #endif
 
 #if defined(ENABLE_EXTENSIONS)
 bool IsStandaloneExtensionProcess() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       extensions::switches::kExtensionProcess);
 }
 #endif
+
+// Defers media player loading in background pages until they're visible.
+// TODO(dalecurtis): Include an idle listener too.  http://crbug.com/509135
+class MediaLoadDeferrer : public content::RenderFrameObserver {
+ public:
+  MediaLoadDeferrer(content::RenderFrame* render_frame,
+                    const base::Closure& continue_loading_cb)
+      : content::RenderFrameObserver(render_frame),
+        continue_loading_cb_(continue_loading_cb) {}
+  ~MediaLoadDeferrer() override {}
+
+ private:
+  // content::RenderFrameObserver implementation:
+  void WasShown() override {
+    continue_loading_cb_.Run();
+    delete this;
+  }
+
+  const base::Closure continue_loading_cb_;
+
+  DISALLOW_COPY_AND_ASSIGN(MediaLoadDeferrer);
+};
+
 }  // namespace
 
 ChromeContentRendererClient::ChromeContentRendererClient() {
   g_current_client = this;
 
 #if defined(ENABLE_EXTENSIONS)
   extensions::ExtensionsClient::Set(
       extensions::ChromeExtensionsClient::GetInstance());
   extensions::ExtensionsRendererClient::Set(
       ChromeExtensionsRendererClient::GetInstance());
@@ skipping 322 matching lines @@
 
 WebPlugin* ChromeContentRendererClient::CreatePluginReplacement(
     content::RenderFrame* render_frame,
     const base::FilePath& plugin_path) {
   return NonLoadablePluginPlaceholder::CreateErrorPlugin(render_frame,
                                                          plugin_path)->plugin();
 }
 
 void ChromeContentRendererClient::DeferMediaLoad(
     content::RenderFrame* render_frame,
+    bool render_frame_has_played_media_before,
     const base::Closure& closure) {
 #if defined(OS_ANDROID)
   // Chromium for Android doesn't support prerender yet.

[tommycli, 2015/08/13 21:50:07]

Although we don't have prerender on Android, it seems like the media deferral
should apply to Android also.

[DaleCurtis, 2015/08/13 22:24:30]

Android doesn't use WebMediaPlayerImpl and ignores the provided deferral
callback -- so this approach won't work currently for Android.  However, since
autoplay requires a user gesture there, it's also not important.

My team is pursuing a project right now to move Android over to
WebMediaPlayerImpl, at that point it would benefit from this code.

Since it doesn't matter and this code is never called, what I'll do is move the
#if around such that only prerender is excluded.

   closure.Run();
   return;
 #else
-  if (!prerender::PrerenderHelper::IsPrerendering(render_frame)) {
-    closure.Run();
+  if (prerender::PrerenderHelper::IsPrerendering(render_frame)) {

[tommycli, 2015/08/13 21:50:06]

Does this mean that pages that are pre-rendered are exempt from the
MediaLoadDeferrer? Or is it chained somehow?

[DaleCurtis, 2015/08/13 22:24:30]

Hmm, I was counting on prerender not taking affect for invislbe pages, but it is
possible to do the following to trigger playback in a background tab:

<link rel="prerender" href="buck2.webm">
<meta http-equiv="refresh" content="2; URL='buck2.webm'"/>

I wonder if it's worth chaining or if we can actually just remove the
IsPrerenderingPath() completely. Locally that works fine because a prerender
frame is hidden, +mmenke for commentary to see if we can just delete the
PrerenderMediaLoadDeferrer().

[mmenke, 2015/08/13 22:36:10]

Prerendered frames should always be hidden.  I don't know much about visibility
issues, but the new code looks to me like it should cover the prerender case,
and if it does, the old prerender code here can probably be removed - which is
great.  The less special case code prerender has, the better.  Just want to make
sure we have tests to protect against regressions, if the new behavior is ever
changes (Which we should already have)

+    // Lifetime is tied to |render_frame| via content::RenderFrameObserver.
+    new prerender::PrerenderMediaLoadDeferrer(render_frame, closure);
     return;
   }
 
-  // Lifetime is tied to |render_frame| via content::RenderFrameObserver.
-  new prerender::PrerenderMediaLoadDeferrer(render_frame, closure);
+  // Don't allow autoplay/autoload of media resources in a RenderFrame that is
+  // hidden and has never played any media before.  We want to allow future
+  // loads even when hidden to allow playlist-like functionality.
+  //
+  // TODO(dalecurtis): Include an idle check too.  http://crbug.com/509135
+  if (render_frame->IsHidden() && !render_frame_has_played_media_before) {
+    // Lifetime is tied to |render_frame| via content::RenderFrameObserver.
+    new MediaLoadDeferrer(render_frame, closure);
+    return;
+  }
+
+  closure.Run();
 #endif
 }
 
 #if defined(ENABLE_PLUGINS)
 WebPlugin* ChromeContentRendererClient::CreatePlugin(
     content::RenderFrame* render_frame,
     blink::WebLocalFrame* frame,
     const WebPluginParams& original_params,
     const ChromeViewHostMsg_GetPluginInfo_Output& output) {
   const WebPluginInfo& info = output.plugin;
@@ skipping 915 matching lines @@
   WebString header_key(ASCIIToUTF16(
       data_reduction_proxy::chrome_proxy_header()));
   if (!response.httpHeaderField(header_key).isNull() &&
       response.httpHeaderField(header_key).utf8().find(
           data_reduction_proxy::chrome_proxy_lo_fi_directive()) !=
               std::string::npos) {
     (*properties)[data_reduction_proxy::chrome_proxy_header()] =
         data_reduction_proxy::chrome_proxy_lo_fi_directive();
   }
 }