Move cc ParamTraits to cc/ipc

cc/ipc/cc_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 "content/common/cc_messages.h"
+#include "cc/ipc/cc_param_traits.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/numerics/safe_conversions.h"
+#include "base/time/time.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/filter_operations.h"
+#include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/draw_quad.h"
+#include "cc/quads/io_surface_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 "cc/quads/render_pass_draw_quad.h"
+#include "cc/quads/solid_color_draw_quad.h"
+#include "cc/quads/surface_draw_quad.h"
+#include "cc/quads/tile_draw_quad.h"
+#include "cc/quads/yuv_video_draw_quad.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkFlattenableSerialization.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
+#include "ui/gfx/ipc/geometry/gfx_param_traits.h"
+#include "ui/gfx/ipc/skia/gfx_skia_param_traits.h"
 
 namespace IPC {
 
 void ParamTraits<cc::FilterOperation>::GetSize(base::PickleSizer* s,
                                                const param_type& p) {
   GetParamSize(s, p.type());
   switch (p.type()) {
     case cc::FilterOperation::GRAYSCALE:
     case cc::FilterOperation::SEPIA:
     case cc::FilterOperation::SATURATE:
@@ skipping 113 matching lines @@
         if (!ReadParam(m, iter, &matrix[i]))
           break;
       }
       if (i == 20) {
         r->set_matrix(matrix);
         success = true;
       }
       break;
     }
     case cc::FilterOperation::ZOOM:
-      if (ReadParam(m, iter, &amount) &&
-          ReadParam(m, iter, &zoom_inset) &&
-          amount >= 0.f &&
-          zoom_inset >= 0) {
+      if (ReadParam(m, iter, &amount) && ReadParam(m, iter, &zoom_inset) &&
+          amount >= 0.f && zoom_inset >= 0) {
         r->set_amount(amount);
         r->set_zoom_inset(zoom_inset);
         success = true;
       }
       break;
     case cc::FilterOperation::REFERENCE: {
       sk_sp<SkImageFilter> filter;
       if (!ReadParam(m, iter, &filter)) {
         success = false;
         break;
       }
       r->set_image_filter(std::move(filter));
       success = true;
       break;
     }
     case cc::FilterOperation::ALPHA_THRESHOLD:
       break;
   }
   return success;
 }
 
-void ParamTraits<cc::FilterOperation>::Log(
-    const param_type& p, std::string* l) {
+void ParamTraits<cc::FilterOperation>::Log(const param_type& p,
+                                           std::string* l) {
   l->append("(");
   LogParam(static_cast<unsigned>(p.type()), l);
   l->append(", ");
 
   switch (p.type()) {
     case cc::FilterOperation::GRAYSCALE:
     case cc::FilterOperation::SEPIA:
     case cc::FilterOperation::SATURATE:
     case cc::FilterOperation::HUE_ROTATE:
     case cc::FilterOperation::INVERT:
@@ skipping 58 matching lines @@
 
   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) {
+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<sk_sp<SkImageFilter>>::GetSize(base::PickleSizer* s,
@@ skipping 28 matching lines @@
   if (length > 0) {
     SkFlattenable* flattenable = SkValidatingDeserializeFlattenable(
         data, length, SkImageFilter::GetFlattenableType());
     *r = sk_sp<SkImageFilter>(static_cast<SkImageFilter*>(flattenable));
   } else {
     r->reset();
   }
   return true;
 }
 
-void ParamTraits<sk_sp<SkImageFilter> >::Log(
-    const param_type& p, std::string* l) {
+void ParamTraits<sk_sp<SkImageFilter>>::Log(const param_type& p,
+                                            std::string* l) {
   l->append("(");
   LogParam(p.get() ? p->countInputs() : 0, l);
   l->append(")");
 }
 
 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);
@@ skipping 104 matching lines @@
   bool has_transparent_background;
   uint32_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,
+  p->SetAll(id, output_rect, damage_rect, transform_to_root_target,
             has_transparent_background);
 
   for (uint32_t i = 0; i < quad_list_size; ++i) {
     cc::DrawQuad::Material material;
     base::PickleIterator temp_iter = *iter;
     if (!ReadParam(m, &temp_iter, &material))
       return false;
 
     cc::DrawQuad* draw_quad = NULL;
     switch (material) {
@@ skipping 56 matching lines @@
       if (!ReadParam(m, iter, state))
         return false;
     }
 
     draw_quad->shared_quad_state = p->shared_quad_state_list.back();
   }
 
   return true;
 }
 
-void ParamTraits<cc::RenderPass>::Log(
-    const param_type& p, std::string* l) {
+void ParamTraits<cc::RenderPass>::Log(const param_type& p, std::string* l) {
   l->append("RenderPass((");
   LogParam(p.id, l);
   l->append("), ");
   LogParam(p.output_rect, l);
   l->append(", ");
   LogParam(p.damage_rect, l);
   l->append(", ");
   LogParam(p.transform_to_root_target, l);
   l->append(", ");
   LogParam(p.has_transparent_background, l);
@@ skipping 41 matching lines @@
         LogParam(*cc::YUVVideoDrawQuad::MaterialCast(quad), l);
         break;
       case cc::DrawQuad::INVALID:
         break;
     }
   }
   l->append("])");
 }
 
 namespace {
-  enum CompositorFrameType {
-    NO_FRAME,
-    DELEGATED_FRAME,
-    GL_FRAME,
-  };
+enum CompositorFrameType {
+  NO_FRAME,
+  DELEGATED_FRAME,
+  GL_FRAME,
+};
 }
 
 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) {
@@ skipping 100 matching lines @@
     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, base::checked_cast<uint32_t>(p.render_pass_list.size()));
   for (const auto& pass : p.render_pass_list) {
     WriteParam(m, base::checked_cast<uint32_t>(pass->quad_list.size()));
-    WriteParam(m, base::checked_cast<uint32_t>(
-        pass->shared_quad_state_list.size()));
+    WriteParam(
+        m, base::checked_cast<uint32_t>(pass->shared_quad_state_list.size()));
     WriteParam(m, *pass);
   }
 }
 
 bool ParamTraits<cc::DelegatedFrameData>::Read(const base::Pickle* m,
                                                base::PickleIterator* iter,
                                                param_type* p) {
+  const size_t kMaxRenderPasses = 10000;
+  const size_t kMaxSharedQuadStateListSize = 100000;
+  const size_t kMaxQuadListSize = 1000000;
+
   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;
 
   uint32_t num_render_passes;
   if (!ReadParam(m, iter, &p->resource_list) ||
       !ReadParam(m, iter, &num_render_passes) ||
       num_render_passes > kMaxRenderPasses || num_render_passes == 0)
     return false;
   for (uint32_t i = 0; i < num_render_passes; ++i) {
     uint32_t quad_list_size;
     uint32_t shared_quad_state_list_size;
@@ skipping 78 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>::GetSize(
-    base::PickleSizer* s, const param_type& p) {
+    base::PickleSizer* s,
+    const param_type& p) {
   for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) {
     GetParamSize(s, p.size_in_pixels[i]);
   }
 }
 
 void ParamTraits<cc::StreamVideoDrawQuad::OverlayResources>::Write(
     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]);
@@ skipping 17 matching lines @@
   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>::GetSize(
-    base::PickleSizer* s, const param_type& p) {
+    base::PickleSizer* s,
+    const param_type& p) {
   for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) {
     GetParamSize(s, p.size_in_pixels[i]);
   }
 }
 
 void ParamTraits<cc::TextureDrawQuad::OverlayResources>::Write(
     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]);
@@ skipping 17 matching lines @@
   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
+
+// Generate param traits size methods.
+#include "ipc/param_traits_size_macros.h"
+namespace IPC {
+#undef CC_IPC_CC_PARAM_TRAITS_MACROS_H_
+#include "cc/ipc/cc_param_traits_macros.h"
+}
+
+// Generate param traits write methods.
+#include "ipc/param_traits_write_macros.h"
+namespace IPC {
+#undef CC_IPC_CC_PARAM_TRAITS_MACROS_H_
+#include "cc/ipc/cc_param_traits_macros.h"
+}  // namespace IPC
+
+// Generate param traits read methods.
+#include "ipc/param_traits_read_macros.h"
+namespace IPC {
+#undef CC_IPC_CC_PARAM_TRAITS_MACROS_H_
+#include "cc/ipc/cc_param_traits_macros.h"
+}  // namespace IPC
+
+// Generate param traits log methods.
+#include "ipc/param_traits_log_macros.h"
+namespace IPC {
+#undef CC_IPC_CC_PARAM_TRAITS_MACROS_H_
+#include "cc/ipc/cc_param_traits_macros.h"
+}  // namespace IPC