Plugin Power Saver: Make PepperPluginInstanceThrottler interface public.

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/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 20 matching lines @@
 #include "content/renderer/pepper/fullscreen_container.h"
 #include "content/renderer/pepper/gfx_conversion.h"
 #include "content/renderer/pepper/host_dispatcher_wrapper.h"
 #include "content/renderer/pepper/host_globals.h"
 #include "content/renderer/pepper/message_channel.h"
 #include "content/renderer/pepper/pepper_browser_connection.h"
 #include "content/renderer/pepper/pepper_compositor_host.h"
 #include "content/renderer/pepper/pepper_file_ref_renderer_host.h"
 #include "content/renderer/pepper/pepper_graphics_2d_host.h"
 #include "content/renderer/pepper/pepper_in_process_router.h"
-#include "content/renderer/pepper/pepper_plugin_instance_impl.h"
-#include "content/renderer/pepper/pepper_plugin_instance_throttler.h"
+#include "content/renderer/pepper/pepper_plugin_instance_metrics.h"
 #include "content/renderer/pepper/pepper_try_catch.h"
 #include "content/renderer/pepper/pepper_url_loader_host.h"
+#include "content/renderer/pepper/plugin_instance_throttler_impl.h"
 #include "content/renderer/pepper/plugin_module.h"
 #include "content/renderer/pepper/plugin_object.h"
 #include "content/renderer/pepper/ppapi_preferences_builder.h"
 #include "content/renderer/pepper/ppb_buffer_impl.h"
 #include "content/renderer/pepper/ppb_graphics_3d_impl.h"
 #include "content/renderer/pepper/ppb_image_data_impl.h"
 #include "content/renderer/pepper/renderer_ppapi_host_impl.h"
 #include "content/renderer/pepper/url_request_info_util.h"
 #include "content/renderer/pepper/url_response_info_util.h"
 #include "content/renderer/render_frame_impl.h"
@@ skipping 18 matching lines @@
 #include "ppapi/c/private/ppb_find_private.h"
 #include "ppapi/c/private/ppp_find_private.h"
 #include "ppapi/c/private/ppp_instance_private.h"
 #include "ppapi/c/private/ppp_pdf.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/serialized_var.h"
 #include "ppapi/proxy/uma_private_resource.h"
 #include "ppapi/proxy/url_loader_resource.h"
 #include "ppapi/shared_impl/ppapi_permissions.h"
-#include "ppapi/shared_impl/ppapi_preferences.h"
 #include "ppapi/shared_impl/ppb_gamepad_shared.h"
 #include "ppapi/shared_impl/ppb_input_event_shared.h"
 #include "ppapi/shared_impl/ppb_url_util_shared.h"
 #include "ppapi/shared_impl/ppb_view_shared.h"
 #include "ppapi/shared_impl/ppp_instance_combined.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/shared_impl/scoped_pp_resource.h"
 #include "ppapi/shared_impl/scoped_pp_var.h"
 #include "ppapi/shared_impl/time_conversion.h"
 #include "ppapi/shared_impl/url_request_info_data.h"
@@ skipping 28 matching lines @@
 #include "third_party/khronos/GLES2/gl2.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_rep.h"
 #include "ui/gfx/range/range.h"
 #include "v8/include/v8.h"
 
 #if defined(OS_CHROMEOS)
 #include "ui/events/keycodes/keyboard_codes_posix.h"
 #endif
 
-#if defined(OS_WIN)
-#include "base/metrics/histogram.h"
-#include "base/win/windows_version.h"
-#include "skia/ext/platform_canvas.h"
-#endif
-
 using base::StringPrintf;
 using ppapi::InputEventData;
 using ppapi::PpapiGlobals;
 using ppapi::PPB_InputEvent_Shared;
 using ppapi::PPB_View_Shared;
 using ppapi::PPP_Instance_Combined;
 using ppapi::Resource;
 using ppapi::ScopedPPResource;
 using ppapi::ScopedPPVar;
 using ppapi::StringVar;
@@ skipping 331 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),
       is_flash_plugin_(module->name() == kFlashPluginName),
+      has_been_clicked_(false),
       javascript_used_(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 116 matching lines @@
 
   UnSetAndDeleteLockTargetAdapter();
   module_->InstanceDeleted(this);
   // If we switched from the NaCl plugin module, notify it too.
   if (original_module_.get())
     original_module_->InstanceDeleted(this);
 
   // This should be last since some of the above "instance deleted" calls will
   // want to look up in the global map to get info off of our object.
   HostGlobals::Get()->InstanceDeleted(pp_instance_);
+
+  if (throttler_)
+    throttler_->RemoveObserver(this);
 }
 
 // NOTE: Any of these methods that calls into the plugin needs to take into
 // account that the plugin may use Var to remove the <embed> from the DOM, which
 // will make the PepperWebPluginImpl drop its reference, usually the last one.
 // If a method needs to access a member of the instance after the call has
 // returned, then it needs to keep its own reference on the stack.
 
 v8::Local<v8::Object> PepperPluginInstanceImpl::GetMessageChannelObject() {
   return v8::Local<v8::Object>::New(isolate_, message_channel_object_);
@@ skipping 156 matching lines @@
   if (content_decryptor_delegate_) {
     content_decryptor_delegate_->InstanceCrashed();
     content_decryptor_delegate_.reset();
   }
 
   if (render_frame_)
     render_frame_->PluginCrashed(module_->path(), module_->GetPeerProcessId());
   UnSetAndDeleteLockTargetAdapter();
 }
 
-static void SetGPUHistogram(const ppapi::Preferences& prefs,
-                            const std::vector<std::string>& arg_names,
-                            const std::vector<std::string>& arg_values) {
-// Calculate a histogram to let us determine how likely people are to try to
-// run Stage3D content on machines that have it blacklisted.
-#if defined(OS_WIN)
-  bool needs_gpu = false;
-  bool is_xp = base::win::GetVersion() <= base::win::VERSION_XP;
-
-  for (size_t i = 0; i < arg_names.size(); i++) {
-    if (arg_names[i] == "wmode") {
-      // In theory content other than Flash could have a "wmode" argument,
-      // but that's pretty unlikely.
-      if (arg_values[i] == "direct" || arg_values[i] == "gpu")
-        needs_gpu = true;
-      break;
-    }
-  }
-  // 0 : No 3D content and GPU is blacklisted
-  // 1 : No 3D content and GPU is not blacklisted
-  // 2 : 3D content but GPU is blacklisted
-  // 3 : 3D content and GPU is not blacklisted
-  // 4 : No 3D content and GPU is blacklisted on XP
-  // 5 : No 3D content and GPU is not blacklisted on XP
-  // 6 : 3D content but GPU is blacklisted on XP
-  // 7 : 3D content and GPU is not blacklisted on XP
-  UMA_HISTOGRAM_ENUMERATION(
-      "Flash.UsesGPU", is_xp * 4 + needs_gpu * 2 + prefs.is_webgl_supported, 8);
-#endif
-}
-
 bool PepperPluginInstanceImpl::Initialize(
     const std::vector<std::string>& arg_names,
     const std::vector<std::string>& arg_values,
     bool full_frame,
-    RenderFrame::PluginPowerSaverMode power_saver_mode) {
+    scoped_ptr<PluginInstanceThrottlerImpl> throttler) {
+  DCHECK(!throttler_);
+
   if (!render_frame_)
     return false;
 
-  blink::WebRect bounds = container()->element().boundsInViewportSpace();
+  if (is_flash_plugin_ && RenderThread::Get()) {
+    RenderThread::Get()->RecordAction(
+        base::UserMetricsAction("Flash.PluginInstanceCreated"));
+    blink::WebRect bounds = container()->element().boundsInViewportSpace();
+    RecordFlashSizeMetric(bounds.width, bounds.height);
+  }
 
-  throttler_.reset(new PepperPluginInstanceThrottler(
-      render_frame(), bounds, is_flash_plugin_, plugin_url_, power_saver_mode,
-      base::Bind(&PepperPluginInstanceImpl::SendDidChangeView,
-                 weak_factory_.GetWeakPtr())));
+  if (throttler) {
+    throttler_ = throttler.Pass();
+    throttler_->AddObserver(this);
+  }
 
   message_channel_ = MessageChannel::Create(this, &message_channel_object_);
 
   full_frame_ = full_frame;
 
   UpdateTouchEventRequest();
   container_->setWantsWheelEvents(IsAcceptingWheelEvents());
 
   SetGPUHistogram(ppapi::Preferences(PpapiPreferencesBuilder::Build(
                       render_frame_->render_view()->webkit_preferences())),
@@ skipping 236 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 (throttler_->ConsumeInputEvent(event))
+  if (!has_been_clicked_ && is_flash_plugin_ &&
+      event.type == blink::WebInputEvent::MouseDown &&
+      (event.modifiers & blink::WebInputEvent::LeftButtonDown)) {
+    has_been_clicked_ = true;
+    blink::WebRect bounds = container()->element().boundsInViewportSpace();
+    RecordFlashClickSizeMetric(bounds.width, bounds.height);
+  }
+
+  if (throttler_ && throttler_->ConsumeInputEvent(event))
     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 526 matching lines @@
 
 void PepperPluginInstanceImpl::SendDidChangeView() {
   // Don't send DidChangeView to crashed plugins.
   if (module()->is_crashed())
     return;
 
   ppapi::ViewData view_data = view_data_;
 
   // When plugin content is throttled, fake the page being offscreen. We cannot
   // send empty view data here, as some plugins rely on accurate view data.
-  if (throttler_ && throttler_->is_throttled()) {
+  if (throttler_ && throttler_->IsThrottled()) {
     view_data.is_page_visible = false;
     view_data.clip_rect.point.x = 0;
     view_data.clip_rect.point.y = 0;
     view_data.clip_rect.size.width = 0;
     view_data.clip_rect.size.height = 0;
   }
 
   if (view_change_weak_ptr_factory_.HasWeakPtrs() ||
       (sent_initial_did_change_view_ &&
        last_sent_view_data_.Equals(view_data)))
@@ skipping 391 matching lines @@
     scoped_ptr<cc::SingleReleaseCallback>* release_callback,
     bool use_shared_memory) {
   if (!bound_graphics_2d_platform_)
     return false;
   return bound_graphics_2d_platform_->PrepareTextureMailbox(mailbox,
                                                             release_callback);
 }
 
 void PepperPluginInstanceImpl::OnDestruct() { render_frame_ = NULL; }
 
+void PepperPluginInstanceImpl::OnThrottleStateChange() {
+  SendDidChangeView();
+}
+
 void PepperPluginInstanceImpl::AddLatencyInfo(
     const std::vector<ui::LatencyInfo>& latency_info) {
   if (render_frame_ && render_frame_->GetRenderWidget()) {
     RenderWidgetCompositor* compositor =
         render_frame_->GetRenderWidget()->compositor();
     if (compositor) {
       for (size_t i = 0; i < latency_info.size(); i++) {
         scoped_ptr<cc::SwapPromise> swap_promise(
             new cc::LatencyInfoSwapPromise(latency_info[i]));
         compositor->QueueSwapPromise(swap_promise.Pass());
@@ skipping 1221 matching lines @@
 
 void PepperPluginInstanceImpl::RecordFlashJavaScriptUse() {
   if (!javascript_used_ && is_flash_plugin_) {
     javascript_used_ = true;
     RenderThread::Get()->RecordAction(
         base::UserMetricsAction("Flash.JavaScriptUsed"));
   }
 }
 
 }  // namespace content