Change most uses of Pickle to base::Pickle

content/common/cc_messages.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 "content/common/cc_messages.h"
 
 #include "cc/output/compositor_frame.h"
 #include "cc/output/filter_operations.h"
 #include "cc/quads/largest_draw_quad.h"
 #include "cc/quads/render_pass_id.h"
@@ skipping 35 matching lines @@
       break;
     case cc::FilterOperation::REFERENCE:
       WriteParam(m, p.image_filter());
       break;
     case cc::FilterOperation::ALPHA_THRESHOLD:
       NOTREACHED();
       break;
   }
 }
 
-bool ParamTraits<cc::FilterOperation>::Read(
-    const Message* m, PickleIterator* iter, param_type* r) {
+bool ParamTraits<cc::FilterOperation>::Read(const Message* m,
+                                            base::PickleIterator* iter,
+                                            param_type* r) {
   cc::FilterOperation::FilterType type;
   float amount;
   gfx::Point drop_shadow_offset;
   SkColor drop_shadow_color;
   SkScalar matrix[20];
   int zoom_inset;
 
   if (!ReadParam(m, iter, &type))
     return false;
   r->set_type(type);
@@ skipping 112 matching lines @@
 }
 
 void ParamTraits<cc::FilterOperations>::Write(
     Message* m, const param_type& p) {
   WriteParam(m, p.size());
   for (std::size_t i = 0; i < p.size(); ++i) {
     WriteParam(m, p.at(i));
   }
 }
 
-bool ParamTraits<cc::FilterOperations>::Read(
-    const Message* m, PickleIterator* iter, param_type* r) {
+bool ParamTraits<cc::FilterOperations>::Read(const Message* m,
+                                             base::PickleIterator* iter,
+                                             param_type* r) {
   size_t count;
   if (!ReadParam(m, iter, &count))
     return false;
 
   for (std::size_t i = 0; i < count; ++i) {
     cc::FilterOperation op = cc::FilterOperation::CreateEmptyFilter();
     if (!ReadParam(m, iter, &op))
       return false;
     r->Append(op);
   }
@@ skipping 16 matching lines @@
   SkImageFilter* filter = p.get();
   if (filter) {
     skia::RefPtr<SkData> data =
         skia::AdoptRef(SkValidatingSerializeFlattenable(filter));
     m->WriteData(static_cast<const char*>(data->data()), data->size());
   } else {
     m->WriteData(0, 0);
   }
 }
 
-bool ParamTraits<skia::RefPtr<SkImageFilter> >::Read(
-    const Message* m, PickleIterator* iter, param_type* r) {
+bool ParamTraits<skia::RefPtr<SkImageFilter>>::Read(const Message* m,
+                                                    base::PickleIterator* iter,
+                                                    param_type* r) {
   const char* data = 0;
   int length = 0;
   if (!iter->ReadData(&data, &length))
     return false;
   if (length > 0) {
     SkFlattenable* flattenable = SkValidatingDeserializeFlattenable(
         data, length, SkImageFilter::GetFlattenableType());
     *r = skia::AdoptRef(static_cast<SkImageFilter*>(flattenable));
   } else {
     r->clear();
@@ skipping 13 matching lines @@
 #ifdef SK_MSCALAR_IS_FLOAT
   float column_major_data[16];
   p.matrix().asColMajorf(column_major_data);
 #else
   double column_major_data[16];
   p.matrix().asColMajord(column_major_data);
 #endif
   m->WriteBytes(&column_major_data, sizeof(SkMScalar) * 16);
 }
 
-bool ParamTraits<gfx::Transform>::Read(
-    const Message* m, PickleIterator* iter, param_type* r) {
+bool ParamTraits<gfx::Transform>::Read(const Message* m,
+                                       base::PickleIterator* iter,
+                                       param_type* r) {
   const char* column_major_data;
   if (!iter->ReadBytes(&column_major_data, sizeof(SkMScalar) * 16))
     return false;
   r->matrix().setColMajor(
       reinterpret_cast<const SkMScalar*>(column_major_data));
   return true;
 }
 
 void ParamTraits<gfx::Transform>::Log(
     const param_type& p, std::string* l) {
@@ skipping 104 matching lines @@
   // that has not been written.
   to_reserve += p.shared_quad_state_list.size() * sizeof(cc::SharedQuadState);
 
   // The largest quad type, verified by a unit test.
   to_reserve += p.quad_list.size() * cc::LargestDrawQuadSize();
   return to_reserve;
 }
 
 template <typename QuadType>
 static cc::DrawQuad* ReadDrawQuad(const Message* m,
-                                  PickleIterator* iter,
+                                  base::PickleIterator* iter,
                                   cc::RenderPass* render_pass) {
   QuadType* quad = render_pass->CreateAndAppendDrawQuad<QuadType>();
   if (!ReadParam(m, iter, quad))
     return NULL;
   return quad;
 }
 
-bool ParamTraits<cc::RenderPass>::Read(
-    const Message* m, PickleIterator* iter, param_type* p) {
+bool ParamTraits<cc::RenderPass>::Read(const Message* m,
+                                       base::PickleIterator* iter,
+                                       param_type* p) {
   cc::RenderPassId id(-1, -1);
   gfx::Rect output_rect;
   gfx::Rect damage_rect;
   gfx::Transform transform_to_root_target;
   bool has_transparent_background;
   size_t quad_list_size;
 
   if (!ReadParam(m, iter, &id) ||
       !ReadParam(m, iter, &output_rect) ||
       !ReadParam(m, iter, &damage_rect) ||
       !ReadParam(m, iter, &transform_to_root_target) ||
       !ReadParam(m, iter, &has_transparent_background) ||
       !ReadParam(m, iter, &quad_list_size))
     return false;
 
   p->SetAll(id,
             output_rect,
             damage_rect,
             transform_to_root_target,
             has_transparent_background);
 
   for (size_t i = 0; i < quad_list_size; ++i) {
     cc::DrawQuad::Material material;
-    PickleIterator temp_iter = *iter;
+    base::PickleIterator temp_iter = *iter;
     if (!ReadParam(m, &temp_iter, &material))
       return false;
 
     cc::DrawQuad* draw_quad = NULL;
     switch (material) {
       case cc::DrawQuad::CHECKERBOARD:
         draw_quad = ReadDrawQuad<cc::CheckerboardDrawQuad>(m, iter, p);
         break;
       case cc::DrawQuad::DEBUG_BORDER:
         draw_quad = ReadDrawQuad<cc::DebugBorderDrawQuad>(m, iter, p);
@@ skipping 149 matching lines @@
     WriteParam(m, *p.gl_frame_data);
   } else if (p.software_frame_data) {
     WriteParam(m, static_cast<int>(SOFTWARE_FRAME));
     WriteParam(m, *p.software_frame_data);
   } else {
     WriteParam(m, static_cast<int>(NO_FRAME));
   }
 }
 
 bool ParamTraits<cc::CompositorFrame>::Read(const Message* m,
-                                            PickleIterator* iter,
+                                            base::PickleIterator* iter,
                                             param_type* p) {
   if (!ReadParam(m, iter, &p->metadata))
     return false;
 
   int compositor_frame_type;
   if (!ReadParam(m, iter, &compositor_frame_type))
     return false;
 
   switch (compositor_frame_type) {
     case DELEGATED_FRAME:
@@ skipping 39 matching lines @@
   WriteParam(m, p.last_software_frame_id);
   if (p.gl_frame_data) {
     WriteParam(m, static_cast<int>(GL_FRAME));
     WriteParam(m, *p.gl_frame_data);
   } else {
     WriteParam(m, static_cast<int>(NO_FRAME));
   }
 }
 
 bool ParamTraits<cc::CompositorFrameAck>::Read(const Message* m,
-                                               PickleIterator* iter,
+                                               base::PickleIterator* iter,
                                                param_type* p) {
   if (!ReadParam(m, iter, &p->resources))
     return false;
 
   if (!ReadParam(m, iter, &p->last_software_frame_id))
     return false;
 
   int compositor_frame_type;
   if (!ReadParam(m, iter, &compositor_frame_type))
     return false;
@@ skipping 41 matching lines @@
   WriteParam(m, p.resource_list);
   WriteParam(m, p.render_pass_list.size());
   for (const auto* pass : p.render_pass_list) {
     WriteParam(m, pass->quad_list.size());
     WriteParam(m, pass->shared_quad_state_list.size());
     WriteParam(m, *pass);
   }
 }
 
 bool ParamTraits<cc::DelegatedFrameData>::Read(const Message* m,
-                                               PickleIterator* iter,
+                                               base::PickleIterator* iter,
                                                param_type* p) {
   if (!ReadParam(m, iter, &p->device_scale_factor))
     return false;
 
   const static size_t kMaxRenderPasses = 10000;
   const static size_t kMaxSharedQuadStateListSize = 100000;
   const static size_t kMaxQuadListSize = 1000000;
 
   std::set<cc::RenderPassId> pass_set;
 
@@ skipping 49 matching lines @@
   DCHECK(cc::SharedBitmap::VerifySizeInBytes(p.size));
 
   m->Reserve(sizeof(cc::SoftwareFrameData));
   WriteParam(m, p.id);
   WriteParam(m, p.size);
   WriteParam(m, p.damage_rect);
   WriteParam(m, p.bitmap_id);
 }
 
 bool ParamTraits<cc::SoftwareFrameData>::Read(const Message* m,
-                                              PickleIterator* iter,
+                                              base::PickleIterator* iter,
                                               param_type* p) {
   if (!ReadParam(m, iter, &p->id))
     return false;
   if (!ReadParam(m, iter, &p->size) ||
       !cc::SharedBitmap::VerifySizeInBytes(p->size))
     return false;
   if (!ReadParam(m, iter, &p->damage_rect))
     return false;
   if (!ReadParam(m, iter, &p->bitmap_id))
     return false;
   return true;
 }
 
 void ParamTraits<cc::SoftwareFrameData>::Log(const param_type& p,
                                              std::string* l) {
   l->append("SoftwareFrameData(");
   LogParam(p.id, l);
   l->append(", ");
   LogParam(p.size, l);
   l->append(", ");
   LogParam(p.damage_rect, l);
   l->append(", ");
   LogParam(p.bitmap_id, l);
   l->append(")");
 }
 
 }  // namespace IPC