Refactor Pickle Read methods to use higher performance PickleIterator.

content/browser/renderer_host/render_sandbox_host_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 "content/browser/renderer_host/render_sandbox_host_linux.h"
 
 #include <fcntl.h>
 #include <fontconfig/fontconfig.h>
 #include <stdint.h>
 #include <unistd.h>
@@ skipping 106 matching lines @@
     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);
-    void* iter = NULL;
+    PickleReader iter(pickle);
 
     int kind;
     if (!pickle.ReadInt(&iter, &kind))
       goto error;
 
     if (kind == FontConfigIPC::METHOD_MATCH) {
       HandleFontMatchRequest(fd, pickle, iter, fds);
     } else if (kind == FontConfigIPC::METHOD_OPEN) {
       HandleFontOpenRequest(fd, pickle, iter, fds);
     } else if (kind == LinuxSandbox::METHOD_GET_FONT_FAMILY_FOR_CHARS) {
@@ skipping 10 matching lines @@
       HandleMatchWithFallback(fd, pickle, iter, fds);
     }
 
   error:
     for (std::vector<int>::const_iterator
          i = fds.begin(); i != fds.end(); ++i) {
       close(*i);
     }
   }
 
-  void HandleFontMatchRequest(int fd, const Pickle& pickle, void* iter,
+  void HandleFontMatchRequest(int fd, const Pickle& pickle, PickleReader iter,
                               std::vector<int>& fds) {
     bool filefaceid_valid;
     uint32_t filefaceid;
 
     if (!pickle.ReadBool(&iter, &filefaceid_valid))
       return;
     if (filefaceid_valid) {
       if (!pickle.ReadUInt32(&iter, &filefaceid))
         return;
     }
@@ skipping 31 matching lines @@
     } else {
       reply.WriteBool(true);
       reply.WriteUInt32(result_filefaceid);
       reply.WriteString(result_family);
       reply.WriteBool(is_bold);
       reply.WriteBool(is_italic);
     }
     SendRendererReply(fds, reply, -1);
   }
 
-  void HandleFontOpenRequest(int fd, const Pickle& pickle, void* iter,
+  void HandleFontOpenRequest(int fd, const Pickle& pickle, PickleReader iter,
                              std::vector<int>& fds) {
     uint32_t filefaceid;
     if (!pickle.ReadUInt32(&iter, &filefaceid))
       return;
     const int result_fd = font_config_->Open(filefaceid);
 
     Pickle reply;
     if (result_fd == -1) {
       reply.WriteBool(false);
     } else {
       reply.WriteBool(true);
     }
 
     SendRendererReply(fds, reply, result_fd);
 
     if (result_fd >= 0)
       close(result_fd);
   }
 
-  void HandleGetFontFamilyForChars(int fd, const Pickle& pickle, void* iter,
+  void HandleGetFontFamilyForChars(int fd, const Pickle& pickle,
+                                   PickleReader iter,
                                    std::vector<int>& fds) {
     // The other side of this call is
     // chrome/renderer/renderer_sandbox_support_linux.cc
 
     int num_chars;
     if (!pickle.ReadInt(&iter, &num_chars))
       return;
 
     // We don't want a corrupt renderer asking too much of us, it might
     // overflow later in the code.
@@ skipping 30 matching lines @@
     if (family.name.data()) {
       reply.WriteString(family.name.data());
     } else {
       reply.WriteString("");
     }
     reply.WriteBool(family.isBold);
     reply.WriteBool(family.isItalic);
     SendRendererReply(fds, reply, -1);
   }
 
-  void HandleGetStyleForStrike(int fd, const Pickle& pickle, void* iter,
+  void HandleGetStyleForStrike(int fd, const Pickle& pickle, PickleReader iter,
                                std::vector<int>& fds) {
     std::string family;
     int sizeAndStyle;
 
     if (!pickle.ReadString(&iter, &family) ||
         !pickle.ReadInt(&iter, &sizeAndStyle)) {
       return;
     }
 
     EnsureWebKitInitialized();
     WebKit::WebFontRenderStyle style;
     WebFontInfo::renderStyleForStrike(family.c_str(), sizeAndStyle, &style);
 
     Pickle reply;
     reply.WriteInt(style.useBitmaps);
     reply.WriteInt(style.useAutoHint);
     reply.WriteInt(style.useHinting);
     reply.WriteInt(style.hintStyle);
     reply.WriteInt(style.useAntiAlias);
     reply.WriteInt(style.useSubpixel);
 
     SendRendererReply(fds, reply, -1);
   }
 
-  void HandleLocaltime(int fd, const Pickle& pickle, void* iter,
+  void HandleLocaltime(int fd, const Pickle& pickle, PickleReader iter,
                        std::vector<int>& 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)) {
       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 HandleGetChildWithInode(int fd, const Pickle& pickle, void* iter,
+  void HandleGetChildWithInode(int fd, const Pickle& pickle, PickleReader iter,
                                std::vector<int>& fds) {
     // The other side of this call is in zygote_main_linux.cc
     if (sandbox_cmd_.empty()) {
       LOG(ERROR) << "Not in the sandbox, this should not be called";
       return;
     }
 
     uint64_t inode;
     if (!pickle.ReadUInt64(&iter, &inode))
       return;
@@ skipping 11 matching lines @@
       // Even though the pid is invalid, we still need to reply to the zygote
       // and not just return here.
       LOG(ERROR) << "Could not get pid";
     }
 
     Pickle reply;
     reply.WriteInt(pid);
     SendRendererReply(fds, reply, -1);
   }
 
-  void HandleMakeSharedMemorySegment(int fd, const Pickle& pickle, void* iter,
+  void HandleMakeSharedMemorySegment(int fd, const Pickle& pickle,
+                                     PickleReader iter,
                                      std::vector<int>& fds) {
     base::SharedMemoryCreateOptions options;
     if (!pickle.ReadUInt32(&iter, &options.size))
       return;
     if (!pickle.ReadBool(&iter, &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 HandleMatchWithFallback(int fd, const Pickle& pickle, void* iter,
+  void HandleMatchWithFallback(int fd, const Pickle& pickle, PickleReader iter,
                                std::vector<int>& fds) {
     // Unlike the other calls, for which we are an indirection in front of
     // WebKit or Skia, this call is always made via this sandbox helper
     // process. Therefore the fontconfig code goes in here directly.
 
     std::string face;
     bool is_bold, is_italic;
     uint32 charset;
 
     if (!pickle.ReadString(&iter, &face) ||
@@ skipping 323 matching lines @@
 }
 
 RenderSandboxHostLinux::~RenderSandboxHostLinux() {
   if (initialized_) {
     if (HANDLE_EINTR(close(renderer_socket_)) < 0)
       PLOG(ERROR) << "close";
     if (HANDLE_EINTR(close(childs_lifeline_fd_)) < 0)
       PLOG(ERROR) << "close";
   }
 }