Add a PepperHelper::EnablePepperSupportForChannel function to content.

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 <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 16 matching lines @@
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/nacl_cmd_line.h"
 #include "chrome/common/nacl_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_child_process_host.h"
 #include "content/public/browser/child_process_data.h"
+#include "content/public/browser/pepper_helper.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/resource_context.h"
 #include "content/public/common/child_process_host.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_switches.h"
 #include "native_client/src/shared/imc/nacl_imc.h"
 #include "net/base/net_util.h"
 #include "ppapi/proxy/ppapi_messages.h"
 
 #if defined(OS_POSIX)
 #include <fcntl.h>
 
 #include "ipc/ipc_channel_posix.h"
 #elif defined(OS_WIN)
 #include <windows.h>
 
 #include "base/threading/thread.h"
 #include "base/process_util.h"
 #include "base/win/scoped_handle.h"
 #include "chrome/browser/nacl_host/nacl_broker_service_win.h"
 #include "chrome/common/nacl_debug_exception_handler_win.h"
 #include "content/public/common/sandbox_init.h"
 #endif
 
 using content::BrowserThread;
 using content::ChildProcessData;
 using content::ChildProcessHost;
+using content::RenderProcessHost;
+using content::ResourceContext;
 using ppapi::proxy::SerializedHandle;
 
 namespace {
 
 #if defined(OS_WIN)
 bool RunningOnWOW64() {
   return (base::win::OSInfo::GetInstance()->wow64_status() ==
           base::win::OSInfo::WOW64_ENABLED);
 }
 #endif
@@ skipping 633 matching lines @@
   DCHECK(enable_ipc_proxy_);
   // If the proxy channel is null, this must be the initial NaCl-Browser IPC
   // channel.
   if (!ipc_proxy_channel_.get()) {
     ipc_proxy_channel_.reset(
         new IPC::ChannelProxy(channel_handle,
                               IPC::Channel::MODE_CLIENT,
                               &ipc_plugin_listener_,
                               base::MessageLoopProxy::current()));
     // Send a message to create the NaCl-Renderer channel. The handle is just
-    // a place holder.
+    // a place holder, filled in by NaCl process trusted code.
     ipc_proxy_channel_->Send(
         new PpapiMsg_CreateNaClChannel(
             chrome_render_message_filter_->render_process_id(),
             chrome_render_message_filter_->off_the_record(),
             SerializedHandle(SerializedHandle::CHANNEL_HANDLE,
                              IPC::InvalidPlatformFileForTransit())));
+    // We will need a ResourceContext to enable the channel so messages get
+    // dispatched to the browser. This must be accessed on the UI thread.
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&NaClProcessHost::EnablePpapiChannelOnUIThread,
+                   base::Unretained(this),

[brettw, 2012/09/06 23:38:09]

You're using unretained here and below. What ensures that this object is not
destroyed in the meantime?

I notice there is a weak ptr factory on the NaClProcessHost that you can use.
Weak ptrs are not threadsafe so you have to be careful and not dereference or
copy it while you're on the UI thread. I think the normal Bind stuff will copy
it.

Maybe you can come up with a better design here. One idea is to make a helper
class that's refcounted to do the hop to the UI thread and back, and then that
class would own a weak ptr to the NaClProcessHost and do the final call back to
the NaClProcessHost to complete.

[bbudge, 2012/09/08 01:17:27]

Moving this to PMF. Done.

+                   chrome_render_message_filter_->render_process_id()));
   } else if (reply_msg_) {
     // Otherwise, this must be a renderer channel.
     ReplyToRenderer(channel_handle);
   } else {
     // Attempt to open more than 1 renderer channel is not supported.
     // Shut down the NaCl process.
     process_->GetHost()->ForceShutdown();
   }
 }
 
+void NaClProcessHost::EnablePpapiChannelOnUIThread(
+    int render_process_id) {
+  content::RenderProcessHost* rph =
+      content::RenderProcessHost::FromID(render_process_id);
+  if (rph) {
+    // ResourceContext::GetHostResolver must be called on the IO thread.
+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&NaClProcessHost::EnablePpapiChannelOnIOThread,
+                   base::Unretained(this),
+                   rph->GetBrowserContext()->GetResourceContext()));
+  }
+}
+
+void NaClProcessHost::EnablePpapiChannelOnIOThread(
+    ResourceContext* resource_context) {
+  DCHECK(resource_context);
+  content::PepperHelper::EnablePepperSupportForChannel(
+      ipc_proxy_channel_.get(), resource_context->GetHostResolver());
+}
+
 bool NaClProcessHost::OnUntrustedMessageForwarded(const IPC::Message& msg) {
   // Handle messages that have been forwarded from our PluginListener.
   // These messages come from untrusted code so should be handled with care.
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(NaClProcessHost, msg)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_ChannelCreated,
                         OnPpapiChannelCreated)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
@@ skipping 96 matching lines @@
   } else {
     NaClStartDebugExceptionHandlerThread(
         process_handle.Take(), info,
         base::MessageLoopProxy::current(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif