Change most uses of Pickle to base::Pickle

components/nacl/zygote/nacl_fork_delegate_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 "components/nacl/zygote/nacl_fork_delegate_linux.h"
 
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/resource.h>
 #include <sys/socket.h>
@@ skipping 80 matching lines @@
 #endif
 
 // Send an IPC request on |ipc_channel|. The request is contained in
 // |request_pickle| and can have file descriptors attached in |attached_fds|.
 // |reply_data_buffer| must be allocated by the caller and will contain the
 // reply. The size of the reply will be written to |reply_size|.
 // This code assumes that only one thread can write to |ipc_channel| to make
 // requests.
 bool SendIPCRequestAndReadReply(int ipc_channel,
                                 const std::vector<int>& attached_fds,
-                                const Pickle& request_pickle,
+                                const base::Pickle& request_pickle,
                                 char* reply_data_buffer,
                                 size_t reply_data_buffer_size,
                                 ssize_t* reply_size) {
   DCHECK_LE(static_cast<size_t>(kNaClMaxIPCMessageLength),
             reply_data_buffer_size);
   DCHECK(reply_size);
 
   if (!UnixDomainSocket::SendMsg(ipc_channel, request_pickle.data(),
                                  request_pickle.size(), attached_fds)) {
     LOG(ERROR) << "SendIPCRequestAndReadReply: SendMsg failed";
@@ skipping 248 matching lines @@
   VLOG(1) << "NaClForkDelegate::Fork";
 
   DCHECK(fds.size() == kNumPassedFDs);
 
   if (status_ != kNaClHelperSuccess) {
     LOG(ERROR) << "Cannot launch NaCl process: nacl_helper failed to start";
     return -1;
   }
 
   // First, send a remote fork request.
-  Pickle write_pickle;
+  base::Pickle write_pickle;
   write_pickle.WriteInt(nacl::kNaClForkRequest);
   // TODO(hamaji): When we split the helper binary for non-SFI mode
   // from nacl_helper, stop sending this information.
   write_pickle.WriteBool(nonsfi_mode_);
   write_pickle.WriteString(channel_id);
 
   char reply_buf[kNaClMaxIPCMessageLength];
   ssize_t reply_size = 0;
   bool got_reply =
       SendIPCRequestAndReadReply(fd_, fds, write_pickle,
                                  reply_buf, sizeof(reply_buf), &reply_size);
   if (!got_reply) {
     LOG(ERROR) << "Could not perform remote fork.";
     return -1;
   }
 
   // Now see if the other end managed to fork.
-  Pickle reply_pickle(reply_buf, reply_size);
-  PickleIterator iter(reply_pickle);
+  base::Pickle reply_pickle(reply_buf, reply_size);
+  base::PickleIterator iter(reply_pickle);
   pid_t nacl_child;
   if (!iter.ReadInt(&nacl_child)) {
     LOG(ERROR) << "NaClForkDelegate::Fork: pickle failed";
     return -1;
   }
   VLOG(1) << "nacl_child is " << nacl_child;
   return nacl_child;
 }
 
 bool NaClForkDelegate::GetTerminationStatus(pid_t pid, bool known_dead,
                                             base::TerminationStatus* status,
                                             int* exit_code) {
   VLOG(1) << "NaClForkDelegate::GetTerminationStatus";
   DCHECK(status);
   DCHECK(exit_code);
 
-  Pickle write_pickle;
+  base::Pickle write_pickle;
   write_pickle.WriteInt(nacl::kNaClGetTerminationStatusRequest);
   write_pickle.WriteInt(pid);
   write_pickle.WriteBool(known_dead);
 
   const std::vector<int> empty_fds;
   char reply_buf[kNaClMaxIPCMessageLength];
   ssize_t reply_size = 0;
   bool got_reply =
       SendIPCRequestAndReadReply(fd_, empty_fds, write_pickle,
                                  reply_buf, sizeof(reply_buf), &reply_size);
   if (!got_reply) {
     LOG(ERROR) << "Could not perform remote GetTerminationStatus.";
     return false;
   }
 
-  Pickle reply_pickle(reply_buf, reply_size);
-  PickleIterator iter(reply_pickle);
+  base::Pickle reply_pickle(reply_buf, reply_size);
+  base::PickleIterator iter(reply_pickle);
   int termination_status;
   if (!iter.ReadInt(&termination_status) ||
       termination_status < 0 ||
       termination_status >= base::TERMINATION_STATUS_MAX_ENUM) {
     LOG(ERROR) << "GetTerminationStatus: pickle failed";
     return false;
   }
 
   int remote_exit_code;
   if (!iter.ReadInt(&remote_exit_code)) {
@@ skipping 21 matching lines @@
   pass_through_vars.push_back(kNaClVerbosity);
   pass_through_vars.push_back(sandbox::kSandboxEnvironmentApiRequest);
   for (size_t i = 0; i < pass_through_vars.size(); ++i) {
     std::string temp;
     if (env->GetVar(pass_through_vars[i].c_str(), &temp))
       options->environ[pass_through_vars[i]] = temp;
   }
 }
 
 }  // namespace nacl