Change most uses of Pickle to base::Pickle

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>
@@ skipping 122 matching lines @@
 
   const ssize_t len = 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;
 
-  Pickle pickle(buf, len);
-  PickleIterator iter(pickle);
+  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());
   } else if (kind == FontConfigIPC::METHOD_OPEN) {
     HandleFontOpenRequest(fd, iter, fds.get());
   } else if (kind == LinuxSandbox::METHOD_GET_FALLBACK_FONT_FOR_CHAR) {
@@ skipping 14 matching lines @@
   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,
-    PickleIterator iter,
+    base::PickleIterator iter,
     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();
   const bool r =
       fc->matchFamilyName(family.c_str(),
                           static_cast<SkTypeface::Style>(requested_style),
                           &result_identity,
                           &result_family,
                           &result_style);
 
-  Pickle reply;
+  base::Pickle reply;
   if (!r) {
     reply.WriteBool(false);
   } else {
     // Stash away the returned path, so we can give it an ID (index)
     // which will later be given to us in a request to open the file.
     int index = FindOrAddPath(result_identity.fString);
     result_identity.fID = static_cast<uint32_t>(index);
 
     reply.WriteBool(true);
     skia::WriteSkString(&reply, result_family);
     skia::WriteSkFontIdentity(&reply, result_identity);
     reply.WriteUInt32(result_style);
   }
   SendRendererReply(fds, reply, -1);
 }
 
 void SandboxIPCHandler::HandleFontOpenRequest(
     int fd,
-    PickleIterator iter,
+    base::PickleIterator iter,
     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);
 
-  Pickle reply;
+  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,
-    PickleIterator iter,
+    base::PickleIterator iter,
     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))
     return;
 
   blink::WebFallbackFont fallbackFont;
   WebFontInfo::fallbackFontForChar(c, preferred_locale.c_str(), &fallbackFont);
 
   int pathIndex = FindOrAddPath(SkString(fallbackFont.filename.data()));
   fallbackFont.fontconfigInterfaceId = pathIndex;
 
-  Pickle reply;
+  base::Pickle reply;
   if (fallbackFont.name.data()) {
     reply.WriteString(fallbackFont.name.data());
   } else {
     reply.WriteString(std::string());
   }
   if (fallbackFont.filename.data()) {
     reply.WriteString(fallbackFont.filename.data());
   } else {
     reply.WriteString(std::string());
   }
   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,
-    PickleIterator iter,
+    base::PickleIterator iter,
     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;
   }
 
   EnsureWebKitInitialized();
 
   gfx::FontRenderParamsQuery query;
   query.families.push_back(family);
   query.pixel_size = pixel_size;
   query.style = gfx::Font::NORMAL |
       (bold ? gfx::Font::BOLD : 0) | (italic ? gfx::Font::ITALIC : 0);
   const gfx::FontRenderParams params = gfx::GetFontRenderParams(query, NULL);
 
   // These are passed as ints since they're interpreted as tri-state chars in
   // Blink.
-  Pickle reply;
+  base::Pickle reply;
   reply.WriteInt(params.use_bitmaps);
   reply.WriteInt(params.autohinter);
   reply.WriteInt(params.hinting != gfx::FontRenderParams::HINTING_NONE);
   reply.WriteInt(ConvertHinting(params.hinting));
   reply.WriteInt(params.antialiasing);
   reply.WriteInt(ConvertSubpixelRendering(params.subpixel_rendering));
   reply.WriteInt(params.subpixel_positioning);
 
   SendRendererReply(fds, reply, -1);
 }
 
 void SandboxIPCHandler::HandleLocaltime(
     int fd,
-    PickleIterator iter,
+    base::PickleIterator iter,
     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;
   }
 
-  Pickle reply;
+  base::Pickle reply;
   reply.WriteString(result_string);
   reply.WriteString(time_zone_string);
   SendRendererReply(fds, reply, -1);
 }
 
 void SandboxIPCHandler::HandleMakeSharedMemorySegment(
     int fd,
-    PickleIterator iter,
+    base::PickleIterator iter,
     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;
-  Pickle reply;
+  base::Pickle reply;
   SendRendererReply(fds, reply, shm_fd);
 }
 
 void SandboxIPCHandler::HandleMatchWithFallback(
     int fd,
-    PickleIterator iter,
+    base::PickleIterator iter,
     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);
 
-  Pickle reply;
+  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 Pickle& reply,
+    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))];
 
   if (reply_fd != -1) {
@@ skipping 32 matching lines @@
 }
 
 void SandboxIPCHandler::EnsureWebKitInitialized() {
   if (blink_platform_impl_)
     return;
   blink_platform_impl_.reset(new BlinkPlatformImpl);
   blink::initializeWithoutV8(blink_platform_impl_.get());
 }
 
 }  // namespace content