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

ppapi/proxy/plugin_main_nacl.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 <map>
 #include <set>
 
 #include "build/build_config.h"
 // Need to include this before most other files because it defines
 // IPC_MESSAGE_LOG_ENABLED. We need to use it to define
 // IPC_MESSAGE_MACROS_LOG_ENABLED so ppapi_messages.h will generate the
 // 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"
 #include "components/tracing/child_trace_message_filter.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_message.h"
 #include "native_client/src/shared/srpc/nacl_srpc.h"
 #include "native_client/src/untrusted/irt/irt_ppapi.h"
 #include "ppapi/c/ppp.h"
 #include "ppapi/c/ppp_instance.h"
 #include "ppapi/native_client/src/shared/ppapi_proxy/ppruntime.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #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"
 
 LogFunctionMap g_log_function_mapping;
 
 #define IPC_MESSAGE_MACROS_LOG_ENABLED
 #define IPC_LOG_TABLE_ADD_ENTRY(msg_id, logger) \
   g_log_function_mapping[msg_id] = logger
 
 #endif
 #include "ppapi/proxy/ppapi_messages.h"
 
 // This must match up with NACL_CHROME_INITIAL_IPC_DESC,
 // defined in sel_main_chrome.h
 #define NACL_IPC_FD 6
 
 using ppapi::proxy::PluginDispatcher;
 using ppapi::proxy::PluginGlobals;
 using ppapi::proxy::PluginProxyDelegate;
 using ppapi::proxy::ProxyChannel;
 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.
 class PpapiDispatcher : public ProxyChannel,
                         public PluginDispatcher::PluginDelegate,
                         public PluginProxyDelegate {
  public:
   explicit PpapiDispatcher(scoped_refptr<base::MessageLoopProxy> io_loop);
 
   // PluginDispatcher::PluginDelegate implementation.
@@ skipping 184 matching lines @@
   if (!msg.ReadUInt32(&iter, &id)) {
     NOTREACHED();
     return;
   }
   std::map<uint32, ppapi::proxy::PluginDispatcher*>::iterator dispatcher =
       plugin_dispatchers_.find(id);
   if (dispatcher != plugin_dispatchers_.end())
     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(
     const struct PP_ThreadFunctions* thread_functions) {
   // Initialize all classes that need to create threads that call back into
   // user code.
   ppapi::PPB_Audio_Shared::SetThreadFunctions(thread_functions);
 }
 
 int PpapiPluginMain() {
@@ skipping 12 matching lines @@
   // module and start the PPAPI proxy so that the NaCl plugin can continue
   // loading the app.
   static struct NaClSrpcHandlerDesc srpc_methods[] = { { NULL, NULL } };
   if (!NaClSrpcAcceptClientOnThread(srpc_methods)) {
     return 1;
   }
 
   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;
 }