Simplify ZygoteForkDelegate API further

components/nacl/zygote/nacl_fork_delegate_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 "components/nacl/zygote/nacl_fork_delegate_linux.h"
 
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/resource.h>
 #include <sys/socket.h>
@@ skipping 245 matching lines @@
   if (process_type != switches::kNaClLoaderProcess &&
       process_type != switches::kNaClLoaderNonSfiProcess)
     return false;
   *uma_name = "NaCl.Client.Helper.StateOnFork";
   *uma_sample = status_;
   *uma_boundary_value = kNaClHelperStatusBoundary;
   return true;
 }
 
 pid_t NaClForkDelegate::Fork(const std::string& process_type,
-                             const std::vector<int>& fds) {
+                             const std::vector<int>& fds,
+                             const std::string& channel_id) {
   VLOG(1) << "NaClForkDelegate::Fork";
 
   DCHECK(fds.size() == kNumPassedFDs);
 
   if (status_ != kNaClHelperSuccess) {
     LOG(ERROR) << "Cannot launch NaCl process: nacl_helper failed to start";
     return -1;
   }
 
   // First, send a remote fork request.
   Pickle write_pickle;
   write_pickle.WriteInt(nacl::kNaClForkRequest);
   // TODO(hamaji): When we split the helper binary for non-SFI mode
   // from nacl_helper, stop sending this information.
   const bool uses_nonsfi_mode =
     process_type == switches::kNaClLoaderNonSfiProcess;
   write_pickle.WriteBool(uses_nonsfi_mode);
+  write_pickle.WriteString(channel_id);
 
   char reply_buf[kNaClMaxIPCMessageLength];
   ssize_t reply_size = 0;
   bool got_reply =
       SendIPCRequestAndReadReply(fd_, fds, write_pickle,
                                  reply_buf, sizeof(reply_buf), &reply_size);
   if (!got_reply) {
     LOG(ERROR) << "Could not perform remote fork.";
     return -1;
   }
 
   // Now see if the other end managed to fork.
   Pickle reply_pickle(reply_buf, reply_size);
   PickleIterator iter(reply_pickle);
   pid_t nacl_child;
   if (!iter.ReadInt(&nacl_child)) {
     LOG(ERROR) << "NaClForkDelegate::Fork: pickle failed";
     return -1;
   }
   VLOG(1) << "nacl_child is " << nacl_child;
   return nacl_child;
 }
 
-bool NaClForkDelegate::AckChild(const int fd, const std::string& channel_id) {
-  ssize_t nwritten =
-      HANDLE_EINTR(write(fd, channel_id.c_str(), channel_id.length()));
-  if (static_cast<size_t>(nwritten) != channel_id.length()) {
-    return false;
-  }
-  return true;
-}
-
 bool NaClForkDelegate::GetTerminationStatus(pid_t pid, bool known_dead,
                                             base::TerminationStatus* status,
                                             int* exit_code) {
   VLOG(1) << "NaClForkDelegate::GetTerminationStatus";
   DCHECK(status);
   DCHECK(exit_code);
 
   Pickle write_pickle;
   write_pickle.WriteInt(nacl::kNaClGetTerminationStatusRequest);
   write_pickle.WriteInt(pid);
@@ skipping 23 matching lines @@
   int remote_exit_code;
   if (!iter.ReadInt(&remote_exit_code)) {
     LOG(ERROR) << "GetTerminationStatus: pickle failed";
     return false;
   }
 
   *status = static_cast<base::TerminationStatus>(termination_status);
   *exit_code = remote_exit_code;
   return true;
 }