Convert the pp::proxy namespace to the ppapi::proxy namespace.

ppapi/proxy/ppapi_param_traits.cc

 // Copyright (c) 2011 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_file_info.h"
 #include "ppapi/c/pp_resource.h"
@@ skipping 175 matching lines @@
   return true;
 }
 
 // static
 void ParamTraits<PP_ObjectProperty>::Log(const param_type& p, std::string* l) {
 }
 
 // PPBFlash_DrawGlyphs_Params --------------------------------------------------
 
 // static
-void ParamTraits<pp::proxy::PPBFlash_DrawGlyphs_Params>::Write(
+void ParamTraits<ppapi::proxy::PPBFlash_DrawGlyphs_Params>::Write(
     Message* m,
     const param_type& p) {
   ParamTraits<PP_Instance>::Write(m, p.instance);
   ParamTraits<ppapi::HostResource>::Write(m, p.image_data);
-  ParamTraits<pp::proxy::SerializedFontDescription>::Write(m, p.font_desc);
+  ParamTraits<ppapi::proxy::SerializedFontDescription>::Write(m, p.font_desc);
   ParamTraits<uint32_t>::Write(m, p.color);
   ParamTraits<PP_Point>::Write(m, p.position);
   ParamTraits<PP_Rect>::Write(m, p.clip);
   ParamTraits<float>::Write(m, p.transformation[0][0]);
   ParamTraits<float>::Write(m, p.transformation[0][1]);
   ParamTraits<float>::Write(m, p.transformation[0][2]);
   ParamTraits<float>::Write(m, p.transformation[1][0]);
   ParamTraits<float>::Write(m, p.transformation[1][1]);
   ParamTraits<float>::Write(m, p.transformation[1][2]);
   ParamTraits<float>::Write(m, p.transformation[2][0]);
   ParamTraits<float>::Write(m, p.transformation[2][1]);
   ParamTraits<float>::Write(m, p.transformation[2][2]);
   ParamTraits<std::vector<uint16_t> >::Write(m, p.glyph_indices);
   ParamTraits<std::vector<PP_Point> >::Write(m, p.glyph_advances);
 }
 
 // static
-bool ParamTraits<pp::proxy::PPBFlash_DrawGlyphs_Params>::Read(
+bool ParamTraits<ppapi::proxy::PPBFlash_DrawGlyphs_Params>::Read(
     const Message* m,
     void** iter,
     param_type* r) {
   return
       ParamTraits<PP_Instance>::Read(m, iter, &r->instance) &&
       ParamTraits<ppapi::HostResource>::Read(m, iter, &r->image_data) &&
-      ParamTraits<pp::proxy::SerializedFontDescription>::Read(m, iter,
+      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]) &&
       ParamTraits<float>::Read(m, iter, &r->transformation[0][1]) &&
       ParamTraits<float>::Read(m, iter, &r->transformation[0][2]) &&
       ParamTraits<float>::Read(m, iter, &r->transformation[1][0]) &&
       ParamTraits<float>::Read(m, iter, &r->transformation[1][1]) &&
       ParamTraits<float>::Read(m, iter, &r->transformation[1][2]) &&
       ParamTraits<float>::Read(m, iter, &r->transformation[2][0]) &&
       ParamTraits<float>::Read(m, iter, &r->transformation[2][1]) &&
       ParamTraits<float>::Read(m, iter, &r->transformation[2][2]) &&
       ParamTraits<std::vector<uint16_t> >::Read(m, iter, &r->glyph_indices) &&
       ParamTraits<std::vector<PP_Point> >::Read(m, iter, &r->glyph_advances) &&
       r->glyph_indices.size() == r->glyph_advances.size();
 }
 
 // static
-void ParamTraits<pp::proxy::PPBFlash_DrawGlyphs_Params>::Log(
+void ParamTraits<ppapi::proxy::PPBFlash_DrawGlyphs_Params>::Log(
     const param_type& p,
     std::string* l) {
 }
 
 // PPBFileRef_CreateInfo -------------------------------------------------------
 
 // static
-void ParamTraits<pp::proxy::PPBFileRef_CreateInfo>::Write(
+void ParamTraits<ppapi::proxy::PPBFileRef_CreateInfo>::Write(
     Message* m,
     const param_type& p) {
   ParamTraits<ppapi::HostResource>::Write(m, p.resource);
   ParamTraits<int>::Write(m, p.file_system_type);
-  ParamTraits<pp::proxy::SerializedVar>::Write(m, p.path);
-  ParamTraits<pp::proxy::SerializedVar>::Write(m, p.name);
+  ParamTraits<ppapi::proxy::SerializedVar>::Write(m, p.path);
+  ParamTraits<ppapi::proxy::SerializedVar>::Write(m, p.name);
 }
 
 // static
-bool ParamTraits<pp::proxy::PPBFileRef_CreateInfo>::Read(const Message* m,
-                                                         void** iter,
-                                                         param_type* r) {
+bool ParamTraits<ppapi::proxy::PPBFileRef_CreateInfo>::Read(const Message* m,
+                                                            void** iter,
+                                                            param_type* r) {
   return
       ParamTraits<ppapi::HostResource>::Read(m, iter, &r->resource) &&
       ParamTraits<int>::Read(m, iter, &r->file_system_type) &&
-      ParamTraits<pp::proxy::SerializedVar>::Read(m, iter, &r->path) &&
-      ParamTraits<pp::proxy::SerializedVar>::Read(m, iter, &r->name);
+      ParamTraits<ppapi::proxy::SerializedVar>::Read(m, iter, &r->path) &&
+      ParamTraits<ppapi::proxy::SerializedVar>::Read(m, iter, &r->name);
 }
 
 // static
-void ParamTraits<pp::proxy::PPBFileRef_CreateInfo>::Log(
+void ParamTraits<ppapi::proxy::PPBFileRef_CreateInfo>::Log(
     const param_type& p,
     std::string* l) {
 }
 
 // PPBURLLoader_UpdateProgress_Params ------------------------------------------
 
 // static
-void ParamTraits<pp::proxy::PPBURLLoader_UpdateProgress_Params>::Write(
+void ParamTraits<ppapi::proxy::PPBURLLoader_UpdateProgress_Params>::Write(
     Message* m,
     const param_type& p) {
   ParamTraits<PP_Instance>::Write(m, p.instance);
   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<pp::proxy::PPBURLLoader_UpdateProgress_Params>::Read(
+bool ParamTraits<ppapi::proxy::PPBURLLoader_UpdateProgress_Params>::Read(
     const Message* m,
     void** 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);
 }
 
 // static
-void ParamTraits<pp::proxy::PPBURLLoader_UpdateProgress_Params>::Log(
+void ParamTraits<ppapi::proxy::PPBURLLoader_UpdateProgress_Params>::Log(
     const param_type& p,
     std::string* l) {
 }
 
 // SerializedDirEntry ----------------------------------------------------------
 
 // static
-void ParamTraits<pp::proxy::SerializedDirEntry>::Write(Message* m,
-                                                       const param_type& p) {
+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<pp::proxy::SerializedDirEntry>::Read(const Message* m,
-                                                      void** iter,
-                                                      param_type* r) {
+bool ParamTraits<ppapi::proxy::SerializedDirEntry>::Read(const Message* m,
+                                                         void** iter,
+                                                         param_type* r) {
   return ParamTraits<std::string>::Read(m, iter, &r->name) &&
          ParamTraits<bool>::Read(m, iter, &r->is_dir);
 }
 
 // static
-void ParamTraits<pp::proxy::SerializedDirEntry>::Log(const param_type& p,
-                                                     std::string* l) {
+void ParamTraits<ppapi::proxy::SerializedDirEntry>::Log(const param_type& p,
+                                                        std::string* l) {
 }
 
-// pp::proxy::SerializedFontDescription ----------------------------------------
+// ppapi::proxy::SerializedFontDescription -------------------------------------
 
 // static
-void ParamTraits<pp::proxy::SerializedFontDescription>::Write(
+void ParamTraits<ppapi::proxy::SerializedFontDescription>::Write(
     Message* m,
     const param_type& p) {
-  ParamTraits<pp::proxy::SerializedVar>::Write(m, p.face);
+  ParamTraits<ppapi::proxy::SerializedVar>::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<pp::proxy::SerializedFontDescription>::Read(
+bool ParamTraits<ppapi::proxy::SerializedFontDescription>::Read(
     const Message* m,
     void** iter,
     param_type* r) {
   return
-      ParamTraits<pp::proxy::SerializedVar>::Read(m, iter, &r->face) &&
+      ParamTraits<ppapi::proxy::SerializedVar>::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);
 }
 
 // static
-void ParamTraits<pp::proxy::SerializedFontDescription>::Log(
+void ParamTraits<ppapi::proxy::SerializedFontDescription>::Log(
     const param_type& p,
     std::string* l) {
 }
 
 // HostResource ----------------------------------------------------------------
 
 // static
 void ParamTraits<ppapi::HostResource>::Write(Message* m,
                                              const param_type& p) {
   ParamTraits<PP_Instance>::Write(m, p.instance());
@@ skipping 14 matching lines @@
 }
 
 // static
 void ParamTraits<ppapi::HostResource>::Log(const param_type& p,
                                            std::string* l) {
 }
 
 // SerializedVar ---------------------------------------------------------------
 
 // static
-void ParamTraits<pp::proxy::SerializedVar>::Write(Message* m,
-                                                  const param_type& p) {
+void ParamTraits<ppapi::proxy::SerializedVar>::Write(Message* m,
+                                                     const param_type& p) {
   p.WriteToMessage(m);
 }
 
 // static
-bool ParamTraits<pp::proxy::SerializedVar>::Read(const Message* m,
-                                                 void** iter,
-                                                 param_type* r) {
+bool ParamTraits<ppapi::proxy::SerializedVar>::Read(const Message* m,
+                                                    void** iter,
+                                                    param_type* r) {
   return r->ReadFromMessage(m, iter);
 }
 
 // static
-void ParamTraits<pp::proxy::SerializedVar>::Log(const param_type& p,
-                                                std::string* l) {
+void ParamTraits<ppapi::proxy::SerializedVar>::Log(const param_type& p,
+                                                   std::string* l) {
 }
 
 // std::vector<SerializedVar> --------------------------------------------------
 
-void ParamTraits< std::vector<pp::proxy::SerializedVar> >::Write(
+void ParamTraits< std::vector<ppapi::proxy::SerializedVar> >::Write(
     Message* m,
     const param_type& p) {
   WriteVectorWithoutCopy(m, p);
 }
 
 // static
-bool ParamTraits< std::vector<pp::proxy::SerializedVar> >::Read(
+bool ParamTraits< std::vector<ppapi::proxy::SerializedVar> >::Read(
     const Message* m,
     void** iter,
     param_type* r) {
   return ReadVectorWithoutCopy(m, iter, r);
 }
 
 // static
-void ParamTraits< std::vector<pp::proxy::SerializedVar> >::Log(
+void ParamTraits< std::vector<ppapi::proxy::SerializedVar> >::Log(
     const param_type& p,
     std::string* l) {
 }
 
 // std::vector<PPBFileRef_CreateInfo> ------------------------------------------
 
-void ParamTraits< std::vector<pp::proxy::PPBFileRef_CreateInfo> >::Write(
+void ParamTraits< std::vector<ppapi::proxy::PPBFileRef_CreateInfo> >::Write(
     Message* m,
     const param_type& p) {
   WriteVectorWithoutCopy(m, p);
 }
 
 // static
-bool ParamTraits< std::vector<pp::proxy::PPBFileRef_CreateInfo> >::Read(
+bool ParamTraits< std::vector<ppapi::proxy::PPBFileRef_CreateInfo> >::Read(
     const Message* m,
     void** iter,
     param_type* r) {
   return ReadVectorWithoutCopy(m, iter, r);
 }
 
 // static
-void ParamTraits< std::vector<pp::proxy::PPBFileRef_CreateInfo> >::Log(
+void ParamTraits< std::vector<ppapi::proxy::PPBFileRef_CreateInfo> >::Log(
     const param_type& p,
     std::string* l) {
 }
 
 // SerializedFlashMenu ---------------------------------------------------------
 
 // static
-void ParamTraits<pp::proxy::SerializedFlashMenu>::Write(Message* m,
-                                                        const param_type& p) {
+void ParamTraits<ppapi::proxy::SerializedFlashMenu>::Write(
+    Message* m,
+    const param_type& p) {
   p.WriteToMessage(m);
 }
 
 // static
-bool ParamTraits<pp::proxy::SerializedFlashMenu>::Read(const Message* m,
-                                                       void** iter,
-                                                       param_type* r) {
+bool ParamTraits<ppapi::proxy::SerializedFlashMenu>::Read(const Message* m,
+                                                          void** iter,
+                                                          param_type* r) {
   return r->ReadFromMessage(m, iter);
 }
 
 // static
-void ParamTraits<pp::proxy::SerializedFlashMenu>::Log(const param_type& p,
-                                                      std::string* l) {
+void ParamTraits<ppapi::proxy::SerializedFlashMenu>::Log(const param_type& p,
+                                                         std::string* l) {
 }
 
 }  // namespace IPC