Cache more information when launching NaCl sel_ldr, and pass 'Dev' interface

chrome/renderer/pepper/ppb_nacl_private_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 "chrome/renderer/pepper/ppb_nacl_private_impl.h"
 
 #ifndef DISABLE_NACL
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 18 matching lines @@
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 namespace {
 
 // This allows us to send requests from background threads.
 // E.g., to do LaunchSelLdr for helper nexes (which is done synchronously),
 // in a background thread, to avoid jank.
 base::LazyInstance<scoped_refptr<IPC::SyncMessageFilter> >
     g_background_thread_sender = LAZY_INSTANCE_INITIALIZER;
 
-typedef std::map<PP_Instance, IPC::ChannelHandle> ChannelHandleMap;
+struct InstanceInfo {
+  GURL url;
+  int plugin_child_id;
+  IPC::ChannelHandle channel_handle;

[dmichael (off chromium), 2012/10/23 19:05:30]

How about a default constructor to make sure plugin_child_id is initialized?

[bbudge, 2012/10/23 19:53:04]

Done.

+};
 
-base::LazyInstance<ChannelHandleMap> g_channel_handle_map =
+typedef std::map<PP_Instance, InstanceInfo> InstanceInfoMap;
+
+base::LazyInstance<InstanceInfoMap> g_instance_info =
     LAZY_INSTANCE_INITIALIZER;
 
 // Launch NaCl's sel_ldr process.
 PP_Bool LaunchSelLdr(PP_Instance instance,
                      const char* alleged_url,
                      int socket_count,
                      void* imc_handles) {
   std::vector<nacl::FileDescriptor> sockets;
   IPC::Sender* sender = content::RenderThread::Get();
   if (sender == NULL)
     sender = g_background_thread_sender.Pointer()->get();
 
-  IPC::ChannelHandle channel_handle;
+  InstanceInfo instance_info;
+  instance_info.url = GURL(alleged_url);
   if (!sender->Send(new ChromeViewHostMsg_LaunchNaCl(
-          GURL(alleged_url), socket_count, &sockets,
-          &channel_handle))) {
+          instance_info.url, socket_count, &sockets,
+          &instance_info.channel_handle,
+          &instance_info.plugin_child_id))) {
     return PP_FALSE;
   }
 
-  // Don't save invalid channel handles.
-  bool invalid_handle = channel_handle.name.empty();
-
+  // Don't save instance_info if channel handle is invalid.
+  bool invalid_handle = instance_info.channel_handle.name.empty();
 #if defined(OS_POSIX)
   if (!invalid_handle)
-    invalid_handle = (channel_handle.socket.fd == -1);
+    invalid_handle = (instance_info.channel_handle.socket.fd == -1);
 #endif
-
   if (!invalid_handle)
-    g_channel_handle_map.Get()[instance] = channel_handle;
+    g_instance_info.Get()[instance] = instance_info;
 
   CHECK(static_cast<int>(sockets.size()) == socket_count);
   for (int i = 0; i < socket_count; i++) {
     static_cast<nacl::Handle*>(imc_handles)[i] =
         nacl::ToNativeHandle(sockets[i]);
   }
 
   return PP_TRUE;
 }
 
-PP_Bool StartPpapiProxy(PP_Instance instance) {
+PP_Bool StartPpapiProxy(PP_Instance instance,
+                        bool allow_dev_interfaces) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableNaClIPCProxy)) {
-    ChannelHandleMap& map = g_channel_handle_map.Get();
-    ChannelHandleMap::iterator it = map.find(instance);
+    InstanceInfoMap& map = g_instance_info.Get();
+    InstanceInfoMap::iterator it = map.find(instance);
     if (it == map.end())
       return PP_FALSE;
-    IPC::ChannelHandle channel_handle = it->second;
+    InstanceInfo instance_info = it->second;
     map.erase(it);
 
     webkit::ppapi::PluginInstance* plugin_instance =
         content::GetHostGlobals()->GetInstance(instance);
     if (!plugin_instance)
       return PP_FALSE;
 
   // Create a new module for each instance of the NaCl plugin that is using
   // the IPC based out-of-process proxy. We can't use the existing module,
   // because it is configured for the in-process NaCl plugin, and we must
   // keep it that way to allow the page to create other instances.
   webkit::ppapi::PluginModule* plugin_module = plugin_instance->module();
   scoped_refptr<webkit::ppapi::PluginModule> nacl_plugin_module(
       plugin_module->CreateModuleForNaClInstance());
 
-    // TODO(brettw) bug 153036 set NaCl permissions to allow dev interface
-    // usage when necessary.
-    ppapi::PpapiPermissions permissions;
-    // TODO(bbudge) fill in place-holder params below with the nexe URL and
-    // NaCl process id.
+    ppapi::PpapiPermissions permissions(
+        allow_dev_interfaces ? ppapi::PERMISSION_DEV : 0);

[dmichael (off chromium), 2012/10/23 19:05:30]

Just curious, how do we handle white-listed Private interfaces, like UDP/TCP? It
doesn't use PpapiPermissions?

[bbudge, 2012/10/23 19:53:04]

Right now, the plugin side returns NULL for 'Private' interfaces. On the browser
side, which is where the real restriction must happen, I don't think we restrict
these yet.

     content::RendererPpapiHost* renderer_ppapi_host =
         content::RendererPpapiHost::CreateExternalPluginModule(
             nacl_plugin_module,
             plugin_instance,
-            FilePath(FILE_PATH_LITERAL("NaCl")),
+            FilePath().AppendASCII(instance_info.url.spec()),
             permissions,
-            channel_handle,
-            0);  // plugin_child_id
+            instance_info.channel_handle,
+            instance_info.plugin_child_id);
     if (renderer_ppapi_host) {
       // Allow the module to reset the instance to the new proxy.
       nacl_plugin_module->InitAsProxiedNaCl(plugin_instance);
       return PP_TRUE;
     }
   }
   return PP_FALSE;
 }
 
 int UrandomFD(void) {
@@ skipping 90 matching lines @@
   &IsPnaclEnabled
 };
 
 }  // namespace
 
 const PPB_NaCl_Private* PPB_NaCl_Private_Impl::GetInterface() {
   return &nacl_interface;
 }
 
 #endif  // DISABLE_NACL