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/scoped_pp_var.h"
 #include "ppapi/shared_impl/time_conversion.h"
+#include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_graphics_2d_api.h"
 #include "ppapi/thunk/thunk.h"
 
 #if defined(OS_CHROMEOS)
 #include "ppapi/c/private/ppb_platform_verification_private.h"
 #endif
 
 using ppapi::InputEventData;
 using ppapi::PpapiGlobals;
@@ skipping 20 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);
+  }
+
+  virtual ~PowerSaverTestPluginDelegate() {
+    throttler_->RemoveObserver(this);
+  }
+
+ private:
+  void OnThrottleStateChange() override {
+    SendMessageToPlugin("throttleStatusChange");
+  }
+
+  void OnPeripheralStateChange() override {
+    SendMessageToPlugin("peripheralStatusChange");
+  }
+
+  void OnHiddenForPlaceholder(bool hidden) override {
+    SendMessageToPlugin("hiddenForPlaceholderStatusChange");
+  }
+
+  void OnThrottlerDestroyed() override { delete this; }
+
+  void SendMessageToPlugin(const std::string& message) {
+    if (throttler_->GetWebPlugin() && throttler_->GetWebPlugin()->instance()) {
+      throttler_->GetWebPlugin()->instance()->HandleMessage(
+          ppapi::ScopedPPVar(ppapi::ScopedPPVar::PassRef(),
+                             ppapi::StringVar::StringToPPVar(message)));

[raymes, 2015/05/01 01:02:05]

This is still a bit un-idiomatic from a pepper perspective. Really it would be
better to have the plugin call GetPowerSaverStatusNotification(PP_Callback
callback, uint32_t notification_type) and then when the callback runs it can
call GetPowerSaverStatusNotification again.

Because this is just for testing, I'm tempted to say it doesn't matter too much.
But if we decide to do that, we should put a note in explaining exactly what
happens in the API definition and suggesting that it's not an ideal approach but
it's convenient for testing.

[tommycli, 2015/05/01 23:12:43]

Done.

+    }
+  }
+
+  // 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) {
+PP_Var GetPowerSaverStatus(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 PP_MakeUndefined();
+  PluginInstanceThrottlerImpl* throttler = plugin_instance->throttler();
+
+  // Refcounted by the returned PP_Var.
+  ppapi::DictionaryVar* dictionary = new ppapi::DictionaryVar;
+  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())));

[raymes, 2015/05/01 01:02:05]

Also, if we're going to postMessage the data, why not just send it all in the
message? You could put all this data into the message that gets sent above and
avoid having 2 API functions. wdyt?

[tommycli, 2015/05/01 23:12:43]

Done.

+  return dictionary->GetPPVar();
+}
+
+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,
+    &GetPowerSaverStatus,
+    &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