Remove deprecated methods from Pickle.

content/zygote/zygote_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/zygote/zygote_linux.h"
 
 #include <fcntl.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/types.h>
@@ skipping 167 matching lines @@
 
   if (len == -1) {
     PLOG(ERROR) << "Error reading message from browser";
     return false;
   }
 
   Pickle pickle(buf, len);
   PickleIterator iter(pickle);
 
   int kind;
-  if (pickle.ReadInt(&iter, &kind)) {
+  if (iter.ReadInt(&kind)) {
     switch (kind) {
       case kZygoteCommandFork:
         // This function call can return multiple times, once per fork().
-        return HandleForkRequest(fd, pickle, iter, fds.Pass());
+        return HandleForkRequest(fd, iter, fds.Pass());
 
       case kZygoteCommandReap:
         if (!fds.empty())
           break;
-        HandleReapRequest(fd, pickle, iter);
+        HandleReapRequest(fd, iter);
         return false;
       case kZygoteCommandGetTerminationStatus:
         if (!fds.empty())
           break;
-        HandleGetTerminationStatus(fd, pickle, iter);
+        HandleGetTerminationStatus(fd, iter);
         return false;
       case kZygoteCommandGetSandboxStatus:
-        HandleGetSandboxStatus(fd, pickle, iter);
+        HandleGetSandboxStatus(fd, iter);
         return false;
       case kZygoteCommandForkRealPID:
         // This shouldn't happen in practice, but some failure paths in
         // HandleForkRequest (e.g., if ReadArgsAndFork fails during depickling)
         // could leave this command pending on the socket.
         LOG(ERROR) << "Unexpected real PID message from browser";
         NOTREACHED();
         return false;
       default:
         NOTREACHED();
         break;
     }
   }
 
   LOG(WARNING) << "Error parsing message from browser";
   return false;
 }
 
 // TODO(jln): remove callers to this broken API. See crbug.com/274855.
 void Zygote::HandleReapRequest(int fd,
-                               const Pickle& pickle,
                                PickleIterator iter) {
   base::ProcessId child;
 
-  if (!pickle.ReadInt(&iter, &child)) {
+  if (!iter.ReadInt(&child)) {
     LOG(WARNING) << "Error parsing reap request from browser";
     return;
   }
 
   ZygoteProcessInfo child_info;
   if (!GetProcessInfo(child, &child_info)) {
     LOG(ERROR) << "Child not found!";
     NOTREACHED();
     return;
   }
@@ skipping 59 matching lines @@
   }
   // Successfully got a status for |real_pid|.
   if (*status != base::TERMINATION_STATUS_STILL_RUNNING) {
     // Time to forget about this process.
     process_info_map_.erase(real_pid);
   }
   return true;
 }
 
 void Zygote::HandleGetTerminationStatus(int fd,
-                                        const Pickle& pickle,
                                         PickleIterator iter) {
   bool known_dead;
   base::ProcessHandle child_requested;
 
-  if (!pickle.ReadBool(&iter, &known_dead) ||
-      !pickle.ReadInt(&iter, &child_requested)) {
+  if (!iter.ReadBool(&known_dead) || !iter.ReadInt(&child_requested)) {
     LOG(WARNING) << "Error parsing GetTerminationStatus request "
                  << "from browser";
     return;
   }
 
   base::TerminationStatus status;
   int exit_code;
 
   bool got_termination_status =
       GetTerminationStatus(child_requested, known_dead, &status, &exit_code);
@@ skipping 94 matching lines @@
     char buf[kZygoteMaxMessageLength];
     const ssize_t len = UnixDomainSocket::RecvMsg(
         kZygoteSocketPairFd, buf, sizeof(buf), &recv_fds);
     CHECK_GT(len, 0);
     CHECK(recv_fds.empty());
 
     Pickle pickle(buf, len);
     PickleIterator iter(pickle);
 
     int kind;
-    CHECK(pickle.ReadInt(&iter, &kind));
+    CHECK(iter.ReadInt(&kind));
     CHECK(kind == kZygoteCommandForkRealPID);
-    CHECK(pickle.ReadInt(&iter, &real_pid));
+    CHECK(iter.ReadInt(&real_pid));
   }
 
   // Fork failed.
   if (pid < 0) {
     return -1;
   }
 
   // If we successfully forked a child, but it crashed without sending
   // a message to the browser, the browser won't have found its PID.
   if (real_pid < 0) {
@@ skipping 15 matching lines @@
   if (process_info_map_.find(real_pid) != process_info_map_.end()) {
     LOG(ERROR) << "Already tracking PID " << real_pid;
     NOTREACHED();
   }
   process_info_map_[real_pid].internal_pid = pid;
   process_info_map_[real_pid].started_from_helper = helper;
 
   return real_pid;
 }
 
-base::ProcessId Zygote::ReadArgsAndFork(const Pickle& pickle,
-                                        PickleIterator iter,
+base::ProcessId Zygote::ReadArgsAndFork(PickleIterator iter,
                                         ScopedVector<base::ScopedFD> 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;
   const std::string channel_id_prefix = std::string("--")
       + switches::kProcessChannelID + std::string("=");
 
-  if (!pickle.ReadString(&iter, &process_type))
+  if (!iter.ReadString(&process_type))
     return -1;
-  if (!pickle.ReadInt(&iter, &argc))
+  if (!iter.ReadInt(&argc))
     return -1;
 
   for (int i = 0; i < argc; ++i) {
     std::string arg;
-    if (!pickle.ReadString(&iter, &arg))
+    if (!iter.ReadString(&arg))
       return -1;
     args.push_back(arg);
     if (arg.compare(0, channel_id_prefix.length(), channel_id_prefix) == 0)
       channel_id = arg.substr(channel_id_prefix.length());
   }
 
-  if (!pickle.ReadInt(&iter, &numfds))
+  if (!iter.ReadInt(&numfds))
     return -1;
   if (numfds != static_cast<int>(fds.size()))
     return -1;
 
   // First FD is the PID oracle socket.
   if (fds.size() < 1)
     return -1;
   base::ScopedFD pid_oracle(fds[0]->Pass());
 
   // Remaining FDs are for the global descriptor mapping.
   for (int i = 1; i < numfds; ++i) {
     base::GlobalDescriptors::Key key;
-    if (!pickle.ReadUInt32(&iter, &key))
+    if (!iter.ReadUInt32(&key))
       return -1;
     mapping.push_back(std::make_pair(key, fds[i]->get()));
   }
 
   mapping.push_back(std::make_pair(
       static_cast<uint32_t>(kSandboxIPCChannel), GetSandboxFD()));
 
   // Returns twice, once per process.
   base::ProcessId child_pid = ForkWithRealPid(process_type,
                                               mapping,
@@ skipping 24 matching lines @@
     // (we don't have the original argv at this point).
     SetProcessTitleFromCommandLine(NULL);
   } else if (child_pid < 0) {
     LOG(ERROR) << "Zygote could not fork: process_type " << process_type
         << " numfds " << numfds << " child_pid " << child_pid;
   }
   return child_pid;
 }
 
 bool Zygote::HandleForkRequest(int fd,
-                               const Pickle& pickle,
                                PickleIterator iter,
                                ScopedVector<base::ScopedFD> fds) {
   std::string uma_name;
   int uma_sample;
   int uma_boundary_value;
   base::ProcessId child_pid = ReadArgsAndFork(
-      pickle, iter, fds.Pass(), &uma_name, &uma_sample, &uma_boundary_value);
+      iter, fds.Pass(), &uma_name, &uma_sample, &uma_boundary_value);
   if (child_pid == 0)
     return true;
   // If there's no UMA report for this particular fork, then check if any
   // helpers have an initial UMA report for us to send instead.
   while (uma_name.empty() && initial_uma_index_ < helpers_.size()) {
     helpers_[initial_uma_index_++]->InitialUMA(
         &uma_name, &uma_sample, &uma_boundary_value);
   }
   // Must always send reply, as ZygoteHost blocks while waiting for it.
   Pickle reply_pickle;
   reply_pickle.WriteInt(child_pid);
   reply_pickle.WriteString(uma_name);
   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 Zygote::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;
 }
 
 }  // namespace content