Plugin Power Saver: Make PPS work well with prerendered pages.

content/renderer/pepper/plugin_module.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/plugin_module.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 117 matching lines @@
 #include "ppapi/c/private/ppb_uma_private.h"
 #include "ppapi/c/private/ppb_video_destination_private.h"
 #include "ppapi/c/private/ppb_video_source_private.h"
 #include "ppapi/c/private/ppb_x509_certificate_private.h"
 #include "ppapi/c/trusted/ppb_broker_trusted.h"
 #include "ppapi/c/trusted/ppb_browser_font_trusted.h"
 #include "ppapi/c/trusted/ppb_char_set_trusted.h"
 #include "ppapi/c/trusted/ppb_file_chooser_trusted.h"
 #include "ppapi/c/trusted/ppb_url_loader_trusted.h"
 #include "ppapi/shared_impl/callback_tracker.h"
+#include "ppapi/shared_impl/dictionary_var.h"
 #include "ppapi/shared_impl/ppapi_preferences.h"
 #include "ppapi/shared_impl/ppapi_switches.h"
 #include "ppapi/shared_impl/ppb_input_event_shared.h"
 #include "ppapi/shared_impl/ppb_opengles2_shared.h"
 #include "ppapi/shared_impl/ppb_var_shared.h"
 #include "ppapi/shared_impl/time_conversion.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_graphics_2d_api.h"
 #include "ppapi/thunk/thunk.h"
 
@@ skipping 26 matching lines @@
 
 // Maintains all currently loaded plugin libs for validating PP_Module
 // identifiers.
 typedef std::set<PluginModule*> PluginModuleSet;
 
 PluginModuleSet* GetLivePluginSet() {
   CR_DEFINE_STATIC_LOCAL(PluginModuleSet, live_plugin_libs, ());
   return &live_plugin_libs;
 }
 
+class PowerSaverTestPluginDelegate : public PluginInstanceThrottler::Observer {
+ public:
+  explicit PowerSaverTestPluginDelegate(PluginInstanceThrottlerImpl* throttler)
+      : throttler_(throttler) {
+    throttler_->AddObserver(this);
+    PostPowerSaverStatusToJavaScript(throttler_, "initial");
+  }
+
+  virtual ~PowerSaverTestPluginDelegate() { throttler_->RemoveObserver(this); }
+
+  static void PostPowerSaverStatusToJavaScript(
+      PluginInstanceThrottlerImpl* throttler,
+      const std::string& source) {
+    if (!throttler->GetWebPlugin() || !throttler->GetWebPlugin()->instance())
+      return;
+
+    PepperPluginInstanceImpl* instance = throttler->GetWebPlugin()->instance();
+
+    // Refcounted by the returned PP_Var.
+    ppapi::DictionaryVar* dictionary = new ppapi::DictionaryVar;
+    dictionary->Set(ppapi::StringVar::StringToPPVar("source"),
+                    ppapi::StringVar::StringToPPVar(source));
+    dictionary->Set(
+        ppapi::StringVar::StringToPPVar("isHiddenForPlaceholder"),
+        PP_MakeBool(PP_FromBool(throttler->IsHiddenForPlaceholder())));
+    dictionary->Set(ppapi::StringVar::StringToPPVar("isPeripheral"),
+                    PP_MakeBool(PP_FromBool(throttler->power_saver_enabled())));
+    dictionary->Set(ppapi::StringVar::StringToPPVar("isThrottled"),
+                    PP_MakeBool(PP_FromBool(throttler->IsThrottled())));
+
+    instance->PostMessageToJavaScript(dictionary->GetPPVar());
+  }
+
+ private:
+  void OnThrottleStateChange() override {
+    PostPowerSaverStatusToJavaScript(throttler_, "throttleStatusChange");
+  }
+
+  void OnPeripheralStateChange() override {
+    PostPowerSaverStatusToJavaScript(throttler_, "peripheralStatusChange");
+  }
+
+  void OnHiddenForPlaceholder(bool hidden) override {
+    PostPowerSaverStatusToJavaScript(throttler_,
+                                     "hiddenForPlaceholderStatusChange");
+  }
+
+  void OnThrottlerDestroyed() override { delete this; }
+
+  // Non-owning pointer.
+  PluginInstanceThrottlerImpl* const throttler_;
+};
+
 // PPB_Core --------------------------------------------------------------------
 
 void AddRefResource(PP_Resource resource) {
   PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(resource);
 }
 
 void ReleaseResource(PP_Resource resource) {
   PpapiGlobals::Get()->GetResourceTracker()->ReleaseResource(resource);
 }
 
@@ skipping 45 matching lines @@
   base::MessageLoop::current()->QuitNow();
 }
 
 uint32_t GetLiveObjectsForInstance(PP_Instance instance_id) {
   return HostGlobals::Get()->GetResourceTracker()->GetLiveObjectsForInstance(
       instance_id);
 }
 
 PP_Bool IsOutOfProcess() { return PP_FALSE; }
 
-PP_Bool IsPeripheral(PP_Instance instance_id) {
+void PostPowerSaverStatus(PP_Instance instance_id) {
   PepperPluginInstanceImpl* plugin_instance =
       host_globals->GetInstance(instance_id);
   if (!plugin_instance || !plugin_instance->throttler())
-    return PP_FALSE;
-  return PP_FromBool(plugin_instance->throttler()->power_saver_enabled());
+    return;
+
+  PowerSaverTestPluginDelegate::PostPowerSaverStatusToJavaScript(
+      plugin_instance->throttler(), "getPowerSaverStatusResponse");
+}
+
+void SubscribeToPowerSaverNotifications(PP_Instance instance_id) {
+  PepperPluginInstanceImpl* plugin_instance =
+      host_globals->GetInstance(instance_id);
+  if (!plugin_instance || !plugin_instance->throttler())
+    return;
+
+  // Manages its own lifetime.
+  new PowerSaverTestPluginDelegate(plugin_instance->throttler());
 }
 
 void SimulateInputEvent(PP_Instance instance, PP_Resource input_event) {
   PepperPluginInstanceImpl* plugin_instance =
       host_globals->GetInstance(instance);
   if (!plugin_instance)
     return;
 
   EnterResource<PPB_InputEvent_API> enter(input_event, false);
   if (enter.failed())
@@ skipping 30 matching lines @@
   content::PepperPluginInstance::Get(instance)->GetIsolate()->
       RequestGarbageCollectionForTesting(v8::Isolate::kFullGarbageCollection);
 }
 
 const PPB_Testing_Private testing_interface = {
     &ReadImageData,
     &RunMessageLoop,
     &QuitMessageLoop,
     &GetLiveObjectsForInstance,
     &IsOutOfProcess,
-    &IsPeripheral,
+    &PostPowerSaverStatus,
+    &SubscribeToPowerSaverNotifications,
     &SimulateInputEvent,
     &GetDocumentURL,
     &GetLiveVars,
     &SetMinimumArrayBufferSizeForShmem,
     &RunV8GC};
 
 // GetInterface ----------------------------------------------------------------
 
 const void* InternalGetInterface(const char* name) {
   // Allow custom interface factories first stab at the GetInterface call.
@@ skipping 420 matching lines @@
                                         channel_handle,
                                         peer_pid,
                                         plugin_child_id,
                                         false))  // is_external = false
     return scoped_refptr<PluginModule>();
 
   return module;
 }
 
 }  // namespace content