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

content/browser/renderer_host/sandbox_ipc_linux.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 "content/browser/renderer_host/sandbox_ipc_linux.h"
 
 #include <fcntl.h>
 #include <sys/poll.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/files/scoped_file.h"
 #include "base/linux_util.h"
 #include "base/macros.h"
-#include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/unix_domain_socket_linux.h"
 #include "base/process/launch.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/browser/renderer_host/font_utils_linux.h"
 #include "content/common/font_config_ipc_linux.h"
 #include "content/common/sandbox_linux/sandbox_linux.h"
 #include "content/common/set_process_title.h"
 #include "content/public/common/content_switches.h"
@@ skipping 88 matching lines @@
 
     if (pfds[1].revents & POLLIN) {
       HandleRequestFromRenderer(browser_socket_);
     }
   }
 
   VLOG(1) << "SandboxIPCHandler stopping.";
 }
 
 void SandboxIPCHandler::HandleRequestFromRenderer(int fd) {
-  ScopedVector<base::ScopedFD> fds;
+  std::vector<base::ScopedFD> fds;
 
   // A FontConfigIPC::METHOD_MATCH message could be kMaxFontFamilyLength
   // bytes long (this is the largest message type).
   // 128 bytes padding are necessary so recvmsg() does not return MSG_TRUNC
   // error for a maximum length message.
   char buf[FontConfigIPC::kMaxFontFamilyLength + 128];
 
   const ssize_t len =
       base::UnixDomainSocket::RecvMsg(fd, buf, sizeof(buf), &fds);
   if (len == -1) {
     // TODO: should send an error reply, or the sender might block forever.
     NOTREACHED() << "Sandbox host message is larger than kMaxFontFamilyLength";
     return;
   }
   if (fds.empty())
     return;
 
   base::Pickle pickle(buf, len);
   base::PickleIterator iter(pickle);
 
   int kind;
   if (!iter.ReadInt(&kind))
     return;
 
   if (kind == FontConfigIPC::METHOD_MATCH) {
-    HandleFontMatchRequest(fd, iter, fds.get());
+    HandleFontMatchRequest(fd, iter, fds);
   } else if (kind == FontConfigIPC::METHOD_OPEN) {
-    HandleFontOpenRequest(fd, iter, fds.get());
+    HandleFontOpenRequest(fd, iter, fds);
   } else if (kind == LinuxSandbox::METHOD_GET_FALLBACK_FONT_FOR_CHAR) {
-    HandleGetFallbackFontForChar(fd, iter, fds.get());
+    HandleGetFallbackFontForChar(fd, iter, fds);
   } else if (kind == LinuxSandbox::METHOD_LOCALTIME) {
-    HandleLocaltime(fd, iter, fds.get());
+    HandleLocaltime(fd, iter, fds);
   } else if (kind == LinuxSandbox::METHOD_GET_STYLE_FOR_STRIKE) {
-    HandleGetStyleForStrike(fd, iter, fds.get());
+    HandleGetStyleForStrike(fd, iter, fds);
   } else if (kind == LinuxSandbox::METHOD_MAKE_SHARED_MEMORY_SEGMENT) {
-    HandleMakeSharedMemorySegment(fd, iter, fds.get());
+    HandleMakeSharedMemorySegment(fd, iter, fds);
   } else if (kind == LinuxSandbox::METHOD_MATCH_WITH_FALLBACK) {
-    HandleMatchWithFallback(fd, iter, fds.get());
+    HandleMatchWithFallback(fd, iter, fds);
   }
 }
 
 int SandboxIPCHandler::FindOrAddPath(const SkString& path) {
   int count = paths_.count();
   for (int i = 0; i < count; ++i) {
     if (path == *paths_[i])
       return i;
   }
   *paths_.append() = new SkString(path);
   return count;
 }
 
 void SandboxIPCHandler::HandleFontMatchRequest(
     int fd,
     base::PickleIterator iter,
-    const std::vector<base::ScopedFD*>& fds) {
+    const std::vector<base::ScopedFD>& fds) {
   uint32_t requested_style;
   std::string family;
   if (!iter.ReadString(&family) || !iter.ReadUInt32(&requested_style))
     return;
 
   SkFontConfigInterface::FontIdentity result_identity;
   SkString result_family;
   SkTypeface::Style result_style;
   SkFontConfigInterface* fc =
       SkFontConfigInterface::GetSingletonDirectInterface();
@@ skipping 17 matching lines @@
     skia::WriteSkString(&reply, result_family);
     skia::WriteSkFontIdentity(&reply, result_identity);
     reply.WriteUInt32(result_style);
   }
   SendRendererReply(fds, reply, -1);
 }
 
 void SandboxIPCHandler::HandleFontOpenRequest(
     int fd,
     base::PickleIterator iter,
-    const std::vector<base::ScopedFD*>& fds) {
+    const std::vector<base::ScopedFD>& fds) {
   uint32_t index;
   if (!iter.ReadUInt32(&index))
     return;
   if (index >= static_cast<uint32_t>(paths_.count()))
     return;
   const int result_fd = open(paths_[index]->c_str(), O_RDONLY);
 
   base::Pickle reply;
   if (result_fd == -1) {
     reply.WriteBool(false);
   } else {
     reply.WriteBool(true);
   }
 
   // The receiver will have its own access to the file, so we will close it
   // after this send.
   SendRendererReply(fds, reply, result_fd);
 
   if (result_fd >= 0) {
     int err = IGNORE_EINTR(close(result_fd));
     DCHECK(!err);
   }
 }
 
 void SandboxIPCHandler::HandleGetFallbackFontForChar(
     int fd,
     base::PickleIterator iter,
-    const std::vector<base::ScopedFD*>& fds) {
+    const std::vector<base::ScopedFD>& fds) {
   // The other side of this call is
   // content/common/child_process_sandbox_support_impl_linux.cc
 
   EnsureWebKitInitialized();
   WebUChar32 c;
   if (!iter.ReadInt(&c))
     return;
 
   std::string preferred_locale;
   if (!iter.ReadString(&preferred_locale))
@@ skipping 19 matching lines @@
   reply.WriteInt(fallbackFont.fontconfigInterfaceId);
   reply.WriteInt(fallbackFont.ttcIndex);
   reply.WriteBool(fallbackFont.isBold);
   reply.WriteBool(fallbackFont.isItalic);
   SendRendererReply(fds, reply, -1);
 }
 
 void SandboxIPCHandler::HandleGetStyleForStrike(
     int fd,
     base::PickleIterator iter,
-    const std::vector<base::ScopedFD*>& fds) {
+    const std::vector<base::ScopedFD>& fds) {
   std::string family;
   bool bold, italic;
   uint16 pixel_size;
 
   if (!iter.ReadString(&family) ||
       !iter.ReadBool(&bold) ||
       !iter.ReadBool(&italic) ||
       !iter.ReadUInt16(&pixel_size)) {
     return;
   }
@@ skipping 17 matching lines @@
   reply.WriteInt(params.antialiasing);
   reply.WriteInt(ConvertSubpixelRendering(params.subpixel_rendering));
   reply.WriteInt(params.subpixel_positioning);
 
   SendRendererReply(fds, reply, -1);
 }
 
 void SandboxIPCHandler::HandleLocaltime(
     int fd,
     base::PickleIterator iter,
-    const std::vector<base::ScopedFD*>& fds) {
+    const std::vector<base::ScopedFD>& fds) {
   // The other side of this call is in zygote_main_linux.cc
 
   std::string time_string;
   if (!iter.ReadString(&time_string) || time_string.size() != sizeof(time_t))
     return;
 
   time_t time;
   memcpy(&time, time_string.data(), sizeof(time));
   // We use localtime here because we need the tm_zone field to be filled
   // out. Since we are a single-threaded process, this is safe.
   const struct tm* expanded_time = localtime(&time);
 
   std::string result_string;
   const char* time_zone_string = "";
   if (expanded_time != NULL) {
     result_string = std::string(reinterpret_cast<const char*>(expanded_time),
                                 sizeof(struct tm));
     time_zone_string = expanded_time->tm_zone;
   }
 
   base::Pickle reply;
   reply.WriteString(result_string);
   reply.WriteString(time_zone_string);
   SendRendererReply(fds, reply, -1);
 }
 
 void SandboxIPCHandler::HandleMakeSharedMemorySegment(
     int fd,
     base::PickleIterator iter,
-    const std::vector<base::ScopedFD*>& fds) {
+    const std::vector<base::ScopedFD>& fds) {
   base::SharedMemoryCreateOptions options;
   uint32_t size;
   if (!iter.ReadUInt32(&size))
     return;
   options.size = size;
   if (!iter.ReadBool(&options.executable))
     return;
   int shm_fd = -1;
   base::SharedMemory shm;
   if (shm.Create(options))
     shm_fd = shm.handle().fd;
   base::Pickle reply;
   SendRendererReply(fds, reply, shm_fd);
 }
 
 void SandboxIPCHandler::HandleMatchWithFallback(
     int fd,
     base::PickleIterator iter,
-    const std::vector<base::ScopedFD*>& fds) {
+    const std::vector<base::ScopedFD>& fds) {
   std::string face;
   bool is_bold, is_italic;
   uint32 charset, fallback_family;
 
   if (!iter.ReadString(&face) || face.empty() ||
       !iter.ReadBool(&is_bold) ||
       !iter.ReadBool(&is_italic) ||
       !iter.ReadUInt32(&charset) ||
       !iter.ReadUInt32(&fallback_family)) {
     return;
   }
 
   int font_fd = MatchFontFaceWithFallback(
       face, is_bold, is_italic, charset, fallback_family);
 
   base::Pickle reply;
   SendRendererReply(fds, reply, font_fd);
 
   if (font_fd >= 0) {
     if (IGNORE_EINTR(close(font_fd)) < 0)
       PLOG(ERROR) << "close";
   }
 }
 
 void SandboxIPCHandler::SendRendererReply(
-    const std::vector<base::ScopedFD*>& fds,
+    const std::vector<base::ScopedFD>& fds,
     const base::Pickle& reply,
     int reply_fd) {
   struct msghdr msg;
   memset(&msg, 0, sizeof(msg));
   struct iovec iov = {const_cast<void*>(reply.data()), reply.size()};
   msg.msg_iov = &iov;
   msg.msg_iovlen = 1;
 
   char control_buffer[CMSG_SPACE(sizeof(int))];
 
@@ skipping 10 matching lines @@
     msg.msg_control = control_buffer;
     msg.msg_controllen = sizeof(control_buffer);
     cmsg = CMSG_FIRSTHDR(&msg);
     cmsg->cmsg_level = SOL_SOCKET;
     cmsg->cmsg_type = SCM_RIGHTS;
     cmsg->cmsg_len = CMSG_LEN(sizeof(int));
     memcpy(CMSG_DATA(cmsg), &reply_fd, sizeof(reply_fd));
     msg.msg_controllen = cmsg->cmsg_len;
   }
 
-  if (HANDLE_EINTR(sendmsg(fds[0]->get(), &msg, MSG_DONTWAIT)) < 0)
+  if (HANDLE_EINTR(sendmsg(fds[0].get(), &msg, MSG_DONTWAIT)) < 0)
     PLOG(ERROR) << "sendmsg";
 }
 
 SandboxIPCHandler::~SandboxIPCHandler() {
   paths_.deleteAll();
   if (blink_platform_impl_)
     blink::shutdownWithoutV8();
 
   if (IGNORE_EINTR(close(lifeline_fd_)) < 0)
     PLOG(ERROR) << "close";
   if (IGNORE_EINTR(close(browser_socket_)) < 0)
     PLOG(ERROR) << "close";
 }
 
 void SandboxIPCHandler::EnsureWebKitInitialized() {
   if (blink_platform_impl_)
     return;
   blink_platform_impl_.reset(new BlinkPlatformImpl);
   blink::initializeWithoutV8(blink_platform_impl_.get());
 }
 
 }  // namespace content