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

chrome/browser/nacl_host/nacl_process_host.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 "chrome/browser/nacl_host/nacl_process_host.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/process/launch.h"
 #include "base/process/process_iterator.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "build/build_config.h"
+#include "chrome/browser/extensions/extension_service.h"

[Mark Seaborn, 2013/11/15 01:32:56]

I don't know if you want a review for this change yet, but we are not supposed
to have any dependencies on Chrome extensions in this file any more.  (The file
is planned to be moved to components/nacl/ soon.)

So any references to chrome/'s extensions subsystem here should be done via
NaClBrowser::GetDelegate().

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

Done.

+#include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/nacl_host/nacl_host_message_filter.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/nacl/browser/nacl_browser.h"
 #include "components/nacl/common/nacl_cmd_line.h"
 #include "components/nacl/common/nacl_host_messages.h"
 #include "components/nacl/common/nacl_messages.h"
 #include "components/nacl/common/nacl_process_type.h"
 #include "components/nacl/common/nacl_switches.h"
 #include "content/public/browser/browser_child_process_host.h"
 #include "content/public/browser/browser_ppapi_host.h"
 #include "content/public/browser/child_process_data.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/site_instance.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
+#include "extensions/browser/process_manager.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_switches.h"
 #include "native_client/src/shared/imc/nacl_imc_c.h"
 #include "net/base/net_util.h"
 #include "net/socket/tcp_listen_socket.h"
 #include "ppapi/host/host_factory.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/ppapi_nacl_channel_args.h"
 
@@ skipping 139 matching lines @@
 }
 
 ppapi::PpapiPermissions GetNaClPermissions(uint32 permission_bits) {
   // Only allow NaCl plugins to request certain permissions. We don't want
   // a compromised renderer to be able to start a nacl plugin with e.g. Flash
   // permissions which may expand the surface area of the sandbox.
   uint32 masked_bits = permission_bits & ppapi::PERMISSION_DEV;
   return ppapi::PpapiPermissions::GetForCommandLine(masked_bits);
 }
 
+// Handles an extension's NaCl process transitioning in or out of idle state by
+// relaying the state to the extension's process manager.
+//
+// A NaCl instance monitors its activity and sends an IPC to the browser
+// process BrowserPpapiHost upon transitioning in our out of idleness. The
+// content::BrowserPpapiHost passes context information up to the chrome level
+// NaClProcessHost where we use the instance's context to find the associated
+// extension process manager.
+//
+// There is 1:many relationship for extension:nacl-embeds, but only a
+// 1:1 relationship for NaClProcessHost:PP_Instance. The content layer doesn't
+// rely on this knowledge because it routes messages for ppapi non-nacl
+// instances as well, though they won't have callbacks set. Here the 1:1
+// assumption is made and DCHECKed.
+void OnIdleStateChangeOnUIThread(
+    content::BrowserPpapiHost::OnIdleChangeInstanceData intance_data,
+    const base::FilePath profile_data_directory,
+    bool idle) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // Only one instance will exist for NaCl embeds, even when more than one
+  // embed of the same plugin exists on the same page.
+  DCHECK(intance_data.size() == 1);
+  if (intance_data.size() < 1)
+    return;
+
+  content::RenderViewHost* render_view_host = content::RenderViewHost::FromID(
+      intance_data[0].render_process_id, intance_data[0].render_view_id);
+  DCHECK(render_view_host);
+  if (!render_view_host)
+    return;
+
+  content::SiteInstance* site_instance = render_view_host->GetSiteInstance();
+  DCHECK(site_instance);
+  if (!site_instance)
+    return;
+
+  extensions::ExtensionSystem* extension_system =
+      extensions::ExtensionSystem::GetForBrowserContext(
+          site_instance->GetBrowserContext());
+  DCHECK(extension_system);
+  if (!extension_system)
+    return;
+
+  const ExtensionService* extension_service =
+      extension_system->extension_service();
+  DCHECK(extension_service);
+  if (!extension_service)
+    return;
+
+  const extensions::Extension* extension = extension_service->GetExtensionById(
+      intance_data[0].document_url.host(), false);
+  if (!extension)
+    return;
+
+  extensions::ProcessManager* pm = extension_system->process_manager();
+  DCHECK(pm);
+  if (!pm)
+    return;
+
+  if (idle) {
+    fprintf(stderr, "%s:%s:%d DecrementLazyKeepaliveCount\n",
+            __FILE__, __FUNCTION__, __LINE__);
+    pm->DecrementLazyKeepaliveCount(extension);
+  } else {
+    fprintf(stderr, "%s:%s:%d IncrementLazyKeepaliveCount\n",
+            __FILE__, __FUNCTION__, __LINE__);
+    pm->IncrementLazyKeepaliveCount(extension);
+  }
+}
+
+// Calls OnIdleStateChangeOnUIThread on UI thread.
+void OnIdleStateChange(
+    content::BrowserPpapiHost::OnIdleChangeInstanceData intance_data,
+    const base::FilePath profile_data_directory,
+    bool idle) {
+  DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&OnIdleStateChangeOnUIThread,
+                                     intance_data,
+                                     profile_data_directory,
+                                     idle));
+}
+
 }  // namespace
 
 struct NaClProcessHost::NaClInternal {
   NaClHandle socket_for_renderer;
   NaClHandle socket_for_sel_ldr;
 
   NaClInternal()
     : socket_for_renderer(NACL_INVALID_HANDLE),
       socket_for_sel_ldr(NACL_INVALID_HANDLE) { }
 };
@@ skipping 579 matching lines @@
     // browser process.
     ppapi_host_.reset(content::BrowserPpapiHost::CreateExternalPluginProcess(
         ipc_proxy_channel_.get(),  // sender
         permissions_,
         process_->GetData().handle,
         ipc_proxy_channel_.get(),
         nacl_host_message_filter_->render_process_id(),
         render_view_id_,
         profile_directory_));
 
+    ppapi_host_->SetOnIdleChangeCallback(base::Bind(&OnIdleStateChange));
+
     ppapi::PpapiNaClChannelArgs args;
     args.off_the_record = nacl_host_message_filter_->off_the_record();
     args.permissions = permissions_;
     CommandLine* cmdline = CommandLine::ForCurrentProcess();
     DCHECK(cmdline);
     std::string flag_whitelist[] = {switches::kV, switches::kVModule};
     for (size_t i = 0; i < arraysize(flag_whitelist); ++i) {
       std::string value = cmdline->GetSwitchValueASCII(flag_whitelist[i]);
       if (!value.empty()) {
         args.switch_names.push_back(flag_whitelist[i]);
@@ skipping 204 matching lines @@
   } else {
     NaClStartDebugExceptionHandlerThread(
         process_handle.Take(), info,
         base::MessageLoopProxy::current(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif