[WIP] Yet another demo for BMM NaCl ppapi connection.

components/nacl/browser/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 "components/nacl/browser/nacl_process_host.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 752 matching lines @@
 #if defined(OS_POSIX)
   if (params.enable_debug_stub) {
     net::SocketDescriptor server_bound_socket = GetDebugStubSocketHandle();
     if (server_bound_socket != net::kInvalidSocket) {
       params.debug_stub_server_bound_socket =
           FileDescriptor(server_bound_socket, true);
     }
   }
 #endif
 
+  // TODO Propagate command line flags and permissions.
+#if 0
+    // TODO move to StartNaCl
+    ppapi::PpapiNaClChannelArgs args;
+    args.off_the_record = nacl_host_message_filter_->off_the_record();
+    args.permissions = permissions_;
+    CommandLine* cmdline = CommandLine::ForCurrentProcess();
+    DCHECK(cmdline);
+    std::string flag_whitelist[] = {
+      switches::kPpapiKeepAliveThrottle,
+      switches::kV,
+      switches::kVModule,
+    };
+    for (size_t i = 0; i < arraysize(flag_whitelist); ++i) {
+      std::string value = cmdline->GetSwitchValueASCII(flag_whitelist[i]);
+      if (!value.empty()) {
+        args.switch_names.push_back(flag_whitelist[i]);
+        args.switch_values.push_back(value);
+      }
+    }
+#endif
+
   process_->Send(new NaClProcessMsg_Start(params));
 
   internal_->socket_for_sel_ldr = NACL_INVALID_HANDLE;
   return true;
 }
 
 bool NaClProcessHost::SendStart() {
   if (!enable_ppapi_proxy()) {
     if (!ReplyToRenderer(IPC::ChannelHandle()))
       return false;
   }
   return StartNaClExecution();
 }
 
 // This method is called when NaClProcessHostMsg_PpapiChannelCreated is
 // received.
 void NaClProcessHost::OnPpapiBrowserChannelCreated(
-    const IPC::ChannelHandle& channel_handle) {
+    const IPC::ChannelHandle& browser_channel_handle,
+    const IPC::ChannelHandle& renderer_channel_handle) {
   // Only renderer processes should create a channel.
   DCHECK(enable_ppapi_proxy());
   if (!ipc_proxy_channel_.get()) {
     DCHECK_EQ(PROCESS_TYPE_NACL_LOADER, process_->GetData().process_type);
 
     ipc_proxy_channel_.reset(
-        new IPC::ChannelProxy(channel_handle,
+        new IPC::ChannelProxy(browser_channel_handle,
                               IPC::Channel::MODE_CLIENT,
                               &ipc_plugin_listener_,
                               base::MessageLoopProxy::current().get()));
     // Create the browser ppapi host and enable PPAPI message dispatching to the
     // browser process.
     ppapi_host_.reset(content::BrowserPpapiHost::CreateExternalPluginProcess(
         ipc_proxy_channel_.get(),  // sender
         permissions_,
         process_->GetData().handle,
         ipc_proxy_channel_.get(),
         nacl_host_message_filter_->render_process_id(),
         render_view_id_,
         profile_directory_));
     ppapi_host_->SetOnKeepaliveCallback(
         NaClBrowser::GetDelegate()->GetOnKeepaliveCallback());
 
-    ppapi::PpapiNaClChannelArgs args;
-    args.off_the_record = nacl_host_message_filter_->off_the_record();
-    args.permissions = permissions_;
-    CommandLine* cmdline = CommandLine::ForCurrentProcess();
-    DCHECK(cmdline);
-    std::string flag_whitelist[] = {
-      switches::kPpapiKeepAliveThrottle,
-      switches::kV,
-      switches::kVModule,
-    };
-    for (size_t i = 0; i < arraysize(flag_whitelist); ++i) {
-      std::string value = cmdline->GetSwitchValueASCII(flag_whitelist[i]);
-      if (!value.empty()) {
-        args.switch_names.push_back(flag_whitelist[i]);
-        args.switch_values.push_back(value);
-      }
-    }
-
     ppapi_host_->GetPpapiHost()->AddHostFactoryFilter(
         scoped_ptr<ppapi::host::HostFactory>(
             NaClBrowser::GetDelegate()->CreatePpapiHostFactory(
                 ppapi_host_.get())));
 
-    // Send a message to create the NaCl-Renderer channel. The handle is just
-    // a place holder.
-    ipc_proxy_channel_->Send(
-        new PpapiMsg_CreateNaClChannel(

[Mark Seaborn, 2014/02/04 01:18:31]

I think you will want to keep the PpapiMsg_CreateNaClChannel message, in order
to send the PpapiNaClChannelArgs to the NaCl process.

So you'll still want to send PpapiMsg_CreateNaClChannel here (though the handle
argument seems to be unnecessary -- I don't know why it's there), but then still
call ReplyToRenderer() afterwards.

But then plugin_main_nacl.cc will still need to wait for
PpapiMsg_CreateNaClChannel() and create a PluginDispatcher in response.  It just
won't need to send a handle back (because it will use the pre-created renderer
socket FD), so you can still remove PpapiHostMsg_NaClChannelCreated.

-            args,
-            SerializedHandle(SerializedHandle::CHANNEL_HANDLE,
-                             IPC::InvalidPlatformFileForTransit())));
+    ReplyToRenderer(renderer_channel_handle);
   } else {
     // Attempt to open more than 1 browser channel is not supported.
     // Shut down the NaCl process.
     process_->GetHost()->ForceShutdown();
   }
 }
 
 void NaClProcessHost::OnPpapiRendererChannelCreated(

[Mark Seaborn, 2014/02/03 22:59:07]

This method should go away, right?

     const IPC::ChannelHandle& channel_handle) {
   if (reply_msg_) {
     ReplyToRenderer(channel_handle);
   } else {
     // Attempt to open more than 1 NaCl renderer channel is not supported.
     // Shut down the NaCl process.
     process_->GetHost()->ForceShutdown();
   }
 }
 
 bool NaClProcessHost::OnUntrustedMessageForwarded(const IPC::Message& msg) {

[Mark Seaborn, 2014/02/03 22:59:07]

I think this should go away too, since it only handles
PpapiHostMsg_NaClChannelCreated.

   // 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_NaClChannelCreated,
                         OnPpapiRendererChannelCreated)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
@@ skipping 165 matching lines @@
         process_handle.Take(), info,
         base::MessageLoopProxy::current(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif
 
 }  // namespace nacl