Change most uses of Pickle to base::Pickle

ppapi/proxy/raw_var_data.cc

 // Copyright (c) 2013 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 "ppapi/proxy/raw_var_data.h"
 
 #include <stack>
 
 #include "base/containers/hash_tables.h"
 #include "base/stl_util.h"
@@ skipping 167 matching lines @@
   // Write the size, followed by each node in the graph.
   m->WriteUInt32(static_cast<uint32_t>(data_.size()));
   for (size_t i = 0; i < data_.size(); ++i) {
     m->WriteInt(data_[i]->Type());
     data_[i]->Write(m, handle_writer);
   }
 }
 
 // static
 scoped_ptr<RawVarDataGraph> RawVarDataGraph::Read(const IPC::Message* m,
-                                                  PickleIterator* iter) {
+                                                  base::PickleIterator* iter) {
   scoped_ptr<RawVarDataGraph> result(new RawVarDataGraph);
   uint32_t size = 0;
   if (!iter->ReadUInt32(&size))
     return scoped_ptr<RawVarDataGraph>();
   for (uint32_t i = 0; i < size; ++i) {
     int32_t type;
     if (!iter->ReadInt(&type))
       return scoped_ptr<RawVarDataGraph>();
     PP_VarType var_type = static_cast<PP_VarType>(type);
     result->data_.push_back(RawVarData::Create(var_type));
@@ skipping 106 matching lines @@
       m->WriteInt64(var_.value.as_id);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 bool BasicRawVarData::Read(PP_VarType type,
                            const IPC::Message* m,
-                           PickleIterator* iter) {
+                           base::PickleIterator* iter) {
   PP_Var result;
   result.type = type;
   switch (type) {
     case PP_VARTYPE_UNDEFINED:
     case PP_VARTYPE_NULL:
       // These don't have any data associated with them other than the type we
       // just deserialized.
       break;
     case PP_VARTYPE_BOOL: {
       bool bool_value;
@@ skipping 51 matching lines @@
                                      const std::vector<PP_Var>& graph) {
 }
 
 void StringRawVarData::Write(IPC::Message* m,
                              const HandleWriter& handle_writer) {
   m->WriteString(data_);
 }
 
 bool StringRawVarData::Read(PP_VarType type,
                             const IPC::Message* m,
-                            PickleIterator* iter) {
+                            base::PickleIterator* iter) {
   if (!iter->ReadString(&data_))
     return false;
   return true;
 }
 
 // ArrayBufferRawVarData -------------------------------------------------------
 ArrayBufferRawVarData::ArrayBufferRawVarData() {
 }
 
 ArrayBufferRawVarData::~ArrayBufferRawVarData() {
@@ skipping 96 matching lines @@
       handle_writer.Run(m, plugin_shm_handle_);
       break;
     case ARRAY_BUFFER_NO_SHMEM:
       m->WriteString(data_);
       break;
   }
 }
 
 bool ArrayBufferRawVarData::Read(PP_VarType type,
                                  const IPC::Message* m,
-                                 PickleIterator* iter) {
+                                 base::PickleIterator* iter) {
   int shmem_type;
   if (!iter->ReadInt(&shmem_type))
     return false;
   type_ = static_cast<ShmemType>(shmem_type);
   switch (type_) {
     case ARRAY_BUFFER_SHMEM_HOST:
       if (!iter->ReadInt(&host_shm_handle_id_))
         return false;
       break;
     case ARRAY_BUFFER_SHMEM_PLUGIN:
@@ skipping 60 matching lines @@
 
 void ArrayRawVarData::Write(IPC::Message* m,
                             const HandleWriter& handle_writer) {
   m->WriteUInt32(static_cast<uint32_t>(children_.size()));
   for (size_t i = 0; i < children_.size(); ++i)
     m->WriteUInt32(static_cast<uint32_t>(children_[i]));
 }
 
 bool ArrayRawVarData::Read(PP_VarType type,
                            const IPC::Message* m,
-                           PickleIterator* iter) {
+                           base::PickleIterator* iter) {
   uint32_t size;
   if (!iter->ReadUInt32(&size))
     return false;
   for (uint32_t i = 0; i < size; ++i) {
     uint32_t index;
     if (!iter->ReadUInt32(&index))
       return false;
     children_.push_back(index);
   }
   return true;
@@ skipping 45 matching lines @@
     const HandleWriter& handle_writer) {
   m->WriteUInt32(static_cast<uint32_t>(children_.size()));
   for (size_t i = 0; i < children_.size(); ++i) {
     m->WriteString(children_[i].first);
     m->WriteUInt32(static_cast<uint32_t>(children_[i].second));
   }
 }
 
 bool DictionaryRawVarData::Read(PP_VarType type,
                                 const IPC::Message* m,
-                                PickleIterator* iter) {
+                                base::PickleIterator* iter) {
   uint32_t size;
   if (!iter->ReadUInt32(&size))
     return false;
   for (uint32_t i = 0; i < size; ++i) {
     std::string key;
     uint32_t value;
     if (!iter->ReadString(&key))
       return false;
     if (!iter->ReadUInt32(&value))
       return false;
@@ skipping 56 matching lines @@
   m->WriteInt(static_cast<int>(pp_resource_));
   m->WriteInt(pending_renderer_host_id_);
   m->WriteInt(pending_browser_host_id_);
   m->WriteBool(creation_message_);
   if (creation_message_)
     IPC::ParamTraits<IPC::Message>::Write(m, *creation_message_);
 }
 
 bool ResourceRawVarData::Read(PP_VarType type,
                               const IPC::Message* m,
-                              PickleIterator* iter) {
+                              base::PickleIterator* iter) {
   int value;
   if (!iter->ReadInt(&value))
     return false;
   pp_resource_ = static_cast<PP_Resource>(value);
   if (!iter->ReadInt(&pending_renderer_host_id_))
     return false;
   if (!iter->ReadInt(&pending_browser_host_id_))
     return false;
   bool has_creation_message;
   if (!iter->ReadBool(&has_creation_message))
     return false;
   if (has_creation_message) {
     creation_message_.reset(new IPC::Message());
     if (!IPC::ParamTraits<IPC::Message>::Read(m, iter, creation_message_.get()))
       return false;
   } else {
     creation_message_.reset();
   }
   return true;
 }
 
 }  // namespace proxy
 }  // namespace ppapi