Change most uses of Pickle to base::Pickle

sandbox/linux/syscall_broker/broker_client.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_client.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/socket.h>
@@ skipping 47 matching lines @@
             pathname, flags, NULL /* file_to_open */,
             NULL /* unlink_after_open */)) {
       return -broker_policy_.denied_errno();
     }
     if (syscall_type == COMMAND_ACCESS &&
         !broker_policy_.GetFileNameIfAllowedToAccess(pathname, flags, NULL)) {
       return -broker_policy_.denied_errno();
     }
   }
 
-  Pickle write_pickle;
+  base::Pickle write_pickle;
   write_pickle.WriteInt(syscall_type);
   write_pickle.WriteString(pathname);
   write_pickle.WriteInt(flags);
   RAW_CHECK(write_pickle.size() <= kMaxMessageLength);
 
   int returned_fd = -1;
   uint8_t reply_buf[kMaxMessageLength];
 
   // Send a request (in write_pickle) as well that will include a new
   // temporary socketpair (created internally by SendRecvMsg()).
   // Then read the reply on this new socketpair in reply_buf and put an
   // eventual attached file descriptor in |returned_fd|.
   ssize_t msg_len = UnixDomainSocket::SendRecvMsgWithFlags(
       ipc_channel_.get(), reply_buf, sizeof(reply_buf), recvmsg_flags,
       &returned_fd, write_pickle);
   if (msg_len <= 0) {
     if (!quiet_failures_for_tests_)
       RAW_LOG(ERROR, "Could not make request to broker process");
     return -ENOMEM;
   }
 
-  Pickle read_pickle(reinterpret_cast<char*>(reply_buf), msg_len);
-  PickleIterator iter(read_pickle);
+  base::Pickle read_pickle(reinterpret_cast<char*>(reply_buf), msg_len);
+  base::PickleIterator iter(read_pickle);
   int return_value = -1;
   // Now deserialize the return value and eventually return the file
   // descriptor.
   if (iter.ReadInt(&return_value)) {
     switch (syscall_type) {
       case COMMAND_ACCESS:
         // We should never have a fd to return.
         RAW_CHECK(returned_fd == -1);
         return return_value;
       case COMMAND_OPEN:
@@ skipping 33 matching lines @@
   return PathAndFlagsSyscall(COMMAND_ACCESS, pathname, mode);
 }
 
 int BrokerClient::Open(const char* pathname, int flags) const {
   return PathAndFlagsSyscall(COMMAND_OPEN, pathname, flags);
 }
 
 }  // namespace syscall_broker
 
 }  // namespace sandbox