Generate param traits size methods for IPC files in content/ (and traits it depends on).

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 "base/numerics/safe_conversions.h"
 #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 "third_party/skia/include/core/SkImageFilter.h"
 #include "third_party/skia/include/core/SkRefCnt.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:
+    case cc::FilterOperation::HUE_ROTATE:
+    case cc::FilterOperation::INVERT:
+    case cc::FilterOperation::BRIGHTNESS:
+    case cc::FilterOperation::SATURATING_BRIGHTNESS:
+    case cc::FilterOperation::CONTRAST:
+    case cc::FilterOperation::OPACITY:
+    case cc::FilterOperation::BLUR:
+      GetParamSize(s, p.amount());
+      break;
+    case cc::FilterOperation::DROP_SHADOW:
+      GetParamSize(s, p.drop_shadow_offset());
+      GetParamSize(s, p.amount());
+      GetParamSize(s, p.drop_shadow_color());
+      break;
+    case cc::FilterOperation::COLOR_MATRIX:
+      for (int i = 0; i < 20; ++i)
+        GetParamSize(s, p.matrix()[i]);
+      break;
+    case cc::FilterOperation::ZOOM:
+      GetParamSize(s, p.amount());
+      GetParamSize(s, p.zoom_inset());
+      break;
+    case cc::FilterOperation::REFERENCE:
+      GetParamSize(s, p.image_filter());
+      break;
+    case cc::FilterOperation::ALPHA_THRESHOLD:
+      NOTREACHED();
+      break;
+  }
+}
+
 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:
@@ skipping 145 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>::GetSize(base::PickleSizer* s,
+                                                const param_type& p) {
+  GetParamSize(s, base::checked_cast<uint32_t>(p.size()));
+  for (std::size_t i = 0; i < p.size(); ++i) {
+    GetParamSize(s, p.at(i));
+  }
+}
+
 void ParamTraits<cc::FilterOperations>::Write(base::Pickle* m,
                                               const param_type& p) {
   WriteParam(m, base::checked_cast<uint32_t>(p.size()));
   for (std::size_t i = 0; i < p.size(); ++i) {
     WriteParam(m, p.at(i));
   }
 }
 
 bool ParamTraits<cc::FilterOperations>::Read(const base::Pickle* m,
                                              base::PickleIterator* iter,
@@ skipping 15 matching lines @@
     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,
+                                                const param_type& p) {
+  SkImageFilter* filter = p.get();
+  if (filter) {
+    sk_sp<SkData> data(SkValidatingSerializeFlattenable(filter));
+    s->AddData(data->size());
+  } else {
+    s->AddData(0);
+  }
+}
+
 void ParamTraits<sk_sp<SkImageFilter>>::Write(base::Pickle* m,
                                               const param_type& p) {
   SkImageFilter* filter = p.get();
   if (filter) {
     sk_sp<SkData> data(SkValidatingSerializeFlattenable(filter));
     m->WriteData(static_cast<const char*>(data->data()), data->size());
   } else {
     m->WriteData(0, 0);
   }
 }
@@ skipping 468 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>::GetSize(base::PickleSizer* s,
+                                                   const param_type& p) {
+  GetParamSize(s, p.count);
+  for (size_t i = 0; i < p.count; ++i)
+    GetParamSize(s, p.ids[i]);
+}
+
 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 base::Pickle* m,
                                                 base::PickleIterator* iter,
@@ skipping 20 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) {
+  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]);
   }
 }
 
 bool ParamTraits<cc::StreamVideoDrawQuad::OverlayResources>::Read(
     const base::Pickle* m,
@@ skipping 11 matching lines @@
     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>::GetSize(
+    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]);
   }
 }
 
 bool ParamTraits<cc::TextureDrawQuad::OverlayResources>::Read(
     const base::Pickle* m,
@@ skipping 12 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