Plugin Power Saver: Improve blocked tiny plugins behavior

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 <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 42 matching lines @@
   DCHECK(!premade_throttler_);
   premade_throttler_ = throttler;
 }
 
 LoadablePluginPlaceholder::LoadablePluginPlaceholder(
     content::RenderFrame* render_frame,
     blink::WebLocalFrame* frame,
     const blink::WebPluginParams& params,
     const std::string& html_data)
     : PluginPlaceholderBase(render_frame, frame, params, html_data),
-      is_delayed_placeholder_(false),
+      is_blocked_for_tinyness_(false),
       is_blocked_for_background_tab_(false),
       is_blocked_for_prerendering_(false),
       is_blocked_for_power_saver_poster_(false),
       power_saver_enabled_(false),
       premade_throttler_(nullptr),
       allow_loading_(false),
       finished_loading_(false),
       heuristic_run_before_(premade_throttler_ != nullptr),
       weak_factory_(this) {}
 
 LoadablePluginPlaceholder::~LoadablePluginPlaceholder() {
 }
 
-void LoadablePluginPlaceholder::SetDelegate(
-    std::unique_ptr<Delegate> delegate) {
-  delegate_ = std::move(delegate);
-}
-
 void LoadablePluginPlaceholder::MarkPluginEssential(
     PluginInstanceThrottler::PowerSaverUnthrottleMethod method) {
   if (!power_saver_enabled_)
     return;
 
   power_saver_enabled_ = false;
 
   if (premade_throttler_)
     premade_throttler_->MarkPluginEssential(method);
   else if (method != PluginInstanceThrottler::UNTHROTTLE_METHOD_DO_NOT_RECORD)
     PluginInstanceThrottler::RecordUnthrottleMethodMetric(method);
 
-  if (is_blocked_for_power_saver_poster_) {
-    is_blocked_for_power_saver_poster_ = false;
-    if (!LoadingBlocked())
-      LoadPlugin();
-  }
+  is_blocked_for_power_saver_poster_ = false;
+  is_blocked_for_tinyness_ = false;
+  if (!LoadingBlocked())
+    LoadPlugin();
 }
 
 void LoadablePluginPlaceholder::ReplacePlugin(blink::WebPlugin* new_plugin) {
   CHECK(plugin());
   if (!new_plugin)
     return;
   blink::WebPluginContainer* container = plugin()->container();
   // This can occur if the container has been destroyed.
   if (!container) {
     new_plugin->destroy();
@@ skipping 76 matching lines @@
   if (premade_throttler_ && premade_throttler_->GetWebPlugin()) {
     return premade_throttler_->GetWebPlugin()->v8ScriptableObject(isolate);
   }
   return v8::Local<v8::Object>();
 }
 
 void LoadablePluginPlaceholder::OnUnobscuredRectUpdate(
     const gfx::Rect& unobscured_rect) {
   DCHECK(content::RenderThread::Get());
 
-  // TODO(groby): Handle the case of power saver not being enabled.
   if (!plugin() || !finished_loading_)
     return;
 
+  if (!is_blocked_for_tinyness_ && !is_blocked_for_power_saver_poster_)
+    return;
+
   if (unobscured_rect_ == unobscured_rect)
     return;
 
   unobscured_rect_ = unobscured_rect;
 
   float zoom_factor = plugin()->container()->pageZoomFactor();
   int width = roundf(unobscured_rect_.width() / zoom_factor);
   int height = roundf(unobscured_rect_.height() / zoom_factor);
   int x = roundf(unobscured_rect_.x() / zoom_factor);
   int y = roundf(unobscured_rect_.y() / zoom_factor);
 
   // On a size update check if we now qualify as a essential plugin.
   url::Origin content_origin = url::Origin(GetPluginParams().url);
   content::RenderFrame::PeripheralContentStatus status =
       render_frame()->GetPeripheralContentStatus(
           render_frame()->GetWebFrame()->top()->getSecurityOrigin(),
           content_origin, gfx::Size(width, height));
-  // If this is a "delay" placeholder, delegate decisions.
-  if (is_delayed_placeholder_) {
-    OnLoadedRectUpdate(gfx::Rect(x, y, width, height), status);
-    is_delayed_placeholder_ = false;
+
+  bool plugin_is_tiny_and_blocked =
+      is_blocked_for_tinyness_ &&
+      status ==
+          content::RenderFrame::CONTENT_STATUS_ESSENTIAL_CROSS_ORIGIN_TINY;
+
+  // Early exit for plugins that we've discovered to be essential.
+  if (!plugin_is_tiny_and_blocked &&
+      status != content::RenderFrame::CONTENT_STATUS_PERIPHERAL) {
+    MarkPluginEssential(
+        heuristic_run_before_
+            ? PluginInstanceThrottler::UNTHROTTLE_METHOD_BY_SIZE_CHANGE
+            : PluginInstanceThrottler::UNTHROTTLE_METHOD_DO_NOT_RECORD);
+
+    if (!heuristic_run_before_ &&
+        status ==
+            content::RenderFrame::CONTENT_STATUS_ESSENTIAL_CROSS_ORIGIN_BIG) {
+      render_frame()->WhitelistContentOrigin(content_origin);
+    }
+
     return;
   }
+  heuristic_run_before_ = true;
+
+  if (is_blocked_for_tinyness_) {
+    if (plugin_is_tiny_and_blocked) {
+      OnBlockedTinyContent();
+    } else {
+      is_blocked_for_tinyness_ = false;
+      if (!LoadingBlocked()) {
+        LoadPlugin();
+      }
+    }
+  }
 
   if (is_blocked_for_power_saver_poster_) {
     // Adjust poster container padding and dimensions to center play button for
     // plugins and plugin posters that have their top or left portions obscured.
     std::string script = base::StringPrintf(
         "window.resizePoster('%dpx', '%dpx', '%dpx', '%dpx')", x, y, width,
         height);
     plugin()->web_view()->mainFrame()->executeScript(
         blink::WebScriptSource(base::UTF8ToUTF16(script)));
-
-    if (status != content::RenderFrame::CONTENT_STATUS_PERIPHERAL) {
-      MarkPluginEssential(
-          heuristic_run_before_
-              ? PluginInstanceThrottler::UNTHROTTLE_METHOD_BY_SIZE_CHANGE
-              : PluginInstanceThrottler::UNTHROTTLE_METHOD_DO_NOT_RECORD);
-
-      if (!heuristic_run_before_ &&
-          status ==
-              content::RenderFrame::CONTENT_STATUS_ESSENTIAL_CROSS_ORIGIN_BIG) {
-        render_frame()->WhitelistContentOrigin(content_origin);
-      }
-    }
-
-    heuristic_run_before_ = true;
   }
 }
 
 void LoadablePluginPlaceholder::WasShown() {
   if (is_blocked_for_background_tab_) {
     is_blocked_for_background_tab_ = false;
     if (!LoadingBlocked())
       LoadPlugin();
   }
 }
@@ skipping 95 matching lines @@
 void LoadablePluginPlaceholder::SetIdentifier(const std::string& identifier) {
   identifier_ = identifier;
 }
 
 const std::string& LoadablePluginPlaceholder::GetIdentifier() const {
   return identifier_;
 }
 
 bool LoadablePluginPlaceholder::LoadingBlocked() const {
   DCHECK(allow_loading_);
-  return is_blocked_for_background_tab_ || is_blocked_for_power_saver_poster_ ||
-         is_blocked_for_prerendering_;
+  return is_blocked_for_tinyness_ || is_blocked_for_background_tab_ ||
+         is_blocked_for_power_saver_poster_ || is_blocked_for_prerendering_;
 }
 
 }  // namespace plugins