Remove deprecated methods from 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 126 matching lines @@
     NOTREACHED() << "Sandbox host message is larger than kMaxFontFamilyLength";
     return;
   }
   if (fds.empty())
     return;
 
   Pickle pickle(buf, len);
   PickleIterator iter(pickle);
 
   int kind;
-  if (!pickle.ReadInt(&iter, &kind))
+  if (!iter.ReadInt(&kind))
     return;
 
   if (kind == FontConfigIPC::METHOD_MATCH) {
-    HandleFontMatchRequest(fd, pickle, iter, fds.get());
+    HandleFontMatchRequest(fd, iter, fds.get());
   } else if (kind == FontConfigIPC::METHOD_OPEN) {
-    HandleFontOpenRequest(fd, pickle, iter, fds.get());
+    HandleFontOpenRequest(fd, iter, fds.get());
   } else if (kind == LinuxSandbox::METHOD_GET_FALLBACK_FONT_FOR_CHAR) {
-    HandleGetFallbackFontForChar(fd, pickle, iter, fds.get());
+    HandleGetFallbackFontForChar(fd, iter, fds.get());
   } else if (kind == LinuxSandbox::METHOD_LOCALTIME) {
-    HandleLocaltime(fd, pickle, iter, fds.get());
+    HandleLocaltime(fd, iter, fds.get());
   } else if (kind == LinuxSandbox::METHOD_GET_STYLE_FOR_STRIKE) {
-    HandleGetStyleForStrike(fd, pickle, iter, fds.get());
+    HandleGetStyleForStrike(fd, iter, fds.get());
   } else if (kind == LinuxSandbox::METHOD_MAKE_SHARED_MEMORY_SEGMENT) {
-    HandleMakeSharedMemorySegment(fd, pickle, iter, fds.get());
+    HandleMakeSharedMemorySegment(fd, iter, fds.get());
   } else if (kind == LinuxSandbox::METHOD_MATCH_WITH_FALLBACK) {
-    HandleMatchWithFallback(fd, pickle, iter, fds.get());
+    HandleMatchWithFallback(fd, iter, fds.get());
   }
 }
 
 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,
-    const Pickle& pickle,
     PickleIterator iter,
     const std::vector<base::ScopedFD*>& fds) {
   uint32_t requested_style;
   std::string family;
-  if (!pickle.ReadString(&iter, &family) ||
-      !pickle.ReadUInt32(&iter, &requested_style))
+  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),
@@ skipping 13 matching lines @@
     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,
-    const Pickle& pickle,
     PickleIterator iter,
     const std::vector<base::ScopedFD*>& fds) {
   uint32_t index;
-  if (!pickle.ReadUInt32(&iter, &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;
   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,
-    const Pickle& pickle,
     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 (!pickle.ReadInt(&iter, &c))
+  if (!iter.ReadInt(&c))
     return;
 
   std::string preferred_locale;
-  if (!pickle.ReadString(&iter, &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;
   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,
-    const Pickle& pickle,
     PickleIterator iter,
     const std::vector<base::ScopedFD*>& fds) {
   std::string family;
   bool bold, italic;
   uint16 pixel_size;
 
-  if (!pickle.ReadString(&iter, &family) ||
-      !pickle.ReadBool(&iter, &bold) ||
-      !pickle.ReadBool(&iter, &italic) ||
-      !pickle.ReadUInt16(&iter, &pixel_size)) {
+  if (!iter.ReadString(&family) ||
+      !iter.ReadBool(&bold) ||
+      !iter.ReadBool(&italic) ||
+      !iter.ReadUInt16(&pixel_size)) {
     return;
   }
 
   EnsureWebKitInitialized();
 
   gfx::FontRenderParamsQuery query(true);
   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;
   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,
-    const Pickle& pickle,
     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 (!pickle.ReadString(&iter, &time_string) ||
-      time_string.size() != sizeof(time_t)) {
+  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;
   reply.WriteString(result_string);
   reply.WriteString(time_zone_string);
   SendRendererReply(fds, reply, -1);
 }
 
 void SandboxIPCHandler::HandleMakeSharedMemorySegment(
     int fd,
-    const Pickle& pickle,
     PickleIterator iter,
     const std::vector<base::ScopedFD*>& fds) {
   base::SharedMemoryCreateOptions options;
   uint32_t size;
-  if (!pickle.ReadUInt32(&iter, &size))
+  if (!iter.ReadUInt32(&size))
     return;
   options.size = size;
-  if (!pickle.ReadBool(&iter, &options.executable))
+  if (!iter.ReadBool(&options.executable))
     return;
   int shm_fd = -1;
   base::SharedMemory shm;
   if (shm.Create(options))
     shm_fd = shm.handle().fd;
   Pickle reply;
   SendRendererReply(fds, reply, shm_fd);
 }
 
 void SandboxIPCHandler::HandleMatchWithFallback(
     int fd,
-    const Pickle& pickle,
     PickleIterator iter,
     const std::vector<base::ScopedFD*>& fds) {
   std::string face;
   bool is_bold, is_italic;
   uint32 charset, fallback_family;
 
-  if (!pickle.ReadString(&iter, &face) || face.empty() ||
-      !pickle.ReadBool(&iter, &is_bold) ||
-      !pickle.ReadBool(&iter, &is_italic) ||
-      !pickle.ReadUInt32(&iter, &charset) ||
-      !pickle.ReadUInt32(&iter, &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;
   SendRendererReply(fds, reply, font_fd);
 
   if (font_fd >= 0) {
@@ skipping 50 matching lines @@
 }
 
 void SandboxIPCHandler::EnsureWebKitInitialized() {
   if (blink_platform_impl_)
     return;
   blink_platform_impl_.reset(new BlinkPlatformImpl);
   blink::initializeWithoutV8(blink_platform_impl_.get());
 }
 
 }  // namespace content