Test Keeping 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/message_loop/message_loop.h"
+#include "base/strings/string_number_conversions.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_message_filter.h"
 #include "ppapi/proxy/plugin_proxy_delegate.h"
 #include "ppapi/proxy/resource_reply_thread_registrar.h"
+#include "ppapi/shared_impl/ppapi_switches.h"
 #include "ppapi/shared_impl/ppb_audio_shared.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
@@ skipping 46 matching lines @@
 
   // IPC::Listener implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
 
  private:
   void OnMsgCreateNaClChannel(int renderer_id,
                               const ppapi::PpapiNaClChannelArgs& args,
                               SerializedHandle handle);
   void OnPluginDispatcherMessageReceived(const IPC::Message& msg);
 
+  void SetPpapiKeepAliveThrottleFromCommandLine();
+
   std::set<PP_Instance> instances_;
   std::map<uint32, PluginDispatcher*> plugin_dispatchers_;
   uint32 next_plugin_dispatcher_id_;
   scoped_refptr<base::MessageLoopProxy> message_loop_;
   base::WaitableEvent shutdown_event_;
 };
 
 PpapiDispatcher::PpapiDispatcher(scoped_refptr<base::MessageLoopProxy> io_loop)
     : next_plugin_dispatcher_id_(0),
       message_loop_(io_loop),
@@ skipping 93 matching lines @@
   if (!command_line_and_logging_initialized) {
     CommandLine::Init(0, NULL);
     for (size_t i = 0; i < args.switch_names.size(); ++i) {
       DCHECK(i < args.switch_values.size());
       CommandLine::ForCurrentProcess()->AppendSwitchASCII(
           args.switch_names[i], args.switch_values[i]);
     }
     logging::LoggingSettings settings;
     settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
     logging::InitLogging(settings);
+    SetPpapiKeepAliveThrottleFromCommandLine();
     command_line_and_logging_initialized = true;
   }
   // Tell the process-global GetInterface which interfaces it can return to the
   // plugin.
   ppapi::proxy::InterfaceList::SetProcessGlobalPermissions(
       args.permissions);
   ppapi::proxy::InterfaceList::SetSupportsDevChannel(
       args.supports_dev_channel);
 
   int32_t error = ::PPP_InitializeModule(
@@ skipping 24 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 PpapiDispatcher::SetPpapiKeepAliveThrottleFromCommandLine() {
+  unsigned keepalive_throttle_interval_milliseconds = 0;
+  if (base::StringToUint(
+          CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+              switches::kPpapiKeepAliveThrottle),
+          &keepalive_throttle_interval_milliseconds)) {
+    ppapi::proxy::PluginGlobals::Get()->
+        set_keepalive_throttle_interval_milliseconds(
+            keepalive_throttle_interval_milliseconds);
+  }
+}
+
 }  // 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 16 matching lines @@
     return 1;
   }
 
   PpapiDispatcher ppapi_dispatcher(io_thread.message_loop_proxy());
   plugin_globals.set_plugin_proxy_delegate(&ppapi_dispatcher);
 
   loop.Run();
 
   return 0;
 }