Turn FileDescriptorInfo a collection class

content/browser/zygote_host/zygote_host_impl_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/browser/zygote_host/zygote_host_impl_linux.h"
 
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ skipping 269 matching lines @@
                           sizeof(sandbox_status_))) !=
         sizeof(sandbox_status_)) {
       return -1;
     }
     have_read_sandbox_status_word_ = true;
   }
 
   return HANDLE_EINTR(read(control_fd_, buf, buf_len));
 }
 
-pid_t ZygoteHostImpl::ForkRequest(
-    const std::vector<std::string>& argv,
-    const std::vector<FileDescriptorInfo>& mapping,
-    const std::string& process_type) {
+pid_t ZygoteHostImpl::ForkRequest(const std::vector<std::string>& argv,
+                                  scoped_ptr<FileDescriptorInfo> mapping,
+                                  const std::string& process_type) {
   DCHECK(init_);
   Pickle pickle;
 
   int raw_socks[2];
   PCHECK(0 == socketpair(AF_UNIX, SOCK_SEQPACKET, 0, raw_socks));
   base::ScopedFD my_sock(raw_socks[0]);
   base::ScopedFD peer_sock(raw_socks[1]);
   CHECK(UnixDomainSocket::EnableReceiveProcessId(my_sock.get()));
 
   pickle.WriteInt(kZygoteCommandFork);
   pickle.WriteString(process_type);
   pickle.WriteInt(argv.size());
   for (std::vector<std::string>::const_iterator
        i = argv.begin(); i != argv.end(); ++i)
     pickle.WriteString(*i);
 
   // Fork requests contain one file descriptor for the PID oracle, and one
   // more for each file descriptor mapping for the child process.
-  const size_t num_fds_to_send = 1 + mapping.size();
+  const size_t num_fds_to_send = 1 + mapping->GetMappingSize();
   pickle.WriteInt(num_fds_to_send);
 
   std::vector<int> fds;
-  ScopedVector<base::ScopedFD> autoclose_fds;
 
   // First FD to send is peer_sock.
+  // TODO(morrita): Ideally, this should be part of the mapping so that
+  // FileDescriptorInfo can manages its lifetime.
   fds.push_back(peer_sock.get());
-  autoclose_fds.push_back(new base::ScopedFD(peer_sock.Pass()));
 
   // The rest come from mapping.
-  for (std::vector<FileDescriptorInfo>::const_iterator
-       i = mapping.begin(); i != mapping.end(); ++i) {
-    pickle.WriteUInt32(i->id);
-    fds.push_back(i->fd.fd);
-    if (i->fd.auto_close) {
-      // Auto-close means we need to close the FDs after they have been passed
-      // to the other process.
-      autoclose_fds.push_back(new base::ScopedFD(i->fd.fd));
-    }
+  for (size_t i = 0; i < mapping->GetMappingSize(); ++i) {
+    pickle.WriteUInt32(mapping->GetIDAt(i));
+    fds.push_back(mapping->GetFDAt(i));
   }
 
   // Sanity check that we've populated |fds| correctly.
   DCHECK_EQ(num_fds_to_send, fds.size());
 
   pid_t pid;
   {
     base::AutoLock lock(control_lock_);
     if (!SendMessage(pickle, &fds))
       return base::kNullProcessHandle;
-    autoclose_fds.clear();
+    mapping.reset();
+    peer_sock.reset();
 
     {
       char buf[sizeof(kZygoteChildPingMessage) + 1];
       ScopedVector<base::ScopedFD> recv_fds;
       base::ProcessId real_pid;
 
       ssize_t n = UnixDomainSocket::RecvMsgWithPid(
           my_sock.get(), buf, sizeof(buf), &recv_fds, &real_pid);
       if (n != sizeof(kZygoteChildPingMessage) ||
           0 != memcmp(buf,
@@ skipping 206 matching lines @@
   return pid_;
 }
 
 int ZygoteHostImpl::GetSandboxStatus() const {
   if (have_read_sandbox_status_word_)
     return sandbox_status_;
   return 0;
 }
 
 }  // namespace content