Change UnixDomainSocket::RecvMsg to return ScopedVector<base::ScopedFD>

sandbox/linux/services/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 <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_handle.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).
 
 namespace sandbox {
@@ 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];
-  std::vector<int> message_fds;
+  ScopedVector<base::ScopedFD> message_fds;
   ssize_t n = 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());
-  base::ScopedFD message_fd(message_fds[0]);
   if (write_pipe)
-    write_pipe->swap(message_fd);
+    write_pipe->swap(*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(UnixDomainSocket::EnableReceiveProcessId(recv_sock.get()));
@@ skipping 142 matching lines @@
 
   // Parent process.
   recv_sock.reset();
   SendHello(send_sock.get());
   WaitForExit(pid);
 }
 
 }  // namespace
 
 }  // namespace sandbox