Use ChannelMojo in Pepper and NaCl processes.

content/zygote/zygote_linux.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 "content/zygote/zygote_linux.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <poll.h>
 #include <signal.h>
@@ skipping 19 matching lines @@
 #include "base/process/process.h"
 #include "base/process/process_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "content/common/child_process_sandbox_support_impl_linux.h"
 #include "content/common/sandbox_linux/sandbox_linux.h"
 #include "content/common/set_process_title.h"
 #include "content/common/zygote_commands_linux.h"
 #include "content/public/common/content_descriptors.h"
+#include "content/public/common/mojo_channel_switches.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/sandbox_linux.h"
 #include "content/public/common/send_zygote_child_ping_linux.h"
 #include "content/public/common/zygote_fork_delegate_linux.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_switches.h"
 #include "sandbox/linux/services/credentials.h"
 #include "sandbox/linux/services/namespace_sandbox.h"
 
 // See https://chromium.googlesource.com/chromium/src/+/master/docs/linux_zygote.md
@@ skipping 373 matching lines @@
        ++i) {
     if ((*i)->CanHelp(process_type, uma_name, uma_sample, uma_boundary_value)) {
       helper = *i;
       break;
     }
   }
 
   base::ScopedFD read_pipe, write_pipe;
   base::ProcessId pid = 0;
   if (helper) {
-    int ipc_channel_fd = LookUpFd(fd_mapping, kPrimaryIPCChannel);
-    if (ipc_channel_fd < 0) {
-      DLOG(ERROR) << "Failed to find kPrimaryIPCChannel in FD mapping";
-      return -1;
-    }
     int mojo_channel_fd = LookUpFd(fd_mapping, kMojoIPCChannel);
     if (mojo_channel_fd < 0) {
       DLOG(ERROR) << "Failed to find kMojoIPCChannel in FD mapping";
       return -1;
     }
+    int ipc_channel_fd = LookUpFd(fd_mapping, kPrimaryIPCChannel);
+    DCHECK_EQ(-1, ipc_channel_fd);
     std::vector<int> fds;
-    fds.push_back(ipc_channel_fd);  // kBrowserFDIndex
+    fds.push_back(mojo_channel_fd);  // kBrowserFDIndex
     fds.push_back(pid_oracle.get());  // kPIDOracleFDIndex
-    fds.push_back(mojo_channel_fd);  // kMojoParentFDIndex
     pid = helper->Fork(process_type, fds, channel_id);
 
     // Helpers should never return in the child process.
     CHECK_NE(pid, 0);
   } else {
     CreatePipe(&read_pipe, &write_pipe);
     if (sandbox_flags_ & kSandboxLinuxPIDNS &&
         sandbox_flags_ & kSandboxLinuxUserNS) {
       pid = sandbox::NamespaceSandbox::ForkInNewPidNamespace(
           /*drop_capabilities_in_child=*/true);
@@ skipping 105 matching lines @@
                                         std::string* uma_name,
                                         int* uma_sample,
                                         int* uma_boundary_value) {
   std::vector<std::string> args;
   int argc = 0;
   int numfds = 0;
   base::GlobalDescriptors::Mapping mapping;
   std::string process_type;
   std::string channel_id;
   const std::string channel_id_prefix = std::string("--")
-      + switches::kProcessChannelID + std::string("=");
+      + switches::kMojoChannelToken + std::string("=");
 
   if (!iter.ReadString(&process_type))
     return -1;
   if (!iter.ReadInt(&argc))
     return -1;
 
   for (int i = 0; i < argc; ++i) {
     std::string arg;
     if (!iter.ReadString(&arg))
       return -1;
@@ skipping 87 matching lines @@
 bool Zygote::HandleGetSandboxStatus(int fd, base::PickleIterator iter) {
   if (HANDLE_EINTR(write(fd, &sandbox_flags_, sizeof(sandbox_flags_))) !=
                    sizeof(sandbox_flags_)) {
     PLOG(ERROR) << "write";
   }
 
   return false;
 }
 
 }  // namespace content