Allow the NaCl IPC proxy to support multiple instances.

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 24 matching lines @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "webkit/plugins/ppapi/host_globals.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 using content::RenderThread;
 using content::RenderView;
 using webkit::ppapi::HostGlobals;
 using webkit::ppapi::PluginInstance;
 using webkit::ppapi::PluginDelegate;
+using webkit::ppapi::PluginModule;
 using WebKit::WebView;
 
 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;
 
@@ skipping 145 matching lines @@
 PP_Bool StartPpapiProxy(PP_Instance instance) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableNaClIPCProxy)) {
     ChannelHandleMap& map = g_channel_handle_map.Get();
     ChannelHandleMap::iterator it = map.find(instance);
     if (it == map.end())
       return PP_FALSE;
     IPC::ChannelHandle channel_handle = it->second;
     map.erase(it);
 
-    webkit::ppapi::PluginInstance* plugin_instance =
+    PluginInstance* plugin_instance =
         content::GetHostGlobals()->GetInstance(instance);
     if (!plugin_instance)
       return PP_FALSE;
 
     WebView* web_view =
         plugin_instance->container()->element().document().frame()->view();
     RenderView* render_view = content::RenderView::FromWebView(web_view);
 
-    webkit::ppapi::PluginModule* plugin_module = plugin_instance->module();
+    PluginModule* plugin_module = plugin_instance->module();
 
     scoped_refptr<SyncMessageStatusReceiver>
         status_receiver(new SyncMessageStatusReceiver());
     scoped_ptr<OutOfProcessProxy> out_of_process_proxy(new OutOfProcessProxy);
+    // 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.
+    scoped_refptr<PluginModule> nacl_plugin_module(
+        plugin_module->CreateModuleForNaClInstance());
+
     if (out_of_process_proxy->Init(
             channel_handle,
-            plugin_module->pp_module(),
-            webkit::ppapi::PluginModule::GetLocalGetInterfaceFunc(),
+            nacl_plugin_module->pp_module(),
+            PluginModule::GetLocalGetInterfaceFunc(),
             ppapi::Preferences(render_view->GetWebkitPreferences()),
             status_receiver.get())) {
-      plugin_module->InitAsProxiedNaCl(
+      nacl_plugin_module->InitAsProxiedNaCl(
           out_of_process_proxy.PassAs<PluginDelegate::OutOfProcessProxy>(),
           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