Plugin Power Saver: Add UI Overlay to throttled plugin using placeholder.

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 22 matching lines @@
 #include "chrome/renderer/content_settings_observer.h"
 #include "chrome/renderer/external_extension.h"
 #include "chrome/renderer/loadtimes_extension_bindings.h"
 #include "chrome/renderer/media/chrome_key_systems.h"
 #include "chrome/renderer/net/net_error_helper.h"
 #include "chrome/renderer/net_benchmarking_extension.h"
 #include "chrome/renderer/page_load_histograms.h"
 #include "chrome/renderer/pepper/pepper_helper.h"
 #include "chrome/renderer/playback_extension.h"
 #include "chrome/renderer/plugins/chrome_plugin_placeholder.h"
+#include "chrome/renderer/plugins/plugin_preroller.h"
 #include "chrome/renderer/plugins/plugin_uma.h"
 #include "chrome/renderer/plugins/shadow_dom_plugin_placeholder.h"
 #include "chrome/renderer/prefetch_helper.h"
 #include "chrome/renderer/prerender/prerender_dispatcher.h"
 #include "chrome/renderer/prerender/prerender_helper.h"
 #include "chrome/renderer/prerender/prerender_media_load_deferrer.h"
 #include "chrome/renderer/prerender/prerenderer_client.h"
 #include "chrome/renderer/principals_extension_bindings.h"
 #include "chrome/renderer/safe_browsing/malware_dom_details.h"
 #include "chrome/renderer/safe_browsing/phishing_classifier_delegate.h"
@@ skipping 567 matching lines @@
   new prerender::PrerenderMediaLoadDeferrer(render_frame, closure);
 #endif
 }
 
 WebPlugin* ChromeContentRendererClient::CreatePlugin(
     content::RenderFrame* render_frame,
     WebLocalFrame* frame,
     const WebPluginParams& original_params,
     const ChromeViewHostMsg_GetPluginInfo_Output& output) {
   const ChromeViewHostMsg_GetPluginInfo_Status& status = output.status;
-  const WebPluginInfo& plugin = output.plugin;
+  const WebPluginInfo& info = output.plugin;
   const std::string& actual_mime_type = output.actual_mime_type;
   const base::string16& group_name = output.group_name;
   const std::string& identifier = output.group_identifier;
   ChromeViewHostMsg_GetPluginInfo_Status::Value status_value = status.value;
   GURL url(original_params.url);
   std::string orig_mime_type = original_params.mimeType.utf8();
   ChromePluginPlaceholder* placeholder = NULL;
 
   // If the browser plugin is to be enabled, this should be handled by the
   // renderer, so the code won't reach here due to the early exit in
@@ skipping 13 matching lines @@
                   GURL(ChromePluginPlaceholder::kPluginPlaceholderDataURL)))
           ->plugin();
     }
 #endif
     PluginUMAReporter::GetInstance()->ReportPluginMissing(orig_mime_type, url);
     placeholder = ChromePluginPlaceholder::CreateMissingPlugin(
         render_frame, frame, original_params);
   } else {
     // TODO(bauerb): This should be in content/.
     WebPluginParams params(original_params);
-    for (size_t i = 0; i < plugin.mime_types.size(); ++i) {
-      if (plugin.mime_types[i].mime_type == actual_mime_type) {
-        AppendParams(plugin.mime_types[i].additional_param_names,
-                     plugin.mime_types[i].additional_param_values,
-                     &params.attributeNames,
-                     &params.attributeValues);
+    for (size_t i = 0; i < info.mime_types.size(); ++i) {
+      if (info.mime_types[i].mime_type == actual_mime_type) {
+        AppendParams(info.mime_types[i].additional_param_names,
+                     info.mime_types[i].additional_param_values,
+                     &params.attributeNames, &params.attributeValues);
         break;
       }
     }
     if (params.mimeType.isNull() && (actual_mime_type.size() > 0)) {
       // Webkit might say that mime type is null while we already know the
       // actual mime type via ChromeViewHostMsg_GetPluginInfo. In that case
       // we should use what we know since WebpluginDelegateProxy does some
       // specific initializations based on this information.
       params.mimeType = WebString::fromUTF8(actual_mime_type.c_str());
     }
 
     ContentSettingsObserver* observer =
         ContentSettingsObserver::Get(render_frame);
 
     const ContentSettingsType content_type =
-        ShouldUseJavaScriptSettingForPlugin(plugin) ?
-            CONTENT_SETTINGS_TYPE_JAVASCRIPT :
-            CONTENT_SETTINGS_TYPE_PLUGINS;
+        ShouldUseJavaScriptSettingForPlugin(info)
+            ? CONTENT_SETTINGS_TYPE_JAVASCRIPT
+            : CONTENT_SETTINGS_TYPE_PLUGINS;
 
     if ((status_value ==
              ChromeViewHostMsg_GetPluginInfo_Status::kUnauthorized ||
          status_value == ChromeViewHostMsg_GetPluginInfo_Status::kClickToPlay ||
          status_value == ChromeViewHostMsg_GetPluginInfo_Status::kBlocked) &&
         observer->IsPluginTemporarilyAllowed(identifier)) {
       status_value = ChromeViewHostMsg_GetPluginInfo_Status::kAllowed;
     }
 
     // Allow full-screen plug-ins for left-click-to-play.
     if (status_value == ChromeViewHostMsg_GetPluginInfo_Status::kClickToPlay &&
         !frame->parent() && !frame->opener() &&
         frame->document().isPluginDocument()) {
       status_value = ChromeViewHostMsg_GetPluginInfo_Status::kAllowed;
     }
 
 #if defined(ENABLE_PLUGINS)
     if (status_value == ChromeViewHostMsg_GetPluginInfo_Status::kAllowed &&
         base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnablePluginPowerSaver)) {
       status_value =
           ChromeViewHostMsg_GetPluginInfo_Status::kPlayImportantContent;
     }
 #endif
 
 #if defined(OS_WIN)
     // In Windows we need to check if we can load NPAPI plugins.
     // For example, if the render view is in the Ash desktop, we should not.
     if (status_value == ChromeViewHostMsg_GetPluginInfo_Status::kAllowed &&
-        plugin.type == content::WebPluginInfo::PLUGIN_TYPE_NPAPI) {
+        info.type == content::WebPluginInfo::PLUGIN_TYPE_NPAPI) {
         if (observer->AreNPAPIPluginsBlocked())
           status_value =
               ChromeViewHostMsg_GetPluginInfo_Status::kNPAPINotSupported;
     }
 #endif
 
     auto create_blocked_plugin =
-        [&render_frame, &frame, &params, &plugin, &identifier, &group_name](
-            int template_id, const base::string16& message,
-            const GURL& poster_url) {
+        [&render_frame, &frame, &params, &info, &identifier, &group_name](
+            int template_id, const base::string16& message) {
       return ChromePluginPlaceholder::CreateBlockedPlugin(
-          render_frame, frame, params, plugin, identifier, group_name,
-          template_id, message, poster_url);
+          render_frame, frame, params, info, identifier, group_name,
+          template_id, message, GURL());
     };
     switch (status_value) {
       case ChromeViewHostMsg_GetPluginInfo_Status::kNotFound: {
         NOTREACHED();
         break;
       }
       case ChromeViewHostMsg_GetPluginInfo_Status::kAllowed:
       case ChromeViewHostMsg_GetPluginInfo_Status::kPlayImportantContent: {
 #if !defined(DISABLE_NACL) && defined(ENABLE_EXTENSIONS)
         const bool is_nacl_plugin =
-            plugin.name == ASCIIToUTF16(nacl::kNaClPluginName);
+            info.name == ASCIIToUTF16(nacl::kNaClPluginName);
         const bool is_nacl_mime_type =
             actual_mime_type == nacl::kNaClPluginMimeType;
         const bool is_pnacl_mime_type =
             actual_mime_type == nacl::kPnaclPluginMimeType;
         if (is_nacl_plugin || is_nacl_mime_type || is_pnacl_mime_type) {
           bool is_nacl_unrestricted = false;
           if (is_nacl_mime_type) {
             is_nacl_unrestricted =
                 base::CommandLine::ForCurrentProcess()->HasSwitch(
                     switches::kEnableNaCl);
           } else if (is_pnacl_mime_type) {
             is_nacl_unrestricted = true;
           }
           GURL manifest_url;
           GURL app_url;
           if (is_nacl_mime_type || is_pnacl_mime_type) {
             // Normal NaCl/PNaCl embed. The app URL is the page URL.
             manifest_url = url;
             app_url = frame->top()->document().url();
           } else {
             // NaCl is being invoked as a content handler. Look up the NaCl
             // module using the MIME type. The app URL is the manifest URL.
-            manifest_url = GetNaClContentHandlerURL(actual_mime_type, plugin);
+            manifest_url = GetNaClContentHandlerURL(actual_mime_type, info);
             app_url = manifest_url;
           }
           const Extension* extension =
               g_current_client->extension_dispatcher_->extensions()->
                   GetExtensionOrAppByURL(manifest_url);
           if (!IsNaClAllowed(manifest_url,
                              app_url,
                              is_nacl_unrestricted,
                              extension,
                              &params)) {
             WebString error_message;
             if (is_nacl_mime_type) {
               error_message =
                   "Only unpacked extensions and apps installed from the Chrome "
                   "Web Store can load NaCl modules without enabling Native "
                   "Client in about:flags.";
             } else if (is_pnacl_mime_type) {
               error_message =
                   "Portable Native Client must not be disabled in about:flags.";
             }
             frame->addMessageToConsole(
                 WebConsoleMessage(WebConsoleMessage::LevelError,
                                   error_message));
             placeholder = create_blocked_plugin(
                 IDR_BLOCKED_PLUGIN_HTML,
   #if defined(OS_CHROMEOS)
-                l10n_util::GetStringUTF16(IDS_NACL_PLUGIN_BLOCKED),
+                l10n_util::GetStringUTF16(IDS_NACL_PLUGIN_BLOCKED));
   #else
-                l10n_util::GetStringFUTF16(IDS_PLUGIN_BLOCKED, group_name),
+                l10n_util::GetStringFUTF16(IDS_PLUGIN_BLOCKED, group_name));
   #endif
-                GURL());
             break;
           }
         }
 #endif  // !defined(DISABLE_NACL) && defined(ENABLE_EXTENSIONS)
 
         scoped_ptr<content::PluginInstanceThrottler> throttler;
 #if defined(ENABLE_PLUGINS)
         PluginPowerSaverMode power_saver_mode =
             PluginPowerSaverMode::POWER_SAVER_MODE_ESSENTIAL;
         bool show_poster = false;
         GURL poster_url;
         bool cross_origin_main_content = false;
         bool blocked_for_background_tab =
             render_frame->IsHidden() &&
             status_value ==
                 ChromeViewHostMsg_GetPluginInfo_Status::kPlayImportantContent;
         if (render_frame->ShouldThrottleContent(params, frame->document().url(),
                                                 &poster_url,
                                                 &cross_origin_main_content)) {
           // TODO(tommycli): Apply throttler behavior to all plugins.
-          if (plugin.name == base::ASCIIToUTF16(content::kFlashPluginName) &&
+          if (info.name == base::ASCIIToUTF16(content::kFlashPluginName) &&
               status_value == ChromeViewHostMsg_GetPluginInfo_Status::
                                   kPlayImportantContent) {
             power_saver_mode =
                 PluginPowerSaverMode::POWER_SAVER_MODE_PERIPHERAL_THROTTLED;
             show_poster = poster_url.is_valid();
           } else {
             power_saver_mode =
                 PluginPowerSaverMode::POWER_SAVER_MODE_PERIPHERAL_UNTHROTTLED;
           }
 
           throttler = content::PluginInstanceThrottler::Get(render_frame, url,
                                                             power_saver_mode);
         }
 
         // Delay loading plugins if prerendering.
         // TODO(mmenke):  In the case of prerendering, feed into
         //                ChromeContentRendererClient::CreatePlugin instead, to
         //                reduce the chance of future regressions.
         bool is_prerendering =
             prerender::PrerenderHelper::IsPrerendering(render_frame);
         if (blocked_for_background_tab || is_prerendering || show_poster) {
-          placeholder = create_blocked_plugin(
+          placeholder = ChromePluginPlaceholder::CreateBlockedPlugin(
+              render_frame, frame, params, info, identifier, group_name,
               show_poster ? IDR_PLUGIN_POSTER_HTML : IDR_BLOCKED_PLUGIN_HTML,
               l10n_util::GetStringFUTF16(IDS_PLUGIN_BLOCKED, group_name),
               poster_url);
           placeholder->set_blocked_for_background_tab(
               blocked_for_background_tab);
           placeholder->set_blocked_for_prerendering(is_prerendering);
           placeholder->set_power_saver_mode(power_saver_mode);
           placeholder->set_allow_loading(true);
           break;
         } else if (cross_origin_main_content) {
           GURL content_origin = GURL(params.url).GetOrigin();
           render_frame->WhitelistContentOrigin(content_origin);
         }
+
+        if (power_saver_mode ==
+            PluginPowerSaverMode::POWER_SAVER_MODE_PERIPHERAL_THROTTLED) {
+          content::PluginInstanceThrottler* throttler_raw = throttler.get();
+          blink::WebPlugin* plugin =
+              render_frame->CreatePlugin(frame, info, params, throttler.Pass());
+
+          // PluginPreroller manages its own lifetime.
+          new PluginPreroller(
+              render_frame, frame, params, info, identifier, group_name,
+              l10n_util::GetStringFUTF16(IDS_PLUGIN_BLOCKED, group_name),
+              plugin, throttler_raw);
+
+          return plugin;
+        }
+
 #endif  // defined(ENABLE_PLUGINS)
-        return render_frame->CreatePlugin(frame, plugin, params,
+        return render_frame->CreatePlugin(frame, info, params,
                                           throttler.Pass());
       }
       case ChromeViewHostMsg_GetPluginInfo_Status::kNPAPINotSupported: {
         RenderThread::Get()->RecordAction(
             UserMetricsAction("Plugin_NPAPINotSupported"));
         placeholder = create_blocked_plugin(
             IDR_BLOCKED_PLUGIN_HTML,
-            l10n_util::GetStringUTF16(IDS_PLUGIN_NOT_SUPPORTED_METRO), GURL());
+            l10n_util::GetStringUTF16(IDS_PLUGIN_NOT_SUPPORTED_METRO));
         render_frame->Send(new ChromeViewHostMsg_NPAPINotSupported(
             render_frame->GetRoutingID(), identifier));
         break;
       }
       case ChromeViewHostMsg_GetPluginInfo_Status::kDisabled: {
         PluginUMAReporter::GetInstance()->ReportPluginDisabled(orig_mime_type,
                                                                url);
         placeholder = create_blocked_plugin(
             IDR_DISABLED_PLUGIN_HTML,
-            l10n_util::GetStringFUTF16(IDS_PLUGIN_DISABLED, group_name),
-            GURL());
+            l10n_util::GetStringFUTF16(IDS_PLUGIN_DISABLED, group_name));
         break;
       }
       case ChromeViewHostMsg_GetPluginInfo_Status::kOutdatedBlocked: {
 #if defined(ENABLE_PLUGIN_INSTALLATION)
         placeholder = create_blocked_plugin(
             IDR_BLOCKED_PLUGIN_HTML,
-            l10n_util::GetStringFUTF16(IDS_PLUGIN_OUTDATED, group_name),
-            GURL());
+            l10n_util::GetStringFUTF16(IDS_PLUGIN_OUTDATED, group_name));
         placeholder->set_allow_loading(true);
         render_frame->Send(new ChromeViewHostMsg_BlockedOutdatedPlugin(
             render_frame->GetRoutingID(), placeholder->CreateRoutingId(),
             identifier));
 #else
         NOTREACHED();
 #endif
         break;
       }
       case ChromeViewHostMsg_GetPluginInfo_Status::kOutdatedDisallowed: {
         placeholder = create_blocked_plugin(
             IDR_BLOCKED_PLUGIN_HTML,
-            l10n_util::GetStringFUTF16(IDS_PLUGIN_OUTDATED, group_name),
-            GURL());
+            l10n_util::GetStringFUTF16(IDS_PLUGIN_OUTDATED, group_name));
         break;
       }
       case ChromeViewHostMsg_GetPluginInfo_Status::kUnauthorized: {
         placeholder = create_blocked_plugin(
             IDR_BLOCKED_PLUGIN_HTML,
-            l10n_util::GetStringFUTF16(IDS_PLUGIN_NOT_AUTHORIZED, group_name),
-            GURL());
+            l10n_util::GetStringFUTF16(IDS_PLUGIN_NOT_AUTHORIZED, group_name));
         placeholder->set_allow_loading(true);
-        if (plugin.type != content::WebPluginInfo::PLUGIN_TYPE_NPAPI) {
+        if (info.type != content::WebPluginInfo::PLUGIN_TYPE_NPAPI) {
           render_frame->Send(new ChromeViewHostMsg_BlockedUnauthorizedPlugin(
               render_frame->GetRoutingID(),
               group_name,
               identifier));
         }
         observer->DidBlockContentType(content_type, group_name);
         break;
       }
       case ChromeViewHostMsg_GetPluginInfo_Status::kClickToPlay: {
         placeholder = create_blocked_plugin(
             IDR_CLICK_TO_PLAY_PLUGIN_HTML,
-            l10n_util::GetStringFUTF16(IDS_PLUGIN_LOAD, group_name), GURL());
+            l10n_util::GetStringFUTF16(IDS_PLUGIN_LOAD, group_name));
         placeholder->set_allow_loading(true);
         RenderThread::Get()->RecordAction(
             UserMetricsAction("Plugin_ClickToPlay"));
         observer->DidBlockContentType(content_type, group_name);
         break;
       }
       case ChromeViewHostMsg_GetPluginInfo_Status::kBlocked: {
         placeholder = create_blocked_plugin(
             IDR_BLOCKED_PLUGIN_HTML,
-            l10n_util::GetStringFUTF16(IDS_PLUGIN_BLOCKED, group_name), GURL());
+            l10n_util::GetStringFUTF16(IDS_PLUGIN_BLOCKED, group_name));
         placeholder->set_allow_loading(true);
         RenderThread::Get()->RecordAction(UserMetricsAction("Plugin_Blocked"));
         observer->DidBlockContentType(content_type, group_name);
         break;
       }
       case ChromeViewHostMsg_GetPluginInfo_Status::kBlockedByPolicy: {
         placeholder = create_blocked_plugin(
             IDR_BLOCKED_PLUGIN_HTML,
-            l10n_util::GetStringFUTF16(IDS_PLUGIN_BLOCKED, group_name), GURL());
+            l10n_util::GetStringFUTF16(IDS_PLUGIN_BLOCKED, group_name));
         placeholder->set_allow_loading(false);
         RenderThread::Get()->RecordAction(
             UserMetricsAction("Plugin_BlockedByPolicy"));
         observer->DidBlockContentType(content_type, group_name);
         break;
       }
     }
   }
   placeholder->SetStatus(status);
   return placeholder->plugin();
@@ skipping 646 matching lines @@
   if (mime_type == content::kBrowserPluginMimeType) {
     return new extensions::ExtensionsGuestViewContainer(render_frame);
   } else {
     return new extensions::MimeHandlerViewContainer(
         render_frame, mime_type, original_url);
   }
 #else
   return NULL;
 #endif
 }