Replace ScopedVector<ScopedFD> with std::vector<ScopedFD>

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>
 #include <stdint.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/wait.h>
+
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/linux_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_vector.h"
 #include "base/pickle.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/global_descriptors.h"
 #include "base/posix/unix_domain_socket_linux.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/process/process.h"
 #include "base/process/process_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 188 matching lines @@
 
 bool Zygote::UsingSUIDSandbox() const {
   return sandbox_flags_ & kSandboxLinuxSUID;
 }
 
 bool Zygote::UsingNSSandbox() const {
   return sandbox_flags_ & kSandboxLinuxUserNS;
 }
 
 bool Zygote::HandleRequestFromBrowser(int fd) {
-  ScopedVector<base::ScopedFD> fds;
+  std::vector<base::ScopedFD> fds;
   char buf[kZygoteMaxMessageLength];
   const ssize_t len = base::UnixDomainSocket::RecvMsg(
       fd, buf, sizeof(buf), &fds);
 
   if (len == 0 || (len == -1 && errno == ECONNRESET)) {
     // EOF from the browser. We should die.
     // TODO(earthdok): call __sanititizer_cov_dump() here to obtain code
-    // coverage  for the Zygote. Currently it's not possible because of
+    // coverage for the Zygote. Currently it's not possible because of
     // confusion over who is responsible for closing the file descriptor.
-    for (std::vector<int>::iterator it = extra_fds_.begin();
-         it < extra_fds_.end(); ++it) {
-      PCHECK(0 == IGNORE_EINTR(close(*it)));
+    for (int fd : extra_fds_) {
+      PCHECK(0 == IGNORE_EINTR(close(fd)));
     }
 #if !defined(SANITIZER_COVERAGE)
     // TODO(earthdok): add watchdog thread before using this in builds not
     // using sanitizer coverage.
     CHECK(extra_children_.empty());
 #endif
-    for (std::vector<base::ProcessHandle>::iterator it =
-             extra_children_.begin();
-         it < extra_children_.end(); ++it) {
-      PCHECK(*it == HANDLE_EINTR(waitpid(*it, NULL, 0)));
+    for (base::ProcessHandle pid : extra_children_) {
+      PCHECK(pid == HANDLE_EINTR(waitpid(pid, NULL, 0)));
     }
     _exit(0);
     return false;
   }
 
   if (len == -1) {
     PLOG(ERROR) << "Error reading message from browser";
     return false;
   }
 
   base::Pickle pickle(buf, len);
   base::PickleIterator iter(pickle);
 
   int kind;
   if (iter.ReadInt(&kind)) {
     switch (kind) {
       case kZygoteCommandFork:
         // This function call can return multiple times, once per fork().
-        return HandleForkRequest(fd, iter, fds.Pass());
+        return HandleForkRequest(fd, iter, std::move(fds));
 
       case kZygoteCommandReap:
         if (!fds.empty())
           break;
         HandleReapRequest(fd, iter);
         return false;
       case kZygoteCommandGetTerminationStatus:
         if (!fds.empty())
           break;
         HandleGetTerminationStatus(fd, iter);
@@ skipping 214 matching lines @@
   }
 
   // In the parent process.
   read_pipe.reset();
   pid_oracle.reset();
 
   // Always receive a real PID from the zygote host, though it might
   // be invalid (see below).
   base::ProcessId real_pid;
   {
-    ScopedVector<base::ScopedFD> recv_fds;
+    std::vector<base::ScopedFD> recv_fds;
     char buf[kZygoteMaxMessageLength];
     const ssize_t len = base::UnixDomainSocket::RecvMsg(
         kZygoteSocketPairFd, buf, sizeof(buf), &recv_fds);
     CHECK_GT(len, 0);
     CHECK(recv_fds.empty());
 
     base::Pickle pickle(buf, len);
     base::PickleIterator iter(pickle);
 
     int kind;
@@ skipping 29 matching lines @@
     LOG(ERROR) << "Already tracking PID " << real_pid;
     NOTREACHED();
   }
   process_info_map_[real_pid].internal_pid = pid;
   process_info_map_[real_pid].started_from_helper = helper;
 
   return real_pid;
 }
 
 base::ProcessId Zygote::ReadArgsAndFork(base::PickleIterator iter,
-                                        ScopedVector<base::ScopedFD> fds,
+                                        std::vector<base::ScopedFD> fds,
                                         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("--")
@@ skipping 14 matching lines @@
   }
 
   if (!iter.ReadInt(&numfds))
     return -1;
   if (numfds != static_cast<int>(fds.size()))
     return -1;
 
   // First FD is the PID oracle socket.
   if (fds.size() < 1)
     return -1;
-  base::ScopedFD pid_oracle(std::move(*fds[0]));
+  base::ScopedFD pid_oracle(std::move(fds[0]));
 
   // Remaining FDs are for the global descriptor mapping.
   for (int i = 1; i < numfds; ++i) {
     base::GlobalDescriptors::Key key;
     if (!iter.ReadUInt32(&key))
       return -1;
-    mapping.push_back(base::GlobalDescriptors::Descriptor(key, fds[i]->get()));
+    mapping.push_back(base::GlobalDescriptors::Descriptor(key, fds[i].get()));
   }
 
   mapping.push_back(base::GlobalDescriptors::Descriptor(
       static_cast<uint32_t>(kSandboxIPCChannel), GetSandboxFD()));
 
   // Returns twice, once per process.
   base::ProcessId child_pid =
       ForkWithRealPid(process_type, mapping, channel_id, std::move(pid_oracle),
                       uma_name, uma_sample, uma_boundary_value);
   if (!child_pid) {
     // This is the child process.
 
     // Our socket from the browser.
     PCHECK(0 == IGNORE_EINTR(close(kZygoteSocketPairFd)));
 
     // Pass ownership of file descriptors from fds to GlobalDescriptors.
-    for (ScopedVector<base::ScopedFD>::iterator i = fds.begin(); i != fds.end();
-         ++i)
-      ignore_result((*i)->release());
+    for (base::ScopedFD& fd : fds)
+      ignore_result(fd.release());
     base::GlobalDescriptors::GetInstance()->Reset(mapping);
 
     // Reset the process-wide command line to our new command line.
     base::CommandLine::Reset();
     base::CommandLine::Init(0, NULL);
     base::CommandLine::ForCurrentProcess()->InitFromArgv(args);
 
     // Update the process title. The argv was already cached by the call to
     // SetProcessTitleFromCommandLine in ChromeMain, so we can pass NULL here
     // (we don't have the original argv at this point).
     SetProcessTitleFromCommandLine(NULL);
   } else if (child_pid < 0) {
     LOG(ERROR) << "Zygote could not fork: process_type " << process_type
         << " numfds " << numfds << " child_pid " << child_pid;
   }
   return child_pid;
 }
 
 bool Zygote::HandleForkRequest(int fd,
                                base::PickleIterator iter,
-                               ScopedVector<base::ScopedFD> fds) {
+                               std::vector<base::ScopedFD> fds) {
   std::string uma_name;
   int uma_sample;
   int uma_boundary_value;
-  base::ProcessId child_pid = ReadArgsAndFork(
-      iter, fds.Pass(), &uma_name, &uma_sample, &uma_boundary_value);
+  base::ProcessId child_pid = ReadArgsAndFork(iter, std::move(fds), &uma_name,
+                                              &uma_sample, &uma_boundary_value);
   if (child_pid == 0)
     return true;
   // If there's no UMA report for this particular fork, then check if any
   // helpers have an initial UMA report for us to send instead.
   while (uma_name.empty() && initial_uma_index_ < helpers_.size()) {
     helpers_[initial_uma_index_++]->InitialUMA(
         &uma_name, &uma_sample, &uma_boundary_value);
   }
   // Must always send reply, as ZygoteHost blocks while waiting for it.
   base::Pickle reply_pickle;
@@ skipping 12 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