Change most uses of Pickle to base::Pickle

content/browser/zygote_host/zygote_host_impl_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/zygote_host_impl_linux.h"
 
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ skipping 203 matching lines @@
   } else {
     // Not using the SUID sandbox.
     // Note that ~base::Process() will reset the internal value, but there's no
     // real "handle" on POSIX so that is safe.
     pid_ = process.Pid();
   }
 
   close(fds[1]);
   control_fd_ = fds[0];
 
-  Pickle pickle;
+  base::Pickle pickle;
   pickle.WriteInt(kZygoteCommandGetSandboxStatus);
   if (!SendMessage(pickle, NULL))
     LOG(FATAL) << "Cannot communicate with zygote";
   // We don't wait for the reply. We'll read it in ReadReply.
 }
 
 void ZygoteHostImpl::TearDownAfterLastChild() {
   bool do_teardown = false;
   {
     base::AutoLock lock(child_tracking_lock_);
@@ skipping 33 matching lines @@
     size_t num_erased = list_of_running_zygote_children_.erase(process);
     DCHECK_EQ(1U, num_erased);
     do_teardown = should_teardown_after_last_child_exits_ &&
                   list_of_running_zygote_children_.empty();
   }
   if (do_teardown) {
     TearDown();
   }
 }
 
-bool ZygoteHostImpl::SendMessage(const Pickle& data,
+bool ZygoteHostImpl::SendMessage(const base::Pickle& data,
                                  const std::vector<int>* fds) {
   DCHECK_NE(-1, control_fd_);
   CHECK(data.size() <= kZygoteMaxMessageLength)
       << "Trying to send too-large message to zygote (sending " << data.size()
       << " bytes, max is " << kZygoteMaxMessageLength << ")";
   CHECK(!fds || fds->size() <= UnixDomainSocket::kMaxFileDescriptors)
       << "Trying to send message with too many file descriptors to zygote "
       << "(sending " << fds->size() << ", max is "
       << UnixDomainSocket::kMaxFileDescriptors << ")";
 
@@ skipping 18 matching lines @@
     UMA_HISTOGRAM_SPARSE_SLOWLY("Linux.SandboxStatus", sandbox_status_);
   }
 
   return HANDLE_EINTR(read(control_fd_, buf, buf_len));
 }
 
 pid_t ZygoteHostImpl::ForkRequest(const std::vector<std::string>& argv,
                                   scoped_ptr<FileDescriptorInfo> mapping,
                                   const std::string& process_type) {
   DCHECK(init_);
-  Pickle pickle;
+  base::Pickle pickle;
 
   int raw_socks[2];
   PCHECK(0 == socketpair(AF_UNIX, SOCK_SEQPACKET, 0, raw_socks));
   base::ScopedFD my_sock(raw_socks[0]);
   base::ScopedFD peer_sock(raw_socks[1]);
   CHECK(UnixDomainSocket::EnableReceiveProcessId(my_sock.get()));
 
   pickle.WriteInt(kZygoteCommandFork);
   pickle.WriteString(process_type);
   pickle.WriteInt(argv.size());
@@ skipping 43 matching lines @@
                       sizeof(kZygoteChildPingMessage))) {
         // Zygote children should still be trustworthy when they're supposed to
         // ping us, so something's broken if we don't receive a valid ping.
         LOG(ERROR) << "Did not receive ping from zygote child";
         NOTREACHED();
         real_pid = -1;
       }
       my_sock.reset();
 
       // Always send PID back to zygote.
-      Pickle pid_pickle;
+      base::Pickle pid_pickle;
       pid_pickle.WriteInt(kZygoteCommandForkRealPID);
       pid_pickle.WriteInt(real_pid);
       if (!SendMessage(pid_pickle, NULL))
         return base::kNullProcessHandle;
     }
 
     // Read the reply, which pickles the PID and an optional UMA enumeration.
     static const unsigned kMaxReplyLength = 2048;
     char buf[kMaxReplyLength];
     const ssize_t len = ReadReply(buf, sizeof(buf));
 
-    Pickle reply_pickle(buf, len);
-    PickleIterator iter(reply_pickle);
+    base::Pickle reply_pickle(buf, len);
+    base::PickleIterator iter(reply_pickle);
     if (len <= 0 || !iter.ReadInt(&pid))
       return base::kNullProcessHandle;
 
     // If there is a nonempty UMA name string, then there is a UMA
     // enumeration to record.
     std::string uma_name;
     int uma_sample;
     int uma_boundary_value;
     if (iter.ReadString(&uma_name) &&
         !uma_name.empty() &&
@@ skipping 101 matching lines @@
       base::EnsureProcessGetsReaped(sandbox_helper_process.Pid());
   } else if (!use_suid_sandbox_for_adj_oom_score_) {
     if (!base::AdjustOOMScore(pid, score))
       PLOG(ERROR) << "Failed to adjust OOM score of renderer with pid " << pid;
   }
 }
 #endif
 
 void ZygoteHostImpl::EnsureProcessTerminated(pid_t process) {
   DCHECK(init_);
-  Pickle pickle;
+  base::Pickle pickle;
 
   pickle.WriteInt(kZygoteCommandReap);
   pickle.WriteInt(process);
   if (!SendMessage(pickle, NULL))
     LOG(ERROR) << "Failed to send Reap message to zygote";
   ZygoteChildDied(process);
 }
 
 base::TerminationStatus ZygoteHostImpl::GetTerminationStatus(
     base::ProcessHandle handle,
     bool known_dead,
     int* exit_code) {
   DCHECK(init_);
-  Pickle pickle;
+  base::Pickle pickle;
   pickle.WriteInt(kZygoteCommandGetTerminationStatus);
   pickle.WriteBool(known_dead);
   pickle.WriteInt(handle);
 
   static const unsigned kMaxMessageLength = 128;
   char buf[kMaxMessageLength];
   ssize_t len;
   {
     base::AutoLock lock(control_lock_);
     if (!SendMessage(pickle, NULL))
       LOG(ERROR) << "Failed to send GetTerminationStatus message to zygote";
     len = ReadReply(buf, sizeof(buf));
   }
 
   // Set this now to handle the error cases.
   if (exit_code)
     *exit_code = RESULT_CODE_NORMAL_EXIT;
   int status = base::TERMINATION_STATUS_NORMAL_TERMINATION;
 
   if (len == -1) {
     LOG(WARNING) << "Error reading message from zygote: " << errno;
   } else if (len == 0) {
     LOG(WARNING) << "Socket closed prematurely.";
   } else {
-    Pickle read_pickle(buf, len);
+    base::Pickle read_pickle(buf, len);
     int tmp_status, tmp_exit_code;
-    PickleIterator iter(read_pickle);
+    base::PickleIterator iter(read_pickle);
     if (!iter.ReadInt(&tmp_status) || !iter.ReadInt(&tmp_exit_code)) {
       LOG(WARNING)
           << "Error parsing GetTerminationStatus response from zygote.";
     } else {
       if (exit_code)
         *exit_code = tmp_exit_code;
       status = tmp_status;
     }
   }
 
@@ skipping 25 matching lines @@
   }
 
   if (!sandbox::Credentials::CanCreateProcessInNewUserNS()) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace content