Plugin Power Saver: Fix implicitly sized and below the fold plugins.

components/plugins/renderer/loadable_plugin_placeholder.cc

 // Copyright 2015 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 "components/plugins/renderer/loadable_plugin_placeholder.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/json/string_escape.h"
 #include "base/strings/string_piece.h"
@@ skipping 14 matching lines @@
 using blink::WebElement;
 using blink::WebLocalFrame;
 using blink::WebMouseEvent;
 using blink::WebNode;
 using blink::WebPlugin;
 using blink::WebPluginContainer;
 using blink::WebPluginParams;
 using blink::WebScriptSource;
 using blink::WebURLRequest;
 using content::PluginInstanceThrottler;
-using content::PluginPowerSaverMode;
 using content::RenderThread;
 
 namespace plugins {
 
 #if defined(ENABLE_PLUGINS)
 void LoadablePluginPlaceholder::BlockForPowerSaverPoster() {
   DCHECK(!is_blocked_for_power_saver_poster_);
   is_blocked_for_power_saver_poster_ = true;
 
   render_frame()->RegisterPeripheralPlugin(
       GURL(GetPluginParams().url).GetOrigin(),
-      base::Bind(&LoadablePluginPlaceholder::DisablePowerSaverForInstance,
+      base::Bind(&LoadablePluginPlaceholder::MarkPluginEssential,
                  weak_factory_.GetWeakPtr(),
                  PluginInstanceThrottler::UNTHROTTLE_METHOD_BY_WHITELIST));
 }
 #endif
 
 void LoadablePluginPlaceholder::SetPremadePlugin(
     blink::WebPlugin* plugin,
     content::PluginInstanceThrottler* throttler) {
   DCHECK(plugin);
   DCHECK(throttler);
@@ skipping 12 matching lines @@
     const std::string& html_data,
     GURL placeholderDataUrl)
     : PluginPlaceholder(render_frame,
                         frame,
                         params,
                         html_data,
                         placeholderDataUrl),
       is_blocked_for_background_tab_(false),
       is_blocked_for_prerendering_(false),
       is_blocked_for_power_saver_poster_(false),
-      power_saver_mode_(PluginPowerSaverMode::POWER_SAVER_MODE_ESSENTIAL),
+      power_saver_enabled_(false),
+      plugin_marked_essential_(false),
       premade_plugin_(nullptr),
       premade_throttler_(nullptr),
       allow_loading_(false),
       placeholder_was_replaced_(false),
       hidden_(false),
       finished_loading_(false),
       weak_factory_(this) {
 }
 
 LoadablePluginPlaceholder::~LoadablePluginPlaceholder() {
 #if defined(ENABLE_PLUGINS)
   DCHECK(!premade_plugin_);
   DCHECK(!premade_throttler_);
 
-  if (!placeholder_was_replaced_ && !is_blocked_for_prerendering_ &&
-      power_saver_mode_ != PluginPowerSaverMode::POWER_SAVER_MODE_ESSENTIAL) {
+  if (!plugin_marked_essential_ && !placeholder_was_replaced_ &&
+      !is_blocked_for_prerendering_ && is_blocked_for_power_saver_poster_) {
     PluginInstanceThrottler::RecordUnthrottleMethodMetric(
         PluginInstanceThrottler::UNTHROTTLE_METHOD_NEVER);
   }
 #endif
 }
 
 #if defined(ENABLE_PLUGINS)
-void LoadablePluginPlaceholder::DisablePowerSaverForInstance(
+void LoadablePluginPlaceholder::MarkPluginEssential(
     PluginInstanceThrottler::PowerSaverUnthrottleMethod method) {
-  if (power_saver_mode_ == PluginPowerSaverMode::POWER_SAVER_MODE_ESSENTIAL)
+  if (plugin_marked_essential_)
     return;
 
-  power_saver_mode_ = PluginPowerSaverMode::POWER_SAVER_MODE_ESSENTIAL;
+  plugin_marked_essential_ = true;
   if (premade_throttler_) {
     premade_throttler_->MarkPluginEssential(method);
-  } else {
-    PluginInstanceThrottler::RecordUnthrottleMethodMetric(method);
   }
 
   if (is_blocked_for_power_saver_poster_) {
     is_blocked_for_power_saver_poster_ = false;
+    PluginInstanceThrottler::RecordUnthrottleMethodMetric(method);
     if (!LoadingBlocked())
       LoadPlugin();
   }
 }
 #endif
 
 gin::ObjectTemplateBuilder LoadablePluginPlaceholder::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   return gin::Wrappable<PluginPlaceholder>::GetObjectTemplateBuilder(isolate)
       .SetMethod("load", &LoadablePluginPlaceholder::LoadCallback)
@@ skipping 172 matching lines @@
     premade_throttler_ = nullptr;
 
     ReplacePlugin(premade_plugin_);
     premade_plugin_ = nullptr;
   } else {
     // TODO(mmenke):  In the case of prerendering, feed into
     //                ChromeContentRendererClient::CreatePlugin instead, to
     //                reduce the chance of future regressions.
     scoped_ptr<PluginInstanceThrottler> throttler;
 #if defined(ENABLE_PLUGINS)
-    throttler = PluginInstanceThrottler::Get(
-        render_frame(), GetPluginParams().url, power_saver_mode_);
+    // If the plugin has already been marked essential in its placeholder form,
+    // we shouldn't create a new throttler and start the process all over again.
+    if (!plugin_marked_essential_)
+      throttler = PluginInstanceThrottler::Create(power_saver_enabled_);
 #endif
     WebPlugin* plugin = render_frame()->CreatePlugin(
         GetFrame(), plugin_info_, GetPluginParams(), throttler.Pass());
 
     ReplacePlugin(plugin);
   }
 }
 
 void LoadablePluginPlaceholder::LoadCallback() {
   RenderThread::Get()->RecordAction(UserMetricsAction("Plugin_Load_Click"));
 #if defined(ENABLE_PLUGINS)
   // If the user specifically clicks on the plug-in content's placeholder,
   // disable power saver throttling for this instance.
-  DisablePowerSaverForInstance(
-      PluginInstanceThrottler::UNTHROTTLE_METHOD_BY_CLICK);
+  MarkPluginEssential(PluginInstanceThrottler::UNTHROTTLE_METHOD_BY_CLICK);
 #endif
   LoadPlugin();
 }
 
 void LoadablePluginPlaceholder::HideCallback() {
   RenderThread::Get()->RecordAction(UserMetricsAction("Plugin_Hide_Click"));
   HidePlugin();
 }
 
 void LoadablePluginPlaceholder::DidFinishLoadingCallback() {
@@ skipping 20 matching lines @@
   identifier_ = identifier;
 }
 
 bool LoadablePluginPlaceholder::LoadingBlocked() const {
   DCHECK(allow_loading_);
   return is_blocked_for_background_tab_ || is_blocked_for_power_saver_poster_ ||
          is_blocked_for_prerendering_;
 }
 
 }  // namespace plugins