Hook up PpapiPermissions in more places.

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 143 matching lines @@
 
 class OutOfProcessProxy : public PluginDelegate::OutOfProcessProxy {
  public:
   OutOfProcessProxy() {}
   virtual ~OutOfProcessProxy() {}
 
   bool Init(const IPC::ChannelHandle& channel_handle,
             PP_Module pp_module,
             PP_GetInterface_Func local_get_interface,
             const ppapi::Preferences& preferences,
-            SyncMessageStatusReceiver* status_receiver) {
+            SyncMessageStatusReceiver* status_receiver,
+            const ppapi::PpapiPermissions& permissions) {
     dispatcher_delegate_.reset(new ProxyChannelDelegate);
     dispatcher_.reset(new ppapi::proxy::HostDispatcher(
-        pp_module, local_get_interface, status_receiver));
+        pp_module, local_get_interface, status_receiver, permissions));
 
     if (!dispatcher_->InitHostWithChannel(dispatcher_delegate_.get(),
                                           channel_handle,
                                           true,  // Client.
                                           preferences)) {
       dispatcher_.reset();
       dispatcher_delegate_.reset();
       return false;
     }
 
@@ skipping 13 matching lines @@
   }
   virtual void RemoveInstance(PP_Instance instance) OVERRIDE {
     ppapi::proxy::HostDispatcher::RemoveForInstance(instance);
   }
 
  private:
   scoped_ptr<ppapi::proxy::HostDispatcher> dispatcher_;
   scoped_ptr<ppapi::proxy::ProxyChannel::Delegate> dispatcher_delegate_;
 };
 
 PP_Bool StartPpapiProxy(PP_Instance instance) {

[bbudge, 2012/10/01 17:32:01]

This is called by the NaCl plugin, which knows whether 'Dev' interfaces should
be enabled. We can add a bool to pass this information down.

[brettw, 2012/10/01 23:04:48]

We also need to hook this up in the browser process. Let's do that in a separate
pass.

   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);
 
     PluginInstance* plugin_instance =
@@ skipping 10 matching lines @@
     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());
 
+    // TODO(brettw) bug 153036 set NaCl permissions to allow dev interface
+    // usage when necessary.
+    ppapi::PpapiPermissions permissions;
+
     if (out_of_process_proxy->Init(
             channel_handle,
             nacl_plugin_module->pp_module(),
             PluginModule::GetLocalGetInterfaceFunc(),
             ppapi::Preferences(render_view->GetWebkitPreferences()),
-            status_receiver.get())) {
+            status_receiver.get(),
+            permissions)) {
       nacl_plugin_module->InitAsProxiedNaCl(
           out_of_process_proxy.PassAs<PluginDelegate::OutOfProcessProxy>(),
           instance);
       return PP_TRUE;
     }
   }
 
   return PP_FALSE;
 }
 
@@ skipping 91 matching lines @@
   &IsPnaclEnabled
 };
 
 }  // namespace
 
 const PPB_NaCl_Private* PPB_NaCl_Private_Impl::GetInterface() {
   return &nacl_interface;
 }
 
 #endif  // DISABLE_NACL