Close leaking FDs.

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 <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/eintr_wrapper.h"
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/linux_util.h"
 #include "base/logging.h"
+#include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/pickle.h"
 #include "base/posix/unix_domain_socket.h"
 #include "base/process_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
@@ skipping 202 matching lines @@
       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 base::GlobalDescriptors::Mapping& mapping,
+    const std::vector<content::FileDescriptorInfo>& mapping,
     const std::string& process_type) {
   DCHECK(init_);
   Pickle pickle;
 
   pickle.WriteInt(content::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);
 
   pickle.WriteInt(mapping.size());
 
   std::vector<int> fds;
-  for (base::GlobalDescriptors::Mapping::const_iterator
+  // Scoped pointers cannot be stored in containers, so we have to use a
+  // linked_ptr.
+  std::vector<linked_ptr<file_util::ScopedFD> > autodelete_fds;
+  for (std::vector<content::FileDescriptorInfo>::const_iterator
        i = mapping.begin(); i != mapping.end(); ++i) {
-    pickle.WriteUInt32(i->first);
-    fds.push_back(i->second);
+    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 habe been passed
+      // to the other process.
+      linked_ptr<file_util::ScopedFD> ptr(
+          new file_util::ScopedFD(&(fds.back())));
+      autodelete_fds.push_back(ptr);
+    }
   }
 
   pid_t pid;
   {
     base::AutoLock lock(control_lock_);
     if (!UnixDomainSocket::SendMsg(control_fd_, pickle.data(), pickle.size(),
                                    fds))
       return base::kNullProcessHandle;
 
     // Read the reply, which pickles the PID and an optional UMA enumeration.
@@ skipping 211 matching lines @@
 
 pid_t ZygoteHostImpl::GetSandboxHelperPid() const {
   return RenderSandboxHostLinux::GetInstance()->pid();
 }
 
 int ZygoteHostImpl::GetSandboxStatus() const {
   if (have_read_sandbox_status_word_)
     return sandbox_status_;
   return 0;
 }