Plugin Power Saver: Add some UMAs to test plugins in wild.

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/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 359 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);
   }
 }
 
+// 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";
+
+void RecordUnthrottleMethodMetric(PowerSaverUnthrottleMethod method) {
+  UMA_HISTOGRAM_ENUMERATION(kPowerSaverUnthrottleHistogram, method,
+                            UNTHROTTLE_METHOD_NUM_ITEMS);
+}
+
 bool IsFlashPlugin(PluginModule* module) {
   return module->name() == kFlashPluginName;
 }
 
 }  // namespace
 
 // static
 PepperPluginInstanceImpl* PepperPluginInstanceImpl::Create(
     RenderFrameImpl* render_frame,
     PluginModule* module,
@@ skipping 85 matching lines @@
     : 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),
       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),
       plugin_find_interface_(NULL),
       plugin_input_event_interface_(NULL),
@@ skipping 83 matching lines @@
 
   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.
   //
   // Swap out the set so we can delete from it (the objects will try to
   // unregister themselves inside the delete call).
   PluginObjectSet plugin_object_copy;
   live_plugin_objects_.swap(plugin_object_copy);
   for (PluginObjectSet::iterator i = plugin_object_copy.begin();
        i != plugin_object_copy.end();
        ++i) {
@@ skipping 238 matching lines @@
     bool full_frame) {
   if (!render_frame_)
     return false;
 
   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;
-  power_saver_enabled_ =
-      CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnablePluginPowerSaver) &&
+  is_peripheral_content_ =
       IsFlashPlugin(module_.get()) &&
-      power_saver_helper->ShouldThrottleContent(
-          content_origin, bounds.width, bounds.height, &cross_origin);
+      power_saver_helper->ShouldThrottleContent(content_origin, bounds.width,
+                                                bounds.height, &cross_origin);
 
-  if (power_saver_enabled_) {
+  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(&PepperPluginInstanceImpl::DisablePowerSaverAndUnthrottle,
-                   weak_factory_.GetWeakPtr()));
+        base::Bind(
+            &PepperPluginInstanceImpl::DisablePowerSaverByRetroactiveWhitelist,
+            weak_factory_.GetWeakPtr()));
 
-    throttler_.reset(new PepperPluginInstanceThrottler(
-        base::Bind(&PepperPluginInstanceImpl::SetPluginThrottled,
-                   weak_factory_.GetWeakPtr(), true /* throttled */)));
+    if (power_saver_enabled_) {
+      throttler_.reset(new PepperPluginInstanceThrottler(
+          base::Bind(&PepperPluginInstanceImpl::SetPluginThrottled,
+                     weak_factory_.GetWeakPtr(), true /* throttled */)));
+    }
   } else if (cross_origin) {
     power_saver_helper->WhitelistContentOrigin(content_origin);
   }
 
   message_channel_ = MessageChannel::Create(this, &message_channel_object_);
 
   full_frame_ = full_frame;
 
   UpdateTouchEventRequest();
   container_->setWantsWheelEvents(IsAcceptingWheelEvents());
@@ skipping 239 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::MouseUp && power_saver_enabled_)
+  if (event.type == blink::WebInputEvent::MouseUp && is_peripheral_content_) {
+    is_peripheral_content_ = false;
     power_saver_enabled_ = false;
 
-  if (plugin_throttled_) {
-    if (event.type == blink::WebInputEvent::MouseUp)
+    RecordUnthrottleMethodMetric(UNTHROTTLE_METHOD_BY_CLICK);
+
+    if (plugin_throttled_) {

[raymes, 2014/11/06 22:24:48]

I'm not sure if this is correct anymore. Before this CL, we used to be able to
unthrottle the plugin even after power_saver_enabled_ == false. It seems like
right now we can end up in a state where is_peripheral_content_ goes from true
to false, then plugin_throttled_ gets set to true and then we can never set it
back to false?

Another advantage to shifting this logic out to another class is we can write a
unittest to test this :)

[tommycli, 2014/11/06 22:33:36]

I think this is okay, as the body of SetPluginThrottled says:
if (!power_saver_enabled_ && throttled)
  return;

Since power_saver_enabled_ goes to false at the same time as
is_peripheral_content_, it should never be allowed be throttled when
is_peripheral_content_ is false.

I could be wrong, but that's my reasoning.

I agree that refactoring it out to a separate class will be good.

[raymes, 2014/11/06 22:37:45]

Ok yep I think I agree! Please still do add a test with the refactor that tests
this. It's subtle and prone to break and it's easy to test.

       SetPluginThrottled(false /* throttled */);
-
-    return true;
+      return true;
+    }
   }
 
   if (!render_frame_)
     return false;
   if (WebInputEvent::isMouseEventType(event.type)) {
     render_frame_->PepperDidReceiveMouseEvent(this);
   }
 
   // Don't dispatch input events to crashed plugins.
   if (module()->is_crashed())
@@ skipping 2173 matching lines @@
 
 void PepperPluginInstanceImpl::SetPluginThrottled(bool throttled) {
   // Do not throttle if we've already disabled power saver.
   if (!power_saver_enabled_ && throttled)
     return;
 
   plugin_throttled_ = throttled;
   SendDidChangeView();
 }
 
-void PepperPluginInstanceImpl::DisablePowerSaverAndUnthrottle() {
-  DCHECK(power_saver_enabled_);
+void PepperPluginInstanceImpl::DisablePowerSaverByRetroactiveWhitelist() {
+  if (!is_peripheral_content_)
+    return;
+
+  is_peripheral_content_ = false;
   power_saver_enabled_ = false;
   SetPluginThrottled(false);
+
+  RecordUnthrottleMethodMetric(UNTHROTTLE_METHOD_BY_WHITELIST);
 }
 
 }  // namespace content