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

sandbox/linux/integration_tests/namespace_unix_domain_socket_unittest.cc

 // Copyright 2014 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 <sched.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/syscall.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
+#include <utility>
 #include <vector>
 
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
-#include "base/memory/scoped_vector.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/unix_domain_socket_linux.h"
 #include "base/process/process.h"
 #include "sandbox/linux/services/syscall_wrappers.h"
 #include "sandbox/linux/tests/unit_tests.h"
 
 // Additional tests for base's UnixDomainSocket to make sure it behaves
 // correctly in the presence of sandboxing functionality (e.g., receiving
 // PIDs across namespaces).
 
@@ skipping 60 matching lines @@
 // the descriptor is closed.
 // (Implementation details: SendHello allocates a new pipe, sends us the writing
 // end alongside the "hello" message, and then blocks until we close the writing
 // end of the pipe.)
 void RecvHello(int fd,
                base::ProcessId* sender_pid,
                base::ScopedFD* write_pipe = NULL) {
   // Extra receiving buffer space to make sure we really received only
   // sizeof(kHello) bytes and it wasn't just truncated to fit the buffer.
   char buf[sizeof(kHello) + 1];
-  ScopedVector<base::ScopedFD> message_fds;
+  std::vector<base::ScopedFD> message_fds;
   ssize_t n = base::UnixDomainSocket::RecvMsgWithPid(
       fd, buf, sizeof(buf), &message_fds, sender_pid);
   CHECK_EQ(sizeof(kHello), static_cast<size_t>(n));
   CHECK_EQ(0, memcmp(buf, kHello, sizeof(kHello)));
   CHECK_EQ(1U, message_fds.size());
   if (write_pipe)
-    write_pipe->swap(*message_fds[0]);
+    std::swap(*write_pipe, message_fds[0]);
 }
 
 // Check that receiving PIDs works across a fork().
 SANDBOX_TEST(UnixDomainSocketTest, Fork) {
   int fds[2];
   CHECK_EQ(0, socketpair(AF_UNIX, SOCK_SEQPACKET, 0, fds));
   base::ScopedFD recv_sock(fds[0]);
   base::ScopedFD send_sock(fds[1]);
 
   CHECK(base::UnixDomainSocket::EnableReceiveProcessId(recv_sock.get()));
@@ skipping 142 matching lines @@
 
   // Parent process.
   recv_sock.reset();
   SendHello(send_sock.get());
   WaitForExit(pid);
 }
 
 }  // namespace
 
 }  // namespace sandbox