Update from https://crrev.com/309717

sandbox/linux/syscall_broker/broker_host.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 "sandbox/linux/syscall_broker/broker_host.h"
 
 #include <fcntl.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/syscall.h>
@@ skipping 92 matching lines @@
     int access_errno = errno;
     if (!access_ret)
       write_pickle->WriteInt(0);
     else
       write_pickle->WriteInt(-access_errno);
   } else {
     write_pickle->WriteInt(-policy.denied_errno());
   }
 }
 
-// Handle a |command_type| request contained in |read_pickle| and send the reply
+// Handle a |command_type| request contained in |iter| and send the reply
 // on |reply_ipc|.
 // Currently COMMAND_OPEN and COMMAND_ACCESS are supported.
 bool HandleRemoteCommand(const BrokerPolicy& policy,
                          IPCCommand command_type,
                          int reply_ipc,
-                         const Pickle& read_pickle,
                          PickleIterator iter) {
   // Currently all commands have two arguments: filename and flags.
   std::string requested_filename;
   int flags = 0;
-  if (!read_pickle.ReadString(&iter, &requested_filename) ||
-      !read_pickle.ReadInt(&iter, &flags)) {
+  if (!iter.ReadString(&requested_filename) || !iter.ReadInt(&flags))
     return false;
-  }
 
   Pickle write_pickle;
   std::vector<int> opened_files;
 
   switch (command_type) {
     case COMMAND_ACCESS:
       AccessFileForIPC(policy, requested_filename, flags, &write_pickle);
       break;
     case COMMAND_OPEN:
       OpenFileForIPC(
@@ skipping 55 matching lines @@
   if (msg_len < 0 || fds.size() != 1 || fds[0]->get() < 0) {
     PLOG(ERROR) << "Error reading message from the client";
     return RequestStatus::FAILURE;
   }
 
   base::ScopedFD temporary_ipc(fds[0]->Pass());
 
   Pickle pickle(buf, msg_len);
   PickleIterator iter(pickle);
   int command_type;
-  if (pickle.ReadInt(&iter, &command_type)) {
+  if (iter.ReadInt(&command_type)) {
     bool command_handled = false;
     // Go through all the possible IPC messages.
     switch (command_type) {
       case COMMAND_ACCESS:
       case COMMAND_OPEN:
         // We reply on the file descriptor sent to us via the IPC channel.
         command_handled = HandleRemoteCommand(
             broker_policy_, static_cast<IPCCommand>(command_type),
-            temporary_ipc.get(), pickle, iter);
+            temporary_ipc.get(), iter);
         break;
       default:
         NOTREACHED();
         break;
     }
 
     if (command_handled) {
       return RequestStatus::SUCCESS;
     } else {
       return RequestStatus::FAILURE;
     }
 
     NOTREACHED();
   }
 
   LOG(ERROR) << "Error parsing IPC request";
   return RequestStatus::FAILURE;
 }
 
 }  // namespace syscall_broker
 
 }  // namespace sandbox