IPC::Message -> 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 <stddef.h>
 #include <utility>
 
 #include "cc/output/compositor_frame.h"
 #include "cc/output/filter_operations.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/largest_draw_quad.h"
 #include "cc/quads/render_pass_id.h"
 #include "content/public/common/common_param_traits.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkFlattenableSerialization.h"
 #include "ui/gfx/transform.h"
 
 namespace IPC {
 
-void ParamTraits<cc::FilterOperation>::Write(
-    Message* m, const param_type& p) {
+void ParamTraits<cc::FilterOperation>::Write(base::Pickle* m,
+                                             const param_type& p) {
   WriteParam(m, p.type());
   switch (p.type()) {
     case cc::FilterOperation::GRAYSCALE:
     case cc::FilterOperation::SEPIA:
     case cc::FilterOperation::SATURATE:
     case cc::FilterOperation::HUE_ROTATE:
     case cc::FilterOperation::INVERT:
     case cc::FilterOperation::BRIGHTNESS:
     case cc::FilterOperation::SATURATING_BRIGHTNESS:
     case cc::FilterOperation::CONTRAST:
@@ skipping 16 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,
+bool ParamTraits<cc::FilterOperation>::Read(const base::Pickle* 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))
@@ skipping 106 matching lines @@
     case cc::FilterOperation::REFERENCE:
       LogParam(p.image_filter(), l);
       break;
     case cc::FilterOperation::ALPHA_THRESHOLD:
       NOTREACHED();
       break;
   }
   l->append(")");
 }
 
-void ParamTraits<cc::FilterOperations>::Write(
-    Message* m, const param_type& p) {
+void ParamTraits<cc::FilterOperations>::Write(base::Pickle* 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,
+bool ParamTraits<cc::FilterOperations>::Read(const base::Pickle* 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);
   }
   return true;
 }
 
 void ParamTraits<cc::FilterOperations>::Log(
     const param_type& p, std::string* l) {
   l->append("(");
   for (std::size_t i = 0; i < p.size(); ++i) {
     if (i)
       l->append(", ");
     LogParam(p.at(i), l);
   }
   l->append(")");
 }
 
-void ParamTraits<skia::RefPtr<SkImageFilter> >::Write(
-    Message* m, const param_type& p) {
+void ParamTraits<skia::RefPtr<SkImageFilter>>::Write(base::Pickle* m,
+                                                     const param_type& p) {
   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,
+bool ParamTraits<skia::RefPtr<SkImageFilter>>::Read(const base::Pickle* 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();
   }
   return true;
 }
 
 void ParamTraits<skia::RefPtr<SkImageFilter> >::Log(
     const param_type& p, std::string* l) {
   l->append("(");
   LogParam(p.get() ? p->countInputs() : 0, l);
   l->append(")");
 }
 
-void ParamTraits<gfx::Transform>::Write(
-    Message* m, const param_type& p) {
+void ParamTraits<gfx::Transform>::Write(base::Pickle* m, const param_type& p) {
 #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,
+bool ParamTraits<gfx::Transform>::Read(const base::Pickle* 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) {
 #ifdef SK_MSCALAR_IS_FLOAT
   float row_major_data[16];
   p.matrix().asRowMajorf(row_major_data);
 #else
   double row_major_data[16];
   p.matrix().asRowMajord(row_major_data);
 #endif
   l->append("(");
   for (int i = 0; i < 16; ++i) {
     if (i > 0)
       l->append(", ");
     LogParam(row_major_data[i], l);
   }
   l->append(") ");
 }
 
-void ParamTraits<cc::RenderPass>::Write(
-    Message* m, const param_type& p) {
+void ParamTraits<cc::RenderPass>::Write(base::Pickle* m, const param_type& p) {
   WriteParam(m, p.id);
   WriteParam(m, p.output_rect);
   WriteParam(m, p.damage_rect);
   WriteParam(m, p.transform_to_root_target);
   WriteParam(m, p.has_transparent_background);
   WriteParam(m, p.quad_list.size());
 
   cc::SharedQuadStateList::ConstIterator shared_quad_state_iter =
       p.shared_quad_state_list.begin();
   cc::SharedQuadStateList::ConstIterator last_shared_quad_state_iter =
@@ skipping 72 matching lines @@
   // Shared quad state is only written when a quad contains a shared quad state
   // 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,
+static cc::DrawQuad* ReadDrawQuad(const base::Pickle* m,
                                   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,
+bool ParamTraits<cc::RenderPass>::Read(const base::Pickle* m,
                                        base::PickleIterator* iter,
                                        param_type* p) {
   cc::RenderPassId id;
   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) ||
@@ skipping 146 matching lines @@
 }
 
 namespace {
   enum CompositorFrameType {
     NO_FRAME,
     DELEGATED_FRAME,
     GL_FRAME,
   };
 }
 
-void ParamTraits<cc::CompositorFrame>::Write(Message* m,
+void ParamTraits<cc::CompositorFrame>::Write(base::Pickle* m,
                                              const param_type& p) {
   WriteParam(m, p.metadata);
   if (p.delegated_frame_data) {
     DCHECK(!p.gl_frame_data);
     WriteParam(m, static_cast<int>(DELEGATED_FRAME));
     WriteParam(m, *p.delegated_frame_data);
   } else 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::CompositorFrame>::Read(const Message* m,
+bool ParamTraits<cc::CompositorFrame>::Read(const base::Pickle* m,
                                             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) {
@@ skipping 20 matching lines @@
   l->append("CompositorFrame(");
   LogParam(p.metadata, l);
   l->append(", ");
   if (p.delegated_frame_data)
     LogParam(*p.delegated_frame_data, l);
   else if (p.gl_frame_data)
     LogParam(*p.gl_frame_data, l);
   l->append(")");
 }
 
-void ParamTraits<cc::CompositorFrameAck>::Write(Message* m,
+void ParamTraits<cc::CompositorFrameAck>::Write(base::Pickle* m,
                                                 const param_type& p) {
   WriteParam(m, p.resources);
   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,
+bool ParamTraits<cc::CompositorFrameAck>::Read(const base::Pickle* m,
                                                base::PickleIterator* iter,
                                                param_type* p) {
   if (!ReadParam(m, iter, &p->resources))
     return false;
 
   int compositor_frame_type;
   if (!ReadParam(m, iter, &compositor_frame_type))
     return false;
 
   switch (compositor_frame_type) {
@@ skipping 13 matching lines @@
 void ParamTraits<cc::CompositorFrameAck>::Log(const param_type& p,
                                               std::string* l) {
   l->append("CompositorFrameAck(");
   LogParam(p.resources, l);
   l->append(", ");
   if (p.gl_frame_data)
     LogParam(*p.gl_frame_data, l);
   l->append(")");
 }
 
-void ParamTraits<cc::DelegatedFrameData>::Write(Message* m,
+void ParamTraits<cc::DelegatedFrameData>::Write(base::Pickle* m,
                                                 const param_type& p) {
   DCHECK_NE(0u, p.render_pass_list.size());
 
   size_t to_reserve = sizeof(p.device_scale_factor);
   to_reserve += p.resource_list.size() * sizeof(cc::TransferableResource);
   for (const auto& pass : p.render_pass_list) {
     to_reserve += sizeof(size_t) * 2;
     to_reserve += ReserveSizeForRenderPassWrite(*pass);
   }
   m->Reserve(to_reserve);
 
   WriteParam(m, p.device_scale_factor);
   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,
+bool ParamTraits<cc::DelegatedFrameData>::Read(const base::Pickle* m,
                                                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 38 matching lines @@
   LogParam(p.resource_list, l);
   l->append(", [");
   for (size_t i = 0; i < p.render_pass_list.size(); ++i) {
     if (i)
       l->append(", ");
     LogParam(*p.render_pass_list[i], l);
   }
   l->append("])");
 }
 
-void ParamTraits<cc::DrawQuad::Resources>::Write(Message* m,
+void ParamTraits<cc::DrawQuad::Resources>::Write(base::Pickle* m,
                                                  const param_type& p) {
   DCHECK_LE(p.count, cc::DrawQuad::Resources::kMaxResourceIdCount);
   WriteParam(m, p.count);
   for (size_t i = 0; i < p.count; ++i)
     WriteParam(m, p.ids[i]);
 }
 
-bool ParamTraits<cc::DrawQuad::Resources>::Read(const Message* m,
+bool ParamTraits<cc::DrawQuad::Resources>::Read(const base::Pickle* m,
                                                 base::PickleIterator* iter,
                                                 param_type* p) {
   if (!ReadParam(m, iter, &p->count))
     return false;
   if (p->count > cc::DrawQuad::Resources::kMaxResourceIdCount)
     return false;
   for (size_t i = 0; i < p->count; ++i) {
     if (!ReadParam(m, iter, &p->ids[i]))
       return false;
   }
@@ skipping 12 matching lines @@
 
   for (size_t i = 0; i < p.count; ++i) {
     LogParam(p.ids[i], l);
     if (i < (p.count - 1))
       l->append(", ");
   }
   l->append("])");
 }
 
 void ParamTraits<cc::StreamVideoDrawQuad::OverlayResources>::Write(
-    Message* m,
+    base::Pickle* m,
     const param_type& p) {
   for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) {
     WriteParam(m, p.size_in_pixels[i]);
   }
 }
 
 bool ParamTraits<cc::StreamVideoDrawQuad::OverlayResources>::Read(
-    const Message* m,
+    const base::Pickle* m,
     base::PickleIterator* iter,
     param_type* p) {
   for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) {
     if (!ReadParam(m, iter, &p->size_in_pixels[i]))
       return false;
   }
   return true;
 }
 
 void ParamTraits<cc::StreamVideoDrawQuad::OverlayResources>::Log(
     const param_type& p,
     std::string* l) {
   l->append("StreamVideoDrawQuad::OverlayResources([");
   for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) {
     LogParam(p.size_in_pixels[i], l);
     if (i < (cc::DrawQuad::Resources::kMaxResourceIdCount - 1))
       l->append(", ");
   }
   l->append("])");
 }
 
 void ParamTraits<cc::TextureDrawQuad::OverlayResources>::Write(
-    Message* m,
+    base::Pickle* m,
     const param_type& p) {
   for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) {
     WriteParam(m, p.size_in_pixels[i]);
   }
 }
 
 bool ParamTraits<cc::TextureDrawQuad::OverlayResources>::Read(
-    const Message* m,
+    const base::Pickle* m,
     base::PickleIterator* iter,
     param_type* p) {
   for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) {
     if (!ReadParam(m, iter, &p->size_in_pixels[i]))
       return false;
   }
   return true;
 }
 
 void ParamTraits<cc::TextureDrawQuad::OverlayResources>::Log(
     const param_type& p,
     std::string* l) {
   l->append("TextureDrawQuad::OverlayResources([");
   for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) {
     LogParam(p.size_in_pixels[i], l);
     if (i < (cc::DrawQuad::Resources::kMaxResourceIdCount - 1))
       l->append(", ");
   }
   l->append("])");
 }
 
 }  // namespace IPC