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

base/posix/unix_domain_socket_linux.cc

 // Copyright (c) 2011 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 "base/posix/unix_domain_socket_linux.h"
 
 #include <errno.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
 #include <vector>
 
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
-#include "base/memory/scoped_vector.h"
 #include "base/pickle.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/stl_util.h"
 
 #if !defined(OS_NACL_NONSFI)
 #include <sys/uio.h>
 #endif
 
 namespace base {
 
@@ skipping 53 matching lines @@
   const ssize_t r = HANDLE_EINTR(sendmsg(fd, &msg, flags));
   const bool ret = static_cast<ssize_t>(length) == r;
   delete[] control_buffer;
   return ret;
 }
 
 // static
 ssize_t UnixDomainSocket::RecvMsg(int fd,
                                   void* buf,
                                   size_t length,
-                                  ScopedVector<ScopedFD>* fds) {
+                                  std::vector<ScopedFD>* fds) {
   return UnixDomainSocket::RecvMsgWithPid(fd, buf, length, fds, NULL);
 }
 
 // static
 ssize_t UnixDomainSocket::RecvMsgWithPid(int fd,
                                          void* buf,
                                          size_t length,
-                                         ScopedVector<ScopedFD>* fds,
+                                         std::vector<ScopedFD>* fds,
                                          ProcessId* pid) {
   return UnixDomainSocket::RecvMsgWithFlags(fd, buf, length, 0, fds, pid);
 }
 
 // static
 ssize_t UnixDomainSocket::RecvMsgWithFlags(int fd,
                                            void* buf,
                                            size_t length,
                                            int flags,
-                                           ScopedVector<ScopedFD>* fds,
+                                           std::vector<ScopedFD>* fds,
                                            ProcessId* out_pid) {
   fds->clear();
 
   struct msghdr msg = {};
   struct iovec iov = { buf, length };
   msg.msg_iov = &iov;
   msg.msg_iovlen = 1;
 
   const size_t kControlBufferSize =
       CMSG_SPACE(sizeof(int) * kMaxFileDescriptors)
@@ skipping 40 matching lines @@
 
   if (msg.msg_flags & MSG_TRUNC || msg.msg_flags & MSG_CTRUNC) {
     for (unsigned i = 0; i < wire_fds_len; ++i)
       close(wire_fds[i]);
     errno = EMSGSIZE;
     return -1;
   }
 
   if (wire_fds) {
     for (unsigned i = 0; i < wire_fds_len; ++i)
-      fds->push_back(new ScopedFD(wire_fds[i]));
+      fds->push_back(ScopedFD(wire_fds[i]));  // TODO(mdempsky): emplace_back
   }
 
   if (out_pid) {
     // |pid| will legitimately be -1 if we read EOF, so only DCHECK if we
     // actually received a message.  Unfortunately, Linux allows sending zero
     // length messages, which are indistinguishable from EOF, so this check
     // has false negatives.
     if (r > 0 || msg.msg_controllen > 0)
       DCHECK_GE(pid, 0);
 
@@ skipping 33 matching lines @@
     send_fds.push_back(send_sock.get());
     if (!SendMsg(fd, request.data(), request.size(), send_fds))
       return -1;
   }
 
   // Close the sending end of the socket right away so that if our peer closes
   // it before sending a response (e.g., from exiting), RecvMsgWithFlags() will
   // return EOF instead of hanging.
   send_sock.reset();
 
-  ScopedVector<ScopedFD> recv_fds;
+  std::vector<ScopedFD> recv_fds;
   // When porting to OSX keep in mind it doesn't support MSG_NOSIGNAL, so the
   // sender might get a SIGPIPE.
   const ssize_t reply_len = RecvMsgWithFlags(
       recv_sock.get(), reply, max_reply_len, recvmsg_flags, &recv_fds, NULL);
   recv_sock.reset();
   if (reply_len == -1)
     return -1;
 
   // If we received more file descriptors than caller expected, then we treat
   // that as an error.
   if (recv_fds.size() > (result_fd != NULL ? 1 : 0)) {
     NOTREACHED();
     return -1;
   }
 
   if (result_fd)
-    *result_fd = recv_fds.empty() ? -1 : recv_fds[0]->release();
+    *result_fd = recv_fds.empty() ? -1 : recv_fds.at(0).release();

[jln (very slow on Chromium), 2015/12/08 23:06:24]

Is [] to at() conversion just to be paranoid or am I missing something?

[mdempsky, 2015/12/08 23:13:55]

Yeah, just paranoia.  Reverted.

 
   return reply_len;
 }
 #endif  // !defined(OS_NACL_NONSFI)
 
 }  // namespace base