Plugin Power Saver Tiny: Fix Plugin.PowerSaver.PeripheralHeuristic UMA

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 14 matching lines @@
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "third_party/WebKit/public/web/WebSerializedScriptValue.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 using base::UserMetricsAction;
 using content::PluginInstanceThrottler;
+using content::RenderFrame;
 using content::RenderThread;
 
 namespace plugins {
 
 void LoadablePluginPlaceholder::BlockForPowerSaverPoster() {
   DCHECK(!is_blocked_for_power_saver_poster_);
   is_blocked_for_power_saver_poster_ = true;
 
   render_frame()->RegisterPeripheralPlugin(
       url::Origin(GURL(GetPluginParams().url)),
       base::Bind(&LoadablePluginPlaceholder::MarkPluginEssential,
                  weak_factory_.GetWeakPtr(),
                  PluginInstanceThrottler::UNTHROTTLE_METHOD_BY_WHITELIST));
 }
 
 void LoadablePluginPlaceholder::SetPremadePlugin(
     content::PluginInstanceThrottler* throttler) {
   DCHECK(throttler);
   DCHECK(!premade_throttler_);
+  heuristic_run_before_ = true;
   premade_throttler_ = throttler;
 }
 
 LoadablePluginPlaceholder::LoadablePluginPlaceholder(
-    content::RenderFrame* render_frame,
+    RenderFrame* render_frame,
     blink::WebLocalFrame* frame,
     const blink::WebPluginParams& params,
     const std::string& html_data)
     : PluginPlaceholderBase(render_frame, frame, params, html_data),
+      heuristic_run_before_(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::MarkPluginEssential(
     PluginInstanceThrottler::PowerSaverUnthrottleMethod method) {
   if (!power_saver_enabled_)
     return;
 
@@ skipping 110 matching lines @@
   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 =
+  RenderFrame::PeripheralContentStatus status =
       render_frame()->GetPeripheralContentStatus(
           render_frame()->GetWebFrame()->top()->getSecurityOrigin(),
-          content_origin, gfx::Size(width, height));
+          content_origin, gfx::Size(width, height),
+          heuristic_run_before_ ? RenderFrame::DONT_RECORD_DECISION
+                                : RenderFrame::RECORD_DECISION);
 
   bool plugin_is_tiny_and_blocked =
       is_blocked_for_tinyness_ &&
-      status ==
-          content::RenderFrame::CONTENT_STATUS_ESSENTIAL_CROSS_ORIGIN_TINY;
+      status == 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) {
+      status != 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) {
+        status == 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();
@@ skipping 127 matching lines @@
   return identifier_;
 }
 
 bool LoadablePluginPlaceholder::LoadingBlocked() const {
   DCHECK(allow_loading_);
   return is_blocked_for_tinyness_ || is_blocked_for_background_tab_ ||
          is_blocked_for_power_saver_poster_ || is_blocked_for_prerendering_;
 }
 
 }  // namespace plugins