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

content/browser/renderer_host/pepper/browser_ppapi_host_impl.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/browser/renderer_host/pepper/browser_ppapi_host_impl.h"
 
 #include "content/browser/renderer_host/pepper/pepper_message_filter.h"
 #include "content/browser/tracing/trace_message_filter.h"
 #include "content/common/pepper_renderer_instance_data.h"
 #include "content/public/browser/render_view_host.h"
+#include "content/public/browser/site_instance.h"
 #include "content/public/common/process_type.h"
 #include "ipc/ipc_message_macros.h"
+#include "ppapi/proxy/ppapi_messages.h"
 
 namespace content {
 
 // static
-BrowserPpapiHost* BrowserPpapiHost::CreateExternalPluginProcess(
+scoped_refptr<BrowserPpapiHost> BrowserPpapiHost::CreateExternalPluginProcess(
+    BrowserPpapiHost::Delegate* delegate,
     IPC::Sender* sender,
     ppapi::PpapiPermissions permissions,
     base::ProcessHandle plugin_child_process,
     IPC::ChannelProxy* channel,
     int render_process_id,
     int render_view_id,
     const base::FilePath& profile_directory) {
   // The plugin name and path shouldn't be needed for external plugins.
-  BrowserPpapiHostImpl* browser_ppapi_host =
-      new BrowserPpapiHostImpl(sender, permissions, std::string(),
+  scoped_refptr<BrowserPpapiHostImpl> browser_ppapi_host =
+      new BrowserPpapiHostImpl(delegate, sender, permissions, std::string(),
                                base::FilePath(), profile_directory,
                                false /* in_process */,
                                true /* external_plugin */);
   browser_ppapi_host->set_plugin_process_handle(plugin_child_process);
 
   scoped_refptr<PepperMessageFilter> pepper_message_filter(
       new PepperMessageFilter());
   channel->AddFilter(pepper_message_filter->GetFilter());
   channel->AddFilter(browser_ppapi_host->message_filter());
   channel->AddFilter((new TraceMessageFilter())->GetFilter());
 
   return browser_ppapi_host;
 }
 
 BrowserPpapiHostImpl::BrowserPpapiHostImpl(
+    BrowserPpapiHost::Delegate* delegate,
     IPC::Sender* sender,
     const ppapi::PpapiPermissions& permissions,
     const std::string& plugin_name,
     const base::FilePath& plugin_path,
     const base::FilePath& profile_data_directory,
     bool in_process,
     bool external_plugin)
-    : ppapi_host_(new ppapi::host::PpapiHost(sender, permissions)),
+    : delegate_(delegate),
+      ppapi_host_(new ppapi::host::PpapiHost(sender, permissions)),
       plugin_process_handle_(base::kNullProcessHandle),
       plugin_name_(plugin_name),
       plugin_path_(plugin_path),
       profile_data_directory_(profile_data_directory),
       in_process_(in_process),
       external_plugin_(external_plugin),
       ssl_context_helper_(new SSLContextHelper()) {
-  message_filter_ = new HostMessageFilter(ppapi_host_.get());
+  message_filter_ = new HostMessageFilter(this, ppapi_host_.get());
   ppapi_host_->AddHostFactoryFilter(scoped_ptr<ppapi::host::HostFactory>(
       new ContentBrowserPepperHostFactory(this)));
 }
 
-BrowserPpapiHostImpl::~BrowserPpapiHostImpl() {
-  // Notify the filter so it won't foward messages to us.
-  message_filter_->OnHostDestroyed();
-
-  // Delete the host explicitly first. This shutdown will destroy the
-  // resources, which may want to do cleanup in their destructors and expect
-  // their pointers to us to be valid.
-  ppapi_host_.reset();
-}
-
 ppapi::host::PpapiHost* BrowserPpapiHostImpl::GetPpapiHost() {
   return ppapi_host_.get();
 }
 
 base::ProcessHandle BrowserPpapiHostImpl::GetPluginProcessHandle() const {
   // Handle should previously have been set before use.
   DCHECK(plugin_process_handle_ != base::kNullProcessHandle);
   return plugin_process_handle_;
 }
 
@@ skipping 52 matching lines @@
 
 void BrowserPpapiHostImpl::DeleteInstance(PP_Instance instance) {
   InstanceMap::iterator found = instance_map_.find(instance);
   if (found == instance_map_.end()) {
     NOTREACHED();
     return;
   }
   instance_map_.erase(found);
 }
 
+void BrowserPpapiHostImpl::OnIdleState(bool idle) {
+  if (!delegate_)
+    return;
+
+  for (InstanceMap::iterator i = instance_map_.begin();
+       i != instance_map_.end();
+       ++i) {
+    RenderViewHost* render_view_host = RenderViewHost::FromID(
+        i->second.render_process_id, i->second.render_view_id);
+
+    delegate_->OnIdleState(idle, profile_data_directory_, render_view_host,
+                           i->second.document_url);
+  }
+}
+
+BrowserPpapiHostImpl::~BrowserPpapiHostImpl() {
+  // Notify the filter so it won't foward messages to us.
+  message_filter_->OnHostDestroyed();
+
+  // Delete the host explicitly first. This shutdown will destroy the
+  // resources, which may want to do cleanup in their destructors and expect
+  // their pointers to us to be valid.
+  ppapi_host_.reset();
+}
+
 bool BrowserPpapiHostImpl::HostMessageFilter::OnMessageReceived(
     const IPC::Message& msg) {
   // Don't forward messages if our owner object has been destroyed.
   if (!ppapi_host_)
     return false;
 
-  /* TODO(brettw) when we add messages, here, the code should look like this:
   bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(BrowserPpapiHostImpl, msg)
+  IPC_BEGIN_MESSAGE_MAP(BrowserPpapiHostImpl::HostMessageFilter, msg)
     // Add necessary message handlers here.
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_IdleState,
+                        OnIdleState)
     IPC_MESSAGE_UNHANDLED(handled = ppapi_host_->OnMessageReceived(msg))
   IPC_END_MESSAGE_MAP();
   return handled;
-  */
-  return ppapi_host_->OnMessageReceived(msg);
 }
 
 void BrowserPpapiHostImpl::HostMessageFilter::OnHostDestroyed() {
+  browser_ppapi_host_impl_ = NULL;
   DCHECK(ppapi_host_);
   ppapi_host_ = NULL;
 }
 
+void BrowserPpapiHostImpl::HostMessageFilter::OnIdleState(bool idle) {
+  if (browser_ppapi_host_impl_) {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(&BrowserPpapiHostImpl::OnIdleState,

[yzshen1, 2013/11/06 22:43:15]

Important: BrowserPpapiHostImpl should be accessed on the IO thread only.

[scheib, 2013/11/15 01:22:17]

Done.

+                                       browser_ppapi_host_impl_,
+                                       idle));
+  }
+}
+
 }  // namespace content