Plugin Power Saver: Refactor Plugin Instance Throttling code

content/renderer/pepper/pepper_plugin_instance_throttler.cc

Index: content/renderer/pepper/pepper_plugin_instance_throttler.cc
diff --git a/content/renderer/pepper/pepper_plugin_instance_throttler.cc b/content/renderer/pepper/pepper_plugin_instance_throttler.cc
index f1d02b9e0682fd014f21c5db009cc90e1a06cbf0..f1f3cea9b280a23f20ac663e6ca1b38120bbd693 100644
--- a/content/renderer/pepper/pepper_plugin_instance_throttler.cc
+++ b/content/renderer/pepper/pepper_plugin_instance_throttler.cc
@@ -4,27 +4,221 @@
 
 #include "content/renderer/pepper/pepper_plugin_instance_throttler.h"
 
+#include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
+#include "base/metrics/histogram.h"
+#include "base/metrics/sparse_histogram.h"
 #include "base/time/time.h"
+#include "content/public/common/content_constants.h"
+#include "content/public/common/content_switches.h"
+#include "content/renderer/pepper/pepper_plugin_instance_impl.h"
+#include "content/renderer/pepper/plugin_module.h"
+#include "content/renderer/pepper/plugin_power_saver_helper.h"
+#include "content/renderer/render_frame_impl.h"
+#include "content/renderer/render_thread_impl.h"
+#include "third_party/WebKit/public/platform/WebRect.h"
+#include "third_party/WebKit/public/web/WebElement.h"
+#include "third_party/WebKit/public/web/WebInputEvent.h"
+#include "third_party/WebKit/public/web/WebPluginContainer.h"
 
 namespace content {
 
 namespace {
 
+static const int kInfiniteRatio = 99999;
+
+#define UMA_HISTOGRAM_ASPECT_RATIO(name, width, height) \
+  UMA_HISTOGRAM_SPARSE_SLOWLY(                          \
+      name, (height) ? ((width)*100) / (height) : kInfiniteRatio);
+
+// Histogram tracking prevalence of tiny Flash instances. Units in pixels.
+enum PluginFlashTinyContentSize {
+  TINY_CONTENT_SIZE_1_1 = 0,
+  TINY_CONTENT_SIZE_5_5 = 1,
+  TINY_CONTENT_SIZE_10_10 = 2,
+  TINY_CONTENT_SIZE_LARGE = 3,
+  TINY_CONTENT_SIZE_NUM_ITEMS
+};
+
+// How the throttled power saver is unthrottled, if ever.
+// These numeric values are used in UMA logs; do not change them.
+enum PowerSaverUnthrottleMethod {
+  UNTHROTTLE_METHOD_NEVER = 0,
+  UNTHROTTLE_METHOD_BY_CLICK = 1,
+  UNTHROTTLE_METHOD_BY_WHITELIST = 2,
+  UNTHROTTLE_METHOD_NUM_ITEMS
+};
+
 // When we give up waiting for a suitable preview frame, and simply suspend
 // the plugin where it's at. In milliseconds.
 const int kThrottleTimeout = 5000;
+
+const char kFlashClickSizeAspectRatioHistogram[] =
+    "Plugin.Flash.ClickSize.AspectRatio";
+const char kFlashClickSizeHeightHistogram[] = "Plugin.Flash.ClickSize.Height";
+const char kFlashClickSizeWidthHistogram[] = "Plugin.Flash.ClickSize.Width";
+const char kFlashTinyContentSizeHistogram[] = "Plugin.Flash.TinyContentSize";
+const char kPowerSaverUnthrottleHistogram[] = "Plugin.PowerSaver.Unthrottle";
+
+// Record size metrics for all Flash instances.
+void RecordFlashSizeMetric(int width, int height) {
+  PluginFlashTinyContentSize size = TINY_CONTENT_SIZE_LARGE;
+
+  if (width <= 1 && height <= 1)
+    size = TINY_CONTENT_SIZE_1_1;
+  else if (width <= 5 && height <= 5)
+    size = TINY_CONTENT_SIZE_5_5;
+  else if (width <= 10 && height <= 10)
+    size = TINY_CONTENT_SIZE_10_10;
+
+  UMA_HISTOGRAM_ENUMERATION(kFlashTinyContentSizeHistogram, size,
+                            TINY_CONTENT_SIZE_NUM_ITEMS);
+}
+
+void RecordUnthrottleMethodMetric(PowerSaverUnthrottleMethod method) {
+  UMA_HISTOGRAM_ENUMERATION(kPowerSaverUnthrottleHistogram, method,
+                            UNTHROTTLE_METHOD_NUM_ITEMS);
+}
+
+// Records size metrics for Flash instances that are clicked.
+void RecordFlashClickSizeMetric(int width, int height) {
+  base::HistogramBase* width_histogram = base::LinearHistogram::FactoryGet(
+      kFlashClickSizeWidthHistogram,
+      0,    // minimum width
+      500,  // maximum width
+      100,  // number of buckets.
+      base::HistogramBase::kUmaTargetedHistogramFlag);
+  width_histogram->Add(width);
+
+  base::HistogramBase* height_histogram = base::LinearHistogram::FactoryGet(
+      kFlashClickSizeHeightHistogram,
+      0,    // minimum height
+      400,  // maximum height
+      100,  // number of buckets.
+      base::HistogramBase::kUmaTargetedHistogramFlag);
+  height_histogram->Add(height);
+
+  UMA_HISTOGRAM_ASPECT_RATIO(kFlashClickSizeAspectRatioHistogram, width,
+                             height);
+}
+
+bool IsFlashPlugin(PluginModule* module) {
+  return module->name() == kFlashPluginName;
+}
 }
 
 PepperPluginInstanceThrottler::PepperPluginInstanceThrottler(
-    const base::Closure& throttle_closure) {
-  DCHECK(!throttle_closure.is_null());
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE, throttle_closure,
-      base::TimeDelta::FromMilliseconds(kThrottleTimeout));
+    PepperPluginInstanceImpl* instance,

[raymes, 2014/11/12 06:38:20]

It looks like if we pass in:
-The PluginPowerSaverHelper*
-The blink::WebRect (bounds)
-The module name
-Plugin GURL

We can decouple this from the PepperPluginInstanceImpl* which is nice for
testing too.

[tommycli, 2014/11/12 21:18:14]

Done.

+    const base::Closure& throttle_change_callback)
+    : instance_(instance),
+      throttle_change_callback_(throttle_change_callback),
+      has_been_clicked_(false),
+      power_saver_enabled_(false),
+      is_peripheral_content_(false),
+      plugin_throttled_(false),
+      weak_factory_(this) {
+  DCHECK(instance);
+
+  PluginPowerSaverHelper* power_saver_helper =
+      instance->render_frame()->plugin_power_saver_helper();
+  GURL content_origin = instance->GetPluginURL().GetOrigin();
+  blink::WebRect bounds =
+      instance->container()->element().boundsInViewportSpace();
+
+  if (IsFlashPlugin(instance->module())) {
+    RenderThread::Get()->RecordAction(
+        base::UserMetricsAction("Flash.PluginInstanceCreated"));
+    RecordFlashSizeMetric(bounds.width, bounds.height);
+  }
+
+  bool cross_origin = false;
+  is_peripheral_content_ =
+      IsFlashPlugin(instance->module()) &&
+      power_saver_helper->ShouldThrottleContent(content_origin, bounds.width,
+                                                bounds.height, &cross_origin);
+
+  power_saver_enabled_ = is_peripheral_content_ &&
+                         base::CommandLine::ForCurrentProcess()->HasSwitch(
+                             switches::kEnablePluginPowerSaver);
+
+  if (is_peripheral_content_) {
+    // To collect UMAs, register peripheral content even if we don't throttle.
+    power_saver_helper->RegisterPeripheralPlugin(
+        content_origin, base::Bind(&PepperPluginInstanceThrottler::
+                                       DisablePowerSaverByRetroactiveWhitelist,
+                                   weak_factory_.GetWeakPtr()));
+
+    if (power_saver_enabled_) {
+      base::MessageLoop::current()->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(&PepperPluginInstanceThrottler::SetPluginThrottled,
+                     weak_factory_.GetWeakPtr(), true /* throttled */),
+          base::TimeDelta::FromMilliseconds(kThrottleTimeout));
+    }
+  } else if (cross_origin) {
+    power_saver_helper->WhitelistContentOrigin(content_origin);
+  }
+}
+
+PepperPluginInstanceThrottler::PepperPluginInstanceThrottler(

[raymes, 2014/11/12 06:38:20]

It's better to avoid having a separate constructor for testing. If we make the
change suggested above, can we use the same constructor for testing? This would
allow you to test the code in the constructor too if you needed to. 

[tommycli, 2014/11/12 21:18:14]

Done.

+    const base::Closure& throttle_change_callback,
+    bool power_saver_enabled,
+    bool is_peripheral_content)
+    : instance_(NULL),
+      throttle_change_callback_(throttle_change_callback),
+      has_been_clicked_(false),
+      power_saver_enabled_(power_saver_enabled),
+      is_peripheral_content_(is_peripheral_content),
+      plugin_throttled_(false),
+      weak_factory_(this) {
 }
 
 PepperPluginInstanceThrottler::~PepperPluginInstanceThrottler() {
 }
 
+bool PepperPluginInstanceThrottler::ConsumeInputEvent(
+    const blink::WebInputEvent& event) {
+  if (instance_ && IsFlashPlugin(instance_->module()) &&
+      event.type == blink::WebInputEvent::MouseDown && !has_been_clicked_) {
+    has_been_clicked_ = true;
+    blink::WebRect bounds =
+        instance_->container()->element().boundsInViewportSpace();
+    RecordFlashClickSizeMetric(bounds.width, bounds.height);
+  }
+
+  if (event.type == blink::WebInputEvent::MouseUp && is_peripheral_content_) {
+    is_peripheral_content_ = false;
+    power_saver_enabled_ = false;
+
+    RecordUnthrottleMethodMetric(UNTHROTTLE_METHOD_BY_CLICK);
+
+    if (plugin_throttled_) {
+      SetPluginThrottled(false /* throttled */);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void PepperPluginInstanceThrottler::SetPluginThrottled(bool throttled) {
+  // Do not throttle if we've already disabled power saver.
+  if (!power_saver_enabled_ && throttled)
+    return;
+
+  plugin_throttled_ = throttled;
+  throttle_change_callback_.Run();
+}
+
+void PepperPluginInstanceThrottler::DisablePowerSaverByRetroactiveWhitelist() {
+  if (!is_peripheral_content_)
+    return;
+
+  is_peripheral_content_ = false;
+  power_saver_enabled_ = false;
+  SetPluginThrottled(false);
+
+  RecordUnthrottleMethodMetric(UNTHROTTLE_METHOD_BY_WHITELIST);
+}
+
 }  // namespace content