Revert of Remove deprecated methods from 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 170 matching lines @@
     m->WriteInt(data_[i]->Type());
     data_[i]->Write(m, handle_writer);
   }
 }
 
 // static
 scoped_ptr<RawVarDataGraph> RawVarDataGraph::Read(const IPC::Message* m,
                                                   PickleIterator* iter) {
   scoped_ptr<RawVarDataGraph> result(new RawVarDataGraph);
   uint32_t size = 0;
-  if (!iter->ReadUInt32(&size))
+  if (!m->ReadUInt32(iter, &size))
     return scoped_ptr<RawVarDataGraph>();
   for (uint32_t i = 0; i < size; ++i) {
     int32_t type;
-    if (!iter->ReadInt(&type))
+    if (!m->ReadInt(iter, &type))
       return scoped_ptr<RawVarDataGraph>();
     PP_VarType var_type = static_cast<PP_VarType>(type);
     result->data_.push_back(RawVarData::Create(var_type));
     if (!result->data_.back()->Read(var_type, m, iter))
       return scoped_ptr<RawVarDataGraph>();
   }
   return result.Pass();
 }
 
 std::vector<SerializedHandle*> RawVarDataGraph::GetHandles() {
@@ skipping 110 matching lines @@
   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;
-      if (!iter->ReadBool(&bool_value))
+      if (!m->ReadBool(iter, &bool_value))
         return false;
       result.value.as_bool = PP_FromBool(bool_value);
       break;
     }
     case PP_VARTYPE_INT32:
-      if (!iter->ReadInt(&result.value.as_int))
+      if (!m->ReadInt(iter, &result.value.as_int))
         return false;
       break;
     case PP_VARTYPE_DOUBLE:
       if (!IPC::ParamTraits<double>::Read(m, iter, &result.value.as_double))
         return false;
       break;
     case PP_VARTYPE_OBJECT:
-      if (!iter->ReadInt64(&result.value.as_id))
+      if (!m->ReadInt64(iter, &result.value.as_id))
         return false;
       break;
     default:
       NOTREACHED();
       return false;
   }
   var_ = result;
   return true;
 }
 
@@ skipping 27 matching lines @@
 }
 
 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) {
-  if (!iter->ReadString(&data_))
+  if (!m->ReadString(iter, &data_))
     return false;
   return true;
 }
 
 // ArrayBufferRawVarData -------------------------------------------------------
 ArrayBufferRawVarData::ArrayBufferRawVarData() {
 }
 
 ArrayBufferRawVarData::~ArrayBufferRawVarData() {
 }
@@ skipping 97 matching lines @@
     case ARRAY_BUFFER_NO_SHMEM:
       m->WriteString(data_);
       break;
   }
 }
 
 bool ArrayBufferRawVarData::Read(PP_VarType type,
                                  const IPC::Message* m,
                                  PickleIterator* iter) {
   int shmem_type;
-  if (!iter->ReadInt(&shmem_type))
+  if (!m->ReadInt(iter, &shmem_type))
     return false;
   type_ = static_cast<ShmemType>(shmem_type);
   switch (type_) {
     case ARRAY_BUFFER_SHMEM_HOST:
-      if (!iter->ReadInt(&host_shm_handle_id_))
+      if (!m->ReadInt(iter, &host_shm_handle_id_))
         return false;
       break;
     case ARRAY_BUFFER_SHMEM_PLUGIN:
       if (!IPC::ParamTraits<SerializedHandle>::Read(
               m, iter, &plugin_shm_handle_)) {
         return false;
       }
       break;
     case ARRAY_BUFFER_NO_SHMEM:
-      if (!iter->ReadString(&data_))
+      if (!m->ReadString(iter, &data_))
         return false;
       break;
     default:
       // We read an invalid ID.
       NOTREACHED();
       return false;
   }
   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->WriteUInt32(static_cast<uint32_t>(children_[i]));
 }
 
 bool ArrayRawVarData::Read(PP_VarType type,
                            const IPC::Message* m,
                            PickleIterator* iter) {
   uint32_t size;
-  if (!iter->ReadUInt32(&size))
+  if (!m->ReadUInt32(iter, &size))
     return false;
   for (uint32_t i = 0; i < size; ++i) {
     uint32_t index;
-    if (!iter->ReadUInt32(&index))
+    if (!m->ReadUInt32(iter, &index))
       return false;
     children_.push_back(index);
   }
   return true;
 }
 
 // DictionaryRawVarData --------------------------------------------------------
 DictionaryRawVarData::DictionaryRawVarData() {
 }
 
@@ skipping 41 matching lines @@
   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) {
   uint32_t size;
-  if (!iter->ReadUInt32(&size))
+  if (!m->ReadUInt32(iter, &size))
     return false;
   for (uint32_t i = 0; i < size; ++i) {
     std::string key;
     uint32_t value;
-    if (!iter->ReadString(&key))
+    if (!m->ReadString(iter, &key))
       return false;
-    if (!iter->ReadUInt32(&value))
+    if (!m->ReadUInt32(iter, &value))
       return false;
     children_.push_back(make_pair(key, value));
   }
   return true;
 }
 
 // ResourceRawVarData ----------------------------------------------------------
 ResourceRawVarData::ResourceRawVarData()
     : pp_resource_(0),
       pending_renderer_host_id_(0),
@@ skipping 49 matching lines @@
   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) {
   int value;
-  if (!iter->ReadInt(&value))
+  if (!m->ReadInt(iter, &value))
     return false;
   pp_resource_ = static_cast<PP_Resource>(value);
-  if (!iter->ReadInt(&pending_renderer_host_id_))
+  if (!m->ReadInt(iter, &pending_renderer_host_id_))
     return false;
-  if (!iter->ReadInt(&pending_browser_host_id_))
+  if (!m->ReadInt(iter, &pending_browser_host_id_))
     return false;
   bool has_creation_message;
-  if (!iter->ReadBool(&has_creation_message))
+  if (!m->ReadBool(iter, &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