Plugin Power Saver: Collect size histogram on Flash Plugins users click.

content/renderer/pepper/pepper_plugin_instance_impl.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 "content/renderer/pepper/pepper_plugin_instance_impl.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
+#include "base/metrics/sparse_histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_offset_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "cc/base/latency_info_swap_promise.h"
 #include "cc/blink/web_layer_impl.h"
 #include "cc/layers/texture_layer.h"
 #include "cc/trees/layer_tree_host.h"
 #include "content/common/content_constants_internal.h"
@@ skipping 154 matching lines @@
 using blink::WebURLRequest;
 using blink::WebURLResponse;
 using blink::WebUserGestureIndicator;
 using blink::WebUserGestureToken;
 using blink::WebView;
 
 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);

[Ilya Sherman, 2014/11/07 23:20:08]

nit: Why define this as a macro rather than as a function, or just inlined?  It
seems to only be used in one place.

[tommycli, 2014/11/08 00:02:25]

It's from
https://code.google.com/p/chromium/codesearch#chromium/src/content/browser/re...

and i plan to merge the two in a followup CL.

+
 // Check PP_TextInput_Type and ui::TextInputType are kept in sync.
 COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_NONE) == int(PP_TEXTINPUT_TYPE_NONE),
                mismatching_enums);
 COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_TEXT) == int(PP_TEXTINPUT_TYPE_TEXT),
                mismatching_enums);
 COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_PASSWORD) ==
                    int(PP_TEXTINPUT_TYPE_PASSWORD),
                mismatching_enums);
 COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_SEARCH) == int(PP_TEXTINPUT_TYPE_SEARCH),
                mismatching_enums);
@@ skipping 185 matching lines @@
       input_sequence);
   new_latency->TraceEventType(WebInputEventTraits::GetName(type));
   if (old_latency) {
     new_latency->CopyLatencyFrom(*old_latency,
                                  ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT);
     new_latency->CopyLatencyFrom(*old_latency,
                                  ui::INPUT_EVENT_LATENCY_UI_COMPONENT);
   }
 }
 
+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
 };
 
-const char kPowerSaverUnthrottleHistogram[] = "Plugin.PowerSaverUnthrottle";
+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";
+
+void RecordFlashSizeMetric(int width, int height) {
+  if (width <= 1 && height <= 1) {
+    UMA_HISTOGRAM_ENUMERATION(kFlashTinyContentSizeHistogram,
+                              TINY_CONTENT_SIZE_1_1,
+                              TINY_CONTENT_SIZE_NUM_ITEMS);
+  } else if (width <= 5 && height <= 5) {
+    UMA_HISTOGRAM_ENUMERATION(kFlashTinyContentSizeHistogram,
+                              TINY_CONTENT_SIZE_5_5,
+                              TINY_CONTENT_SIZE_NUM_ITEMS);
+  } else if (width <= 10 && height <= 10) {
+    UMA_HISTOGRAM_ENUMERATION(kFlashTinyContentSizeHistogram,
+                              TINY_CONTENT_SIZE_10_10,
+                              TINY_CONTENT_SIZE_NUM_ITEMS);
+  } else {
+    UMA_HISTOGRAM_ENUMERATION(kFlashTinyContentSizeHistogram,
+                              TINY_CONTENT_SIZE_LARGE,
+                              TINY_CONTENT_SIZE_NUM_ITEMS);
+  }

[Ilya Sherman, 2014/11/07 23:20:08]

Rather than repeating the UMA_HISTOGRAM_ENUMERATION macro three times, it would
be better to just define a variable of type PluginFlashTinyContentSize, and set
it via the if-stmts.

[tommycli, 2014/11/08 00:02:25]

Done.

+}
+
+void RecordFlashClickSizeMetric(int width, int height) {
+  base::HistogramBase* width_histogram = base::LinearHistogram::FactoryGet(
+      kFlashClickSizeWidthHistogram,
+      0,    // minimum width

[groby-ooo-7-16, 2014/11/07 23:02:20]

Min/max width should be ~ 300-500. I don't believe we care much outside of that,
and restricting the range gives us finer resolution per bucket.

[tommycli, 2014/11/07 23:14:10]

I feel that if we're going to collect the histogram we might as well get a good
sample of all the plugin instance sizes.

At 1000 max and 100 buckets, that's a resolution of 10 px per bin. Is that
sufficient for your experiment?

[groby-ooo-7-16, 2014/11/08 00:21:36]

I'm happy to trade resolution for range *iff* there's anything we can do as a
reaction to the data in the new range. "might as well" shouldn't be a reason,
though :)

And I don't see anything actionable we can gain from an extended range.

[tommycli, 2014/11/08 02:01:20]

Well alright I changed it since it's not that big of a deal. I still think
perhaps another team might find the size data useful.

+      1000, // maximum width
+      100,  // number of buckets.
+      base::HistogramBase::kUmaTargetedHistogramFlag);
+  width_histogram->Add(width);
+
+  base::HistogramBase* height_histogram = base::LinearHistogram::FactoryGet(
+      kFlashClickSizeHeightHistogram,
+      0,    // minimum height

[groby-ooo-7-16, 2014/11/07 23:02:20]

min/max height should probably be 200-400

[tommycli, 2014/11/07 23:14:10]

See above. It's not a huge deal, but it seems nice to get the whole range.

+      1000, // maximum height
+      100,  // number of buckets.
+      base::HistogramBase::kUmaTargetedHistogramFlag);
+  height_histogram->Add(height);
+
+  UMA_HISTOGRAM_ASPECT_RATIO(kFlashClickSizeAspectRatioHistogram, width,
+                             height);
+}
 
 void RecordUnthrottleMethodMetric(PowerSaverUnthrottleMethod method) {
   UMA_HISTOGRAM_ENUMERATION(kPowerSaverUnthrottleHistogram, method,
                             UNTHROTTLE_METHOD_NUM_ITEMS);
 }
 
 bool IsFlashPlugin(PluginModule* module) {
   return module->name() == kFlashPluginName;
 }
 
@@ skipping 90 matching lines @@
     const GURL& plugin_url)
     : RenderFrameObserver(render_frame),
       render_frame_(render_frame),
       module_(module),
       instance_interface_(instance_interface),
       pp_instance_(0),
       container_(container),
       layer_bound_to_fullscreen_(false),
       layer_is_hardware_(false),
       plugin_url_(plugin_url),
+      has_been_clicked_(false),
       power_saver_enabled_(false),
       is_peripheral_content_(false),
       plugin_throttled_(false),
       full_frame_(false),
       sent_initial_did_change_view_(false),
       bound_graphics_2d_platform_(NULL),
       bound_compositor_(NULL),
       has_webkit_focus_(false),
       has_content_area_focus_(false),
       find_identifier_(-1),
@@ skipping 75 matching lines @@
           GetPluginURL());
     }
   }
 
   RendererPpapiHostImpl* host_impl = module_->renderer_ppapi_host();
   resource_creation_ = host_impl->CreateInProcessResourceCreationAPI(this);
 
   if (GetContentClient()->renderer() &&  // NULL in unit tests.
       GetContentClient()->renderer()->IsExternalPepperPlugin(module->name()))
     external_document_load_ = true;
-
-  if (IsFlashPlugin(module_.get())) {
-    RenderThread::Get()->RecordAction(
-        base::UserMetricsAction("Flash.PluginInstanceCreated"));
-  }
 }
 
 PepperPluginInstanceImpl::~PepperPluginInstanceImpl() {
   DCHECK(!fullscreen_container_);
 
   if (plugin_throttled_)
     RecordUnthrottleMethodMetric(UNTHROTTLE_METHOD_NEVER);
 
   // Notify all the plugin objects of deletion. This will prevent blink from
   // calling into the plugin any more.
@@ skipping 240 matching lines @@
 #endif
 }
 
 bool PepperPluginInstanceImpl::Initialize(
     const std::vector<std::string>& arg_names,
     const std::vector<std::string>& arg_values,
     bool full_frame) {
   if (!render_frame_)
     return false;
 
+  blink::WebRect bounds = container_->element().boundsInViewportSpace();
+  if (IsFlashPlugin(module_.get())) {
+    RenderThread::Get()->RecordAction(
+        base::UserMetricsAction("Flash.PluginInstanceCreated"));
+    RecordFlashSizeMetric(bounds.width, bounds.height);
+  }
+
   PluginPowerSaverHelper* power_saver_helper =
       render_frame_->plugin_power_saver_helper();
   GURL content_origin = plugin_url_.GetOrigin();
-  blink::WebRect bounds = container_->element().boundsInViewportSpace();
 
   bool cross_origin = false;
   is_peripheral_content_ =
       IsFlashPlugin(module_.get()) &&
       power_saver_helper->ShouldThrottleContent(content_origin, bounds.width,
                                                 bounds.height, &cross_origin);
 
   power_saver_enabled_ = is_peripheral_content_ &&
                          base::CommandLine::ForCurrentProcess()->HasSwitch(
                              switches::kEnablePluginPowerSaver);
@@ skipping 263 matching lines @@
   gfx::Rect caret(text_input_caret_);
   caret.Offset(view_data_.rect.point.x, view_data_.rect.point.y);
   return caret;
 }
 
 bool PepperPluginInstanceImpl::HandleInputEvent(
     const blink::WebInputEvent& event,
     WebCursorInfo* cursor_info) {
   TRACE_EVENT0("ppapi", "PepperPluginInstanceImpl::HandleInputEvent");
 
+  if (event.type == blink::WebInputEvent::MouseDown && !has_been_clicked_ &&
+      IsFlashPlugin(module_.get())) {
+    has_been_clicked_ = true;
+    blink::WebRect bounds = 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;
     }
@@ skipping 2195 matching lines @@
     return;
 
   is_peripheral_content_ = false;
   power_saver_enabled_ = false;
   SetPluginThrottled(false);
 
   RecordUnthrottleMethodMetric(UNTHROTTLE_METHOD_BY_WHITELIST);
 }
 
 }  // namespace content