IPC::Message -> 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 155 matching lines @@
     graph.push_back(data_[i]->CreatePPVar(instance));
   for (size_t i = 0; i < data_.size(); ++i)
     data_[i]->PopulatePPVar(graph[i], graph);
   // Everything except the root will have one extra ref. Remove that ref.
   for (size_t i = 1; i < data_.size(); ++i)
     ScopedPPVar(ScopedPPVar::PassRef(), graph[i]);
   // The first element is the root.
   return graph[0];
 }
 
-void RawVarDataGraph::Write(IPC::Message* m,
+void RawVarDataGraph::Write(base::Pickle* m,
                             const HandleWriter& handle_writer) {
   // 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,
+scoped_ptr<RawVarDataGraph> RawVarDataGraph::Read(const base::Pickle* m,
                                                   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);
@@ skipping 78 matching lines @@
 }
 
 PP_Var BasicRawVarData::CreatePPVar(PP_Instance instance) {
   return var_;
 }
 
 void BasicRawVarData::PopulatePPVar(const PP_Var& var,
                                     const std::vector<PP_Var>& graph) {
 }
 
-void BasicRawVarData::Write(
-    IPC::Message* m,
-    const HandleWriter& handle_writer) {
+void BasicRawVarData::Write(base::Pickle* m,
+                            const HandleWriter& handle_writer) {
   switch (var_.type) {
     case PP_VARTYPE_UNDEFINED:
     case PP_VARTYPE_NULL:
       // These don't need any data associated with them other than the type we
       // just serialized.
       break;
     case PP_VARTYPE_BOOL:
       m->WriteBool(PP_ToBool(var_.value.as_bool));
       break;
     case PP_VARTYPE_INT32:
       m->WriteInt(var_.value.as_int);
       break;
     case PP_VARTYPE_DOUBLE:
       IPC::WriteParam(m, var_.value.as_double);
       break;
     case PP_VARTYPE_OBJECT:
       m->WriteInt64(var_.value.as_id);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 bool BasicRawVarData::Read(PP_VarType type,
-                           const IPC::Message* m,
+                           const base::Pickle* m,
                            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: {
@@ skipping 45 matching lines @@
 }
 
 PP_Var StringRawVarData::CreatePPVar(PP_Instance instance) {
   return StringVar::SwapValidatedUTF8StringIntoPPVar(&data_);
 }
 
 void StringRawVarData::PopulatePPVar(const PP_Var& var,
                                      const std::vector<PP_Var>& graph) {
 }
 
-void StringRawVarData::Write(IPC::Message* m,
+void StringRawVarData::Write(base::Pickle* m,
                              const HandleWriter& handle_writer) {
   m->WriteString(data_);
 }
 
 bool StringRawVarData::Read(PP_VarType type,
-                            const IPC::Message* m,
+                            const base::Pickle* m,
                             base::PickleIterator* iter) {
   if (!iter->ReadString(&data_))
     return false;
   return true;
 }
 
 // ArrayBufferRawVarData -------------------------------------------------------
 ArrayBufferRawVarData::ArrayBufferRawVarData() {
 }
 
@@ skipping 78 matching lines @@
       return PP_MakeUndefined();
   }
   DCHECK(result.type == PP_VARTYPE_ARRAY_BUFFER);
   return result;
 }
 
 void ArrayBufferRawVarData::PopulatePPVar(const PP_Var& var,
                                           const std::vector<PP_Var>& graph) {
 }
 
-void ArrayBufferRawVarData::Write(
-    IPC::Message* m,
-    const HandleWriter& handle_writer) {
+void ArrayBufferRawVarData::Write(base::Pickle* m,
+                                  const HandleWriter& handle_writer) {
   m->WriteInt(type_);
   switch (type_) {
     case ARRAY_BUFFER_SHMEM_HOST:
       m->WriteInt(host_shm_handle_id_);
       break;
     case ARRAY_BUFFER_SHMEM_PLUGIN:
       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,
+                                 const base::Pickle* m,
                                  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;
@@ skipping 51 matching lines @@
   if (var.type != PP_VARTYPE_ARRAY) {
     NOTREACHED();
     return;
   }
   ArrayVar* array_var = ArrayVar::FromPPVar(var);
   DCHECK(array_var->elements().empty());
   for (size_t i = 0; i < children_.size(); ++i)
     array_var->elements().push_back(ScopedPPVar(graph[children_[i]]));
 }
 
-void ArrayRawVarData::Write(IPC::Message* m,
+void ArrayRawVarData::Write(base::Pickle* 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,
+                           const base::Pickle* m,
                            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);
   }
@@ skipping 34 matching lines @@
   }
   DictionaryVar* dictionary_var = DictionaryVar::FromPPVar(var);
   DCHECK(dictionary_var->key_value_map().empty());
   for (size_t i = 0; i < children_.size(); ++i) {
     bool success = dictionary_var->SetWithStringKey(children_[i].first,
                                                     graph[children_[i].second]);
     DCHECK(success);
   }
 }
 
-void DictionaryRawVarData::Write(
-    IPC::Message* m,
-    const HandleWriter& handle_writer) {
+void DictionaryRawVarData::Write(base::Pickle* m,
+                                 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,
+                                const base::Pickle* m,
                                 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))
@@ skipping 45 matching lines @@
       instance,
       *creation_message_,
       pending_renderer_host_id_,
       pending_browser_host_id_);
 }
 
 void ResourceRawVarData::PopulatePPVar(const PP_Var& var,
                                        const std::vector<PP_Var>& graph) {
 }
 
-void ResourceRawVarData::Write(IPC::Message* m,
+void ResourceRawVarData::Write(base::Pickle* m,
                                const HandleWriter& handle_writer) {
   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::WriteParam(m, *creation_message_);
 }
 
 bool ResourceRawVarData::Read(PP_VarType type,
-                              const IPC::Message* m,
+                              const base::Pickle* m,
                               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::ReadParam(m, iter, creation_message_.get()))
       return false;
   } else {
     creation_message_.reset();
   }
   return true;
 }
 
 }  // namespace proxy
 }  // namespace ppapi