Keep NaCl plugins used in app background pages alive when active.

ppapi/proxy/plugin_main_nacl.cc

Index: ppapi/proxy/plugin_main_nacl.cc
diff --git a/ppapi/proxy/plugin_main_nacl.cc b/ppapi/proxy/plugin_main_nacl.cc
index f050778227cad4eef35c4f1c26f59fe1a6ccbcbe..46c988a80f3114594b1759c1890add14e32eba22 100644
--- a/ppapi/proxy/plugin_main_nacl.cc
+++ b/ppapi/proxy/plugin_main_nacl.cc
@@ -12,6 +12,7 @@
 // ViewMsgLog et al. functions.
 
 #include "base/command_line.h"
+#include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
@@ -28,6 +29,7 @@
 #include "ppapi/proxy/plugin_globals.h"
 #include "ppapi/proxy/plugin_proxy_delegate.h"
 #include "ppapi/shared_impl/ppb_audio_shared.h"
+#include "ppapi/shared_impl/proxy_lock.h"
 
 #if defined(IPC_MESSAGE_LOG_ENABLED)
 #include "base/containers/hash_tables.h"
@@ -53,6 +55,12 @@ using ppapi::proxy::SerializedHandle;
 
 namespace {
 
+// Interval to check if plugin has been active and report to the browser
+// process. The value is somewhat arbitrary. It should be large enough to
+// minimize computation overhead and small enough to not add exessive latency
+// to detecting idle processes.
+const int kIdleCheckIntervalInSeconds = 5;
+
 // This class manages communication between the plugin and the browser, and
 // manages the PluginDispatcher instances for communication between the plugin
 // and the renderer.
@@ -257,6 +265,24 @@ void PpapiDispatcher::OnPluginDispatcherMessageReceived(
     dispatcher->second->OnMessageReceived(msg);
 }
 
+void CheckActivity(bool last_was_active) {

[Mark Seaborn, 2013/11/15 23:51:24]

It looks like this will make every NaCl process wake up every 5 seconds.  This
is generally not a good idea.  It will waste power, which is a problem on
battery-powered systems, and it will increase memory pressure.  If NaCl
processes are idle, it should be possible for the system to swap out all the
pages they're using, and not page in the nexe (and the NaCl trusted runtime)
until the user starts interacting with the nexe again.  If the process wakes up
every 5 seconds, the system probably won't be able to page it out.

If you really need to do this activity check for nexes in background pages in
Chrome extensions, the check should only enable the wakeup in that case so that
it doesn't affect other cases.

(I don't understand the motivation for this activity check fully yet, but I'll
read the design doc.)

[scheib, 2013/12/11 21:35:40]

Done by having the plugin only report when it is active (at a throttled rate)
and having the browser implement the conversion of activity impulses to a
increment / decrement for keep alive.

+  ppapi::ProxyAutoLock lock;
+  if (!PluginGlobals::Get())
+    return;
+
+  bool was_active = PluginGlobals::Get()->plugin_has_been_active();
+  PluginGlobals::Get()->set_plugin_has_been_active(false);
+
+  if (last_was_active != was_active) {
+    PluginGlobals::Get()->GetBrowserSender()->Send(
+        new PpapiHostMsg_IdleStateChange(!was_active));
+  }
+
+  base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
+      base::Bind(&CheckActivity, was_active),
+      base::TimeDelta::FromSeconds(kIdleCheckIntervalInSeconds));
+}
+
 }  // namespace
 
 void PpapiPluginRegisterThreadCreator(
@@ -289,6 +315,9 @@ int PpapiPluginMain() {
   PpapiDispatcher ppapi_dispatcher(io_thread.message_loop_proxy());
   plugin_globals.set_plugin_proxy_delegate(&ppapi_dispatcher);
 
+  base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
+      base::Bind(&CheckActivity, false),
+      base::TimeDelta::FromSeconds(kIdleCheckIntervalInSeconds));
   loop.Run();
 
   return 0;