Add IPC Channel for new ManifestService.

components/nacl/loader/nacl_listener.cc

 // Copyright 2013 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/loader/nacl_listener.h"
 
 #include <errno.h>
 #include <stdlib.h>
 
 #if defined(OS_POSIX)
@@ skipping 274 matching lines @@
     NaClChromeMainInit();
     nap = NaClAppCreate();
     if (nap == NULL) {
       LOG(ERROR) << "NaClAppCreate() failed";
       return;
     }
   }
 
   IPC::ChannelHandle browser_handle;
   IPC::ChannelHandle ppapi_renderer_handle;
+  IPC::ChannelHandle manifest_service_handle;
 
   if (params.enable_ipc_proxy) {
     browser_handle = IPC::Channel::GenerateVerifiedChannelID("nacl");
     ppapi_renderer_handle = IPC::Channel::GenerateVerifiedChannelID("nacl");
 
 #if defined(OS_LINUX)
     if (uses_nonsfi_mode_) {
+      manifest_service_handle =
+          IPC::Channel::GenerateVerifiedChannelID("nacl");
+
       // In non-SFI mode, we neither intercept nor rewrite the message using
       // NaClIPCAdapter, and the channels are connected between the plugin and
       // the hosts directly. So, the IPC::Channel instances will be created in
       // the plugin side, because the IPC::Listener needs to live on the
       // plugin's main thread. However, on initialization (i.e. before loading
       // the plugin binary), the FD needs to be passed to the hosts. So, here
       // we create raw FD pairs, and pass the client side FDs to the hosts,
       // and the server side FDs to the plugin.
       int browser_server_ppapi_fd;
       int browser_client_ppapi_fd;
       int renderer_server_ppapi_fd;
       int renderer_client_ppapi_fd;
+      int manifest_service_server_fd;
+      int manifest_service_client_fd;
       if (!IPC::SocketPair(
               &browser_server_ppapi_fd, &browser_client_ppapi_fd) ||
           !IPC::SocketPair(
-              &renderer_server_ppapi_fd, &renderer_client_ppapi_fd)) {
+              &renderer_server_ppapi_fd, &renderer_client_ppapi_fd) ||
+          !IPC::SocketPair(
+              &manifest_service_server_fd, &manifest_service_client_fd)) {
         LOG(ERROR) << "Failed to create sockets for IPC.";
         return;
       }
 
       // Set the plugin IPC channel FDs.
-      ppapi::SetIPCFileDescriptors(
-          browser_server_ppapi_fd, renderer_server_ppapi_fd);
+      ppapi::SetIPCFileDescriptors(browser_server_ppapi_fd,
+                                   renderer_server_ppapi_fd,
+                                   manifest_service_server_fd);
+      ppapi::StartUpPlugin();
 
       // Send back to the client side IPC channel FD to the host.
       browser_handle.socket =
           base::FileDescriptor(browser_client_ppapi_fd, true);
       ppapi_renderer_handle.socket =
           base::FileDescriptor(renderer_client_ppapi_fd, true);
+      manifest_service_handle.socket =
+          base::FileDescriptor(manifest_service_client_fd, true);
     } else {
 #endif
       // Create the PPAPI IPC channels between the NaCl IRT and the host
       // (browser/renderer) processes. The IRT uses these channels to
       // communicate with the host and to initialize the IPC dispatchers.
       SetUpIPCAdapter(&browser_handle, io_thread_.message_loop_proxy(),
                       nap, NACL_CHROME_DESC_BASE);
       SetUpIPCAdapter(&ppapi_renderer_handle, io_thread_.message_loop_proxy(),
                       nap, NACL_CHROME_DESC_BASE + 1);
 #if defined(OS_LINUX)
     }
 #endif
   }
 
   // The argument passed to GenerateVerifiedChannelID() here MUST be "nacl".
   // Using an alternate channel name prevents the pipe from being created on
   // Windows when the sandbox is enabled.
   IPC::ChannelHandle trusted_renderer_handle =
       IPC::Channel::GenerateVerifiedChannelID("nacl");
   trusted_listener_ = new NaClTrustedListener(
       trusted_renderer_handle, io_thread_.message_loop_proxy(),
       &shutdown_event_);
 #if defined(OS_POSIX)
   trusted_renderer_handle.socket = base::FileDescriptor(
       trusted_listener_->TakeClientFileDescriptor(), true);
 #endif
   if (!Send(new NaClProcessHostMsg_PpapiChannelsCreated(
-          browser_handle, ppapi_renderer_handle, trusted_renderer_handle)))
+          browser_handle, ppapi_renderer_handle,
+          trusted_renderer_handle, manifest_service_handle)))
     LOG(ERROR) << "Failed to send IPC channel handle to NaClProcessHost.";
 
   std::vector<nacl::FileDescriptor> handles = params.handles;
 
 #if defined(OS_LINUX)
   if (uses_nonsfi_mode_) {
     if (params.uses_irt) {
       LOG(ERROR) << "IRT must not be used for non-SFI NaCl.";
       return;
     }
@@ skipping 77 matching lines @@
   args->broker_duplicate_handle_func = BrokerDuplicateHandle;
   args->attach_debug_exception_handler_func = AttachDebugExceptionHandler;
 #endif
 #if defined(OS_LINUX)
   args->prereserved_sandbox_size = prereserved_sandbox_size_;
 #endif
 
   NaClChromeMainStartApp(nap, args);
   NOTREACHED();
 }