Create IPC channel to communicate with the renderer in NaClListener::OnStart().

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 30 matching lines @@
 #include "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_switches.h"
 #include "native_client/src/shared/imc/nacl_imc_c.h"
 #include "net/base/net_util.h"
 #include "net/socket/tcp_listen_socket.h"
 #include "ppapi/host/host_factory.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ppapi/proxy/ppapi_messages.h"
-#include "ppapi/shared_impl/ppapi_nacl_channel_args.h"
+#include "ppapi/shared_impl/ppapi_initialize_nacl_dispatcher_args.h"
 #include "ppapi/shared_impl/ppapi_switches.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"
@@ skipping 148 matching lines @@
   NaClHandle socket_for_renderer;
   NaClHandle socket_for_sel_ldr;
 
   NaClInternal()
     : socket_for_renderer(NACL_INVALID_HANDLE),
       socket_for_sel_ldr(NACL_INVALID_HANDLE) { }
 };
 
 // -----------------------------------------------------------------------------
 
-NaClProcessHost::PluginListener::PluginListener(NaClProcessHost* host)
-    : host_(host) {
-}
-
-bool NaClProcessHost::PluginListener::OnMessageReceived(
-    const IPC::Message& msg) {
-  return host_->OnUntrustedMessageForwarded(msg);
-}
-
 NaClProcessHost::NaClProcessHost(const GURL& manifest_url,
                                  int render_view_id,
                                  uint32 permission_bits,
                                  bool uses_irt,
                                  bool enable_dyncode_syscalls,
                                  bool enable_exception_handling,
                                  bool enable_crash_throttling,
                                  bool off_the_record,
                                  const base::FilePath& profile_directory)
     : manifest_url_(manifest_url),
       permissions_(GetNaClPermissions(permission_bits)),
 #if defined(OS_WIN)
       process_launched_by_broker_(false),
 #endif
       reply_msg_(NULL),
 #if defined(OS_WIN)
       debug_exception_handler_requested_(false),
 #endif
       internal_(new NaClInternal()),
       weak_factory_(this),
       uses_irt_(uses_irt),
       enable_debug_stub_(false),
       enable_dyncode_syscalls_(enable_dyncode_syscalls),
       enable_exception_handling_(enable_exception_handling),
       enable_crash_throttling_(enable_crash_throttling),
       off_the_record_(off_the_record),
       profile_directory_(profile_directory),
-      ipc_plugin_listener_(this),
       render_view_id_(render_view_id) {
   process_.reset(content::BrowserChildProcessHost::Create(
       PROCESS_TYPE_NACL_LOADER, this));
 
   // Set the display name so the user knows what plugin the process is running.
   // We aren't on the UI thread so getting the pref locale for language
   // formatting isn't possible, so IDN will be lost, but this is probably OK
   // for this use case.
   process_->SetName(net::FormatUrl(manifest_url_, std::string()));
 
@@ skipping 297 matching lines @@
     IPC_MESSAGE_HANDLER(NaClProcessMsg_QueryKnownToValidate,
                         OnQueryKnownToValidate)
     IPC_MESSAGE_HANDLER(NaClProcessMsg_SetKnownToValidate,
                         OnSetKnownToValidate)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(NaClProcessMsg_ResolveFileToken,
                                     OnResolveFileToken)
 #if defined(OS_WIN)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(NaClProcessMsg_AttachDebugExceptionHandler,
                                     OnAttachDebugExceptionHandler)
 #endif
-    IPC_MESSAGE_HANDLER(NaClProcessHostMsg_PpapiChannelCreated,
-                        OnPpapiBrowserChannelCreated)
+    IPC_MESSAGE_HANDLER(NaClProcessHostMsg_PpapiChannelsCreated,
+                        OnPpapiChannelsCreated)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void NaClProcessHost::OnProcessLaunched() {
   if (!StartWithLaunchedProcess())
     delete this;
 }
 
@@ skipping 193 matching lines @@
 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) {
+void NaClProcessHost::OnPpapiChannelsCreated(
+    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_,
+                              NULL,
                               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;
+    ppapi::PpapiInitializeNaClDispatcherArgs 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(
-            args,
-            SerializedHandle(SerializedHandle::CHANNEL_HANDLE,
-                             IPC::InvalidPlatformFileForTransit())));
+    // Send a message to initialize the IPC dispatchers in the NaCl plugin.
+    ipc_proxy_channel_->Send(new PpapiMsg_InitializeNaClDispatcher(args));
+
+    // Let the renderer know that the IPC channels are established.
+    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(
-    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) {
-  // 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;
-}
-
 bool NaClProcessHost::StartWithLaunchedProcess() {
   NaClBrowser* nacl_browser = NaClBrowser::GetInstance();
 
   if (nacl_browser->IsReady()) {
     return SendStart();
   } else if (nacl_browser->IsOk()) {
     nacl_browser->WaitForResources(
         base::Bind(&NaClProcessHost::OnResourcesReady,
                    weak_factory_.GetWeakPtr()));
     return true;
@@ skipping 154 matching lines @@
         process_handle.Take(), info,
         base::MessageLoopProxy::current(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif
 
 }  // namespace nacl