Change most uses of Pickle to base::Pickle

ppapi/proxy/ppapi_param_traits.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 "ppapi/proxy/ppapi_param_traits.h"
 
 #include <string.h>  // For memcpy
 
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/proxy/ppapi_messages.h"
@@ skipping 18 matching lines @@
 // copy constructor.
 //
 // Since we allocate the inner class when you call the default constructor and
 // transfer the inner class when you do operator=, the entire vector will end
 // up referring to the same inner class. Deserializing into this will just end
 // up overwriting the same item over and over, since all the SerializedVars
 // will refer to the same thing.
 //
 // The solution is to make a new object for each deserialized item, and then
 // add it to the vector one at a time.
-template<typename T>
+template <typename T>
 bool ReadVectorWithoutCopy(const Message* m,
-                           PickleIterator* iter,
+                           base::PickleIterator* iter,
                            std::vector<T>* output) {
   // This part is just a copy of the the default ParamTraits vector Read().
   int size;
   // ReadLength() checks for < 0 itself.
   if (!iter->ReadLength(&size))
     return false;
   // Resizing beforehand is not safe, see BUG 1006367 for details.
   if (INT_MAX / sizeof(T) <= static_cast<size_t>(size))
     return false;
 
@@ skipping 22 matching lines @@
 
 // PP_Bool ---------------------------------------------------------------------
 
 // static
 void ParamTraits<PP_Bool>::Write(Message* m, const param_type& p) {
   ParamTraits<bool>::Write(m, PP_ToBool(p));
 }
 
 // static
 bool ParamTraits<PP_Bool>::Read(const Message* m,
-                                PickleIterator* iter,
+                                base::PickleIterator* iter,
                                 param_type* r) {
   // We specifically want to be strict here about what types of input we accept,
   // which ParamTraits<bool> does for us. We don't want to deserialize "2" into
   // a PP_Bool, for example.
   bool result = false;
   if (!ParamTraits<bool>::Read(m, iter, &result))
     return false;
   *r = PP_FromBool(result);
   return true;
 }
 
 // static
 void ParamTraits<PP_Bool>::Log(const param_type& p, std::string* l) {
 }
 
 // PP_KeyInformation -------------------------------------------------------
 
 // static
 void ParamTraits<PP_KeyInformation>::Write(Message* m, const param_type& p) {
   WriteParam(m, p.key_id_size);
   m->WriteBytes(p.key_id, static_cast<int>(p.key_id_size));
   WriteParam(m, p.key_status);
   WriteParam(m, p.system_code);
 }
 
 // static
 bool ParamTraits<PP_KeyInformation>::Read(const Message* m,
-                                          PickleIterator* iter,
+                                          base::PickleIterator* iter,
                                           param_type* p) {
   uint32_t size;
   if (!ReadParam(m, iter, &size))
     return false;
   if (size > sizeof(p->key_id))
     return false;
   p->key_id_size = size;
 
   const char* data;
   if (!iter->ReadBytes(&data, size))
@@ skipping 24 matching lines @@
 
 // static
 void ParamTraits<PP_NetAddress_Private>::Write(Message* m,
                                                const param_type& p) {
   WriteParam(m, p.size);
   m->WriteBytes(p.data, static_cast<int>(p.size));
 }
 
 // static
 bool ParamTraits<PP_NetAddress_Private>::Read(const Message* m,
-                                              PickleIterator* iter,
+                                              base::PickleIterator* iter,
                                               param_type* p) {
   uint16 size;
   if (!ReadParam(m, iter, &size))
     return false;
   if (size > sizeof(p->data))
     return false;
   p->size = size;
 
   const char* data;
   if (!iter->ReadBytes(&data, size))
@@ skipping 14 matching lines @@
 
 // static
 void ParamTraits<ppapi::HostResource>::Write(Message* m,
                                              const param_type& p) {
   ParamTraits<PP_Instance>::Write(m, p.instance());
   ParamTraits<PP_Resource>::Write(m, p.host_resource());
 }
 
 // static
 bool ParamTraits<ppapi::HostResource>::Read(const Message* m,
-                                            PickleIterator* iter,
+                                            base::PickleIterator* iter,
                                             param_type* r) {
   PP_Instance instance;
   PP_Resource resource;
   if (!ParamTraits<PP_Instance>::Read(m, iter, &instance) ||
       !ParamTraits<PP_Resource>::Read(m, iter, &resource))
     return false;
   r->SetHostResource(instance, resource);
   return true;
 }
 
 // static
 void ParamTraits<ppapi::HostResource>::Log(const param_type& p,
                                            std::string* l) {
 }
 
 // SerializedVar ---------------------------------------------------------------
 
 // static
 void ParamTraits<ppapi::proxy::SerializedVar>::Write(Message* m,
                                                      const param_type& p) {
   p.WriteToMessage(m);
 }
 
 // static
 bool ParamTraits<ppapi::proxy::SerializedVar>::Read(const Message* m,
-                                                    PickleIterator* iter,
+                                                    base::PickleIterator* iter,
                                                     param_type* r) {
   return r->ReadFromMessage(m, iter);
 }
 
 // static
 void ParamTraits<ppapi::proxy::SerializedVar>::Log(const param_type& p,
                                                    std::string* l) {
 }
 
 // std::vector<SerializedVar> --------------------------------------------------
 
 void ParamTraits< std::vector<ppapi::proxy::SerializedVar> >::Write(
     Message* m,
     const param_type& p) {
   WriteVectorWithoutCopy(m, p);
 }
 
 // static
-bool ParamTraits< std::vector<ppapi::proxy::SerializedVar> >::Read(
+bool ParamTraits<std::vector<ppapi::proxy::SerializedVar>>::Read(
     const Message* m,
-    PickleIterator* iter,
+    base::PickleIterator* iter,
     param_type* r) {
   return ReadVectorWithoutCopy(m, iter, r);
 }
 
 // static
 void ParamTraits< std::vector<ppapi::proxy::SerializedVar> >::Log(
     const param_type& p,
     std::string* l) {
 }
 
 // ppapi::PpapiPermissions -----------------------------------------------------
 
 void ParamTraits<ppapi::PpapiPermissions>::Write(Message* m,
                                                  const param_type& p) {
   ParamTraits<uint32_t>::Write(m, p.GetBits());
 }
 
 // static
 bool ParamTraits<ppapi::PpapiPermissions>::Read(const Message* m,
-                                                PickleIterator* iter,
+                                                base::PickleIterator* iter,
                                                 param_type* r) {
   uint32_t bits;
   if (!ParamTraits<uint32_t>::Read(m, iter, &bits))
     return false;
   *r = ppapi::PpapiPermissions(bits);
   return true;
 }
 
 // static
 void ParamTraits<ppapi::PpapiPermissions>::Log(const param_type& p,
@@ skipping 14 matching lines @@
     case ppapi::proxy::SerializedHandle::FILE:
       ParamTraits<IPC::PlatformFileForTransit>::Write(m, p.descriptor());
       break;
     case ppapi::proxy::SerializedHandle::INVALID:
       break;
     // No default so the compiler will warn on new types.
   }
 }
 
 // static
-bool ParamTraits<ppapi::proxy::SerializedHandle>::Read(const Message* m,
-                                                       PickleIterator* iter,
-                                                       param_type* r) {
+bool ParamTraits<ppapi::proxy::SerializedHandle>::Read(
+    const Message* m,
+    base::PickleIterator* iter,
+    param_type* r) {
   ppapi::proxy::SerializedHandle::Header header;
   if (!ppapi::proxy::SerializedHandle::ReadHeader(iter, &header))
     return false;
   switch (header.type) {
     case ppapi::proxy::SerializedHandle::SHARED_MEMORY: {
       base::SharedMemoryHandle handle;
       if (ParamTraits<base::SharedMemoryHandle>::Read(m, iter, &handle)) {
         r->set_shmem(handle, header.size);
         return true;
       }
@@ skipping 37 matching lines @@
   ParamTraits<ppapi::HostResource>::Write(m, p.resource);
   ParamTraits<int64_t>::Write(m, p.bytes_sent);
   ParamTraits<int64_t>::Write(m, p.total_bytes_to_be_sent);
   ParamTraits<int64_t>::Write(m, p.bytes_received);
   ParamTraits<int64_t>::Write(m, p.total_bytes_to_be_received);
 }
 
 // static
 bool ParamTraits<ppapi::proxy::PPBURLLoader_UpdateProgress_Params>::Read(
     const Message* m,
-    PickleIterator* iter,
+    base::PickleIterator* iter,
     param_type* r) {
   return
       ParamTraits<PP_Instance>::Read(m, iter, &r->instance) &&
       ParamTraits<ppapi::HostResource>::Read(m, iter, &r->resource) &&
       ParamTraits<int64_t>::Read(m, iter, &r->bytes_sent) &&
       ParamTraits<int64_t>::Read(m, iter, &r->total_bytes_to_be_sent) &&
       ParamTraits<int64_t>::Read(m, iter, &r->bytes_received) &&
       ParamTraits<int64_t>::Read(m, iter, &r->total_bytes_to_be_received);
 }
 
@@ skipping 25 matching lines @@
   ParamTraits<float>::Write(m, p.transformation[2][1]);
   ParamTraits<float>::Write(m, p.transformation[2][2]);
   ParamTraits<PP_Bool>::Write(m, p.allow_subpixel_aa);
   ParamTraits<std::vector<uint16_t> >::Write(m, p.glyph_indices);
   ParamTraits<std::vector<PP_Point> >::Write(m, p.glyph_advances);
 }
 
 // static
 bool ParamTraits<ppapi::proxy::PPBFlash_DrawGlyphs_Params>::Read(
     const Message* m,
-    PickleIterator* iter,
+    base::PickleIterator* iter,
     param_type* r) {
   return
       ParamTraits<PP_Instance>::Read(m, iter, &r->instance) &&
       ParamTraits<ppapi::HostResource>::Read(m, iter, &r->image_data) &&
       ParamTraits<ppapi::proxy::SerializedFontDescription>::Read(m, iter,
                                                               &r->font_desc) &&
       ParamTraits<uint32_t>::Read(m, iter, &r->color) &&
       ParamTraits<PP_Point>::Read(m, iter, &r->position) &&
       ParamTraits<PP_Rect>::Read(m, iter, &r->clip) &&
       ParamTraits<float>::Read(m, iter, &r->transformation[0][0]) &&
@@ skipping 20 matching lines @@
 // SerializedDirEntry ----------------------------------------------------------
 
 // static
 void ParamTraits<ppapi::proxy::SerializedDirEntry>::Write(Message* m,
                                                           const param_type& p) {
   ParamTraits<std::string>::Write(m, p.name);
   ParamTraits<bool>::Write(m, p.is_dir);
 }
 
 // static
-bool ParamTraits<ppapi::proxy::SerializedDirEntry>::Read(const Message* m,
-                                                         PickleIterator* iter,
-                                                         param_type* r) {
+bool ParamTraits<ppapi::proxy::SerializedDirEntry>::Read(
+    const Message* m,
+    base::PickleIterator* iter,
+    param_type* r) {
   return ParamTraits<std::string>::Read(m, iter, &r->name) &&
          ParamTraits<bool>::Read(m, iter, &r->is_dir);
 }
 
 // static
 void ParamTraits<ppapi::proxy::SerializedDirEntry>::Log(const param_type& p,
                                                         std::string* l) {
 }
 
 // ppapi::proxy::SerializedFontDescription -------------------------------------
 
 // static
 void ParamTraits<ppapi::proxy::SerializedFontDescription>::Write(
     Message* m,
     const param_type& p) {
   ParamTraits<std::string>::Write(m, p.face);
   ParamTraits<int32_t>::Write(m, p.family);
   ParamTraits<uint32_t>::Write(m, p.size);
   ParamTraits<int32_t>::Write(m, p.weight);
   ParamTraits<PP_Bool>::Write(m, p.italic);
   ParamTraits<PP_Bool>::Write(m, p.small_caps);
   ParamTraits<int32_t>::Write(m, p.letter_spacing);
   ParamTraits<int32_t>::Write(m, p.word_spacing);
 }
 
 // static
 bool ParamTraits<ppapi::proxy::SerializedFontDescription>::Read(
     const Message* m,
-    PickleIterator* iter,
+    base::PickleIterator* iter,
     param_type* r) {
   return
       ParamTraits<std::string>::Read(m, iter, &r->face) &&
       ParamTraits<int32_t>::Read(m, iter, &r->family) &&
       ParamTraits<uint32_t>::Read(m, iter, &r->size) &&
       ParamTraits<int32_t>::Read(m, iter, &r->weight) &&
       ParamTraits<PP_Bool>::Read(m, iter, &r->italic) &&
       ParamTraits<PP_Bool>::Read(m, iter, &r->small_caps) &&
       ParamTraits<int32_t>::Read(m, iter, &r->letter_spacing) &&
       ParamTraits<int32_t>::Read(m, iter, &r->word_spacing);
@@ skipping 16 matching lines @@
   ParamTraits<PP_TrueTypeFontFamily_Dev>::Write(m, p.generic_family);
   ParamTraits<PP_TrueTypeFontStyle_Dev>::Write(m, p.style);
   ParamTraits<PP_TrueTypeFontWeight_Dev>::Write(m, p.weight);
   ParamTraits<PP_TrueTypeFontWidth_Dev>::Write(m, p.width);
   ParamTraits<PP_TrueTypeFontCharset_Dev>::Write(m, p.charset);
 }
 
 // static
 bool ParamTraits<ppapi::proxy::SerializedTrueTypeFontDesc>::Read(
     const Message* m,
-    PickleIterator* iter,
+    base::PickleIterator* iter,
     param_type* r) {
   return
       ParamTraits<std::string>::Read(m, iter, &r->family) &&
       ParamTraits<PP_TrueTypeFontFamily_Dev>::Read(m, iter,
                                                    &r->generic_family) &&
       ParamTraits<PP_TrueTypeFontStyle_Dev>::Read(m, iter, &r->style) &&
       ParamTraits<PP_TrueTypeFontWeight_Dev>::Read(m, iter, &r->weight) &&
       ParamTraits<PP_TrueTypeFontWidth_Dev>::Read(m, iter, &r->width) &&
       ParamTraits<PP_TrueTypeFontCharset_Dev>::Read(m, iter, &r->charset);
 }
 
 // static
 void ParamTraits<ppapi::proxy::SerializedTrueTypeFontDesc>::Log(
     const param_type& p,
     std::string* l) {
 }
 
 #if !defined(OS_NACL) && !defined(NACL_WIN64)
 // ppapi::PepperFilePath -------------------------------------------------------
 
 // static
 void ParamTraits<ppapi::PepperFilePath>::Write(Message* m,
                                                const param_type& p) {
   WriteParam(m, static_cast<unsigned>(p.domain()));
   WriteParam(m, p.path());
 }
 
 // static
 bool ParamTraits<ppapi::PepperFilePath>::Read(const Message* m,
-                                              PickleIterator* iter,
+                                              base::PickleIterator* iter,
                                               param_type* p) {
   unsigned domain;
   base::FilePath path;
   if (!ReadParam(m, iter, &domain) || !ReadParam(m, iter, &path))
     return false;
   if (domain > ppapi::PepperFilePath::DOMAIN_MAX_VALID)
     return false;
 
   *p = ppapi::PepperFilePath(
       static_cast<ppapi::PepperFilePath::Domain>(domain), path);
@@ skipping 13 matching lines @@
 // SerializedFlashMenu ---------------------------------------------------------
 
 // static
 void ParamTraits<ppapi::proxy::SerializedFlashMenu>::Write(
     Message* m,
     const param_type& p) {
   p.WriteToMessage(m);
 }
 
 // static
-bool ParamTraits<ppapi::proxy::SerializedFlashMenu>::Read(const Message* m,
-                                                          PickleIterator* iter,
-                                                          param_type* r) {
+bool ParamTraits<ppapi::proxy::SerializedFlashMenu>::Read(
+    const Message* m,
+    base::PickleIterator* iter,
+    param_type* r) {
   return r->ReadFromMessage(m, iter);
 }
 
 // static
 void ParamTraits<ppapi::proxy::SerializedFlashMenu>::Log(const param_type& p,
                                                          std::string* l) {
 }
 #endif  // !defined(OS_NACL) && !defined(NACL_WIN64)
 
 // PPB_X509Certificate_Fields --------------------------------------------------
 
 // static
 void ParamTraits<ppapi::PPB_X509Certificate_Fields>::Write(
     Message* m,
     const param_type& p) {
   ParamTraits<base::ListValue>::Write(m, p.values_);
 }
 
 // static
-bool ParamTraits<ppapi::PPB_X509Certificate_Fields>::Read(const Message* m,
-                                                          PickleIterator* iter,
-                                                          param_type* r) {
+bool ParamTraits<ppapi::PPB_X509Certificate_Fields>::Read(
+    const Message* m,
+    base::PickleIterator* iter,
+    param_type* r) {
   return ParamTraits<base::ListValue>::Read(m, iter, &(r->values_));
 }
 
 // static
 void ParamTraits<ppapi::PPB_X509Certificate_Fields>::Log(const param_type& p,
                                                          std::string* l) {
 }
 
 // ppapi::SocketOptionData -----------------------------------------------------
 
@@ skipping 25 matching lines @@
 
       ParamTraits<int32_t>::Write(m, out_value);
       break;
     }
     // No default so the compiler will warn on new types.
   }
 }
 
 // static
 bool ParamTraits<ppapi::SocketOptionData>::Read(const Message* m,
-                                                PickleIterator* iter,
+                                                base::PickleIterator* iter,
                                                 param_type* r) {
   *r = ppapi::SocketOptionData();
   int32_t type = 0;
   if (!ParamTraits<int32_t>::Read(m, iter, &type))
     return false;
   if (type != ppapi::SocketOptionData::TYPE_INVALID &&
       type != ppapi::SocketOptionData::TYPE_BOOL &&
       type != ppapi::SocketOptionData::TYPE_INT32) {
     return false;
   }
@@ skipping 31 matching lines @@
 void ParamTraits<ppapi::CompositorLayerData::Transform>::Write(
     Message* m,
     const param_type& p) {
   for (size_t i = 0; i < arraysize(p.matrix); i++)
     ParamTraits<float>::Write(m, p.matrix[i]);
 }
 
 // static
 bool ParamTraits<ppapi::CompositorLayerData::Transform>::Read(
     const Message* m,
-    PickleIterator* iter,
+    base::PickleIterator* iter,
     param_type* r) {
   for (size_t i = 0; i < arraysize(r->matrix);i++) {
     if (!ParamTraits<float>::Read(m, iter, &r->matrix[i]))
       return false;
   }
   return true;
 }
 
 void ParamTraits<ppapi::CompositorLayerData::Transform>::Log(
     const param_type& p,
     std::string* l) {
 }
 
 }  // namespace IPC