Refactor Pickle Read methods to use higher performance PickleIterator.

content/browser/zygote_main_linux.cc

 // Copyright (c) 2012 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/zygote_host_impl_linux.h"
 
 #include <dlfcn.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <sys/socket.h>
@@ skipping 151 matching lines @@
       _exit(0);
       return false;
     }
 
     if (len == -1) {
       PLOG(ERROR) << "Error reading message from browser";
       return false;
     }
 
     Pickle pickle(buf, len);
-    void* iter = NULL;
+    PickleIterator iter(pickle);
 
     int kind;
     if (pickle.ReadInt(&iter, &kind)) {
       switch (kind) {
         case ZygoteHostImpl::kCmdFork:
           // This function call can return multiple times, once per fork().
           return HandleForkRequest(fd, pickle, iter, fds);
 
         case ZygoteHostImpl::kCmdReap:
           if (!fds.empty())
@@ skipping 14 matching lines @@
       }
     }
 
     LOG(WARNING) << "Error parsing message from browser";
     for (std::vector<int>::const_iterator
          i = fds.begin(); i != fds.end(); ++i)
       close(*i);
     return false;
   }
 
-  void HandleReapRequest(int fd, const Pickle& pickle, void* iter) {
+  void HandleReapRequest(int fd, const Pickle& pickle, PickleIterator iter) {
     base::ProcessId child;
     base::ProcessId actual_child;
 
     if (!pickle.ReadInt(&iter, &child)) {
       LOG(WARNING) << "Error parsing reap request from browser";
       return;
     }
 
     if (g_suid_sandbox_active) {
       actual_child = real_pids_to_sandbox_pids[child];
       if (!actual_child)
         return;
       real_pids_to_sandbox_pids.erase(child);
     } else {
       actual_child = child;
     }
 
     base::EnsureProcessTerminated(actual_child);
   }
 
-  void HandleGetTerminationStatus(int fd, const Pickle& pickle, void* iter) {
+  void HandleGetTerminationStatus(int fd,
+                                  const Pickle& pickle,
+                                  PickleIterator iter) {
     base::ProcessHandle child;
 
     if (!pickle.ReadInt(&iter, &child)) {
       LOG(WARNING) << "Error parsing GetTerminationStatus request "
                    << "from browser";
       return;
     }
 
     base::TerminationStatus status;
     int exit_code;
@@ skipping 101 matching lines @@
 
         const ssize_t r = UnixDomainSocket::SendRecvMsg(
             kMagicSandboxIPCDescriptor, reply_buf, sizeof(reply_buf), NULL,
             request);
         if (r == -1) {
           LOG(ERROR) << "Failed to get child process's real PID";
           goto error;
         }
 
         Pickle reply(reinterpret_cast<char*>(reply_buf), r);
-        void* iter = NULL;
+        PickleIterator iter(reply);
         if (!reply.ReadInt(&iter, &real_pid))
           goto error;
         if (real_pid <= 0) {
           // METHOD_GET_CHILD_WITH_INODE failed. Did the child die already?
           LOG(ERROR) << "METHOD_GET_CHILD_WITH_INODE failed";
           goto error;
         }
         real_pids_to_sandbox_pids[real_pid] = pid;
       }
       if (use_helper) {
@@ skipping 25 matching lines @@
       close(pipe_fds[0]);
     if (pipe_fds[1] >= 0)
       close(pipe_fds[1]);
     return -1;
   }
 
   // Unpacks process type and arguments from |pickle| and forks a new process.
   // Returns -1 on error, otherwise returns twice, returning 0 to the child
   // process and the child process ID to the parent process, like fork().
   base::ProcessId ReadArgsAndFork(const Pickle& pickle,
-                                  void* iter,
+                                  PickleIterator iter,
                                   std::vector<int>& fds,
                                   std::string* uma_name,
                                   int* uma_sample,
                                   int* uma_boundary_value) {
     std::vector<std::string> args;
     int argc = 0;
     int numfds = 0;
     base::GlobalDescriptors::Mapping mapping;
     std::string process_type;
     std::string channel_id;
@@ skipping 72 matching lines @@
           << " numfds " << numfds << " child_pid " << child_pid;
     }
     return child_pid;
   }
 
   // Handle a 'fork' request from the browser: this means that the browser
   // wishes to start a new renderer.  Returns true if we are in a new process,
   // otherwise writes the child_pid back to the browser via |fd|.  Writes a
   // child_pid of -1 on error.
   bool HandleForkRequest(int fd, const Pickle& pickle,
-                         void* iter, std::vector<int>& fds) {
+                         PickleIterator iter, std::vector<int>& fds) {
     std::string uma_name;
     int uma_sample;
     int uma_boundary_value;
     base::ProcessId child_pid = ReadArgsAndFork(pickle, iter, fds,
                                                 &uma_name, &uma_sample,
                                                 &uma_boundary_value);
     if (child_pid == 0)
       return true;
     for (std::vector<int>::const_iterator
          i = fds.begin(); i != fds.end(); ++i)
@@ skipping 14 matching lines @@
     if (!uma_name.empty()) {
       reply_pickle.WriteInt(uma_sample);
       reply_pickle.WriteInt(uma_boundary_value);
     }
     if (HANDLE_EINTR(write(fd, reply_pickle.data(), reply_pickle.size())) !=
         static_cast<ssize_t> (reply_pickle.size()))
       PLOG(ERROR) << "write";
     return false;
   }
 
-  bool HandleGetSandboxStatus(int fd, const Pickle& pickle, void* iter) {
+  bool HandleGetSandboxStatus(int fd,
+                              const Pickle& pickle,
+                              PickleIterator iter) {
     if (HANDLE_EINTR(write(fd, &sandbox_flags_, sizeof(sandbox_flags_)) !=
                      sizeof(sandbox_flags_))) {
       PLOG(ERROR) << "write";
     }
 
     return false;
   }
 
   // In the SUID sandbox, we try to use a new PID namespace. Thus the PIDs
   // fork() returns are not the real PIDs, so we need to map the Real PIDS
@@ skipping 25 matching lines @@
 
   uint8_t reply_buf[512];
   const ssize_t r = UnixDomainSocket::SendRecvMsg(
       kMagicSandboxIPCDescriptor, reply_buf, sizeof(reply_buf), NULL, request);
   if (r == -1) {
     memset(output, 0, sizeof(struct tm));
     return;
   }
 
   Pickle reply(reinterpret_cast<char*>(reply_buf), r);
-  void* iter = NULL;
+  PickleIterator iter(reply);
   std::string result, timezone;
   if (!reply.ReadString(&iter, &result) ||
       !reply.ReadString(&iter, &timezone) ||
       result.size() != sizeof(struct tm)) {
     memset(output, 0, sizeof(struct tm));
     return;
   }
 
   memcpy(output, result.data(), sizeof(struct tm));
   if (timezone_out_len) {
@@ skipping 288 matching lines @@
       VLOG(1) << "Enabling experimental Seccomp sandbox.";
       sandbox_flags |= ZygoteHostImpl::kSandboxSeccomp;
     }
   }
 #endif  // SECCOMP_SANDBOX
 
   Zygote zygote(sandbox_flags, forkdelegate);
   // This function call can return multiple times, once per fork().
   return zygote.ProcessRequests();
 }