Implement DrawQuad StructTraits

cc/ipc/quads_struct_traits.cc

Index: cc/ipc/quads_struct_traits.cc
diff --git a/cc/ipc/quads_struct_traits.cc b/cc/ipc/quads_struct_traits.cc
new file mode 100644
index 0000000000000000000000000000000000000000..588b7b2ea935851577eebdcc3d8a653fe0b24d69
--- /dev/null
+++ b/cc/ipc/quads_struct_traits.cc
@@ -0,0 +1,263 @@
+// Copyright 2016 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 "cc/ipc/quads_struct_traits.h"
+
+namespace mojo {
+
+namespace {
+
+cc::mojom::Material CCMaterialToMojo(cc::DrawQuad::Material material) {

[yzshen1, 2016/06/15 17:12:12]

You can use EnumTraits to do this now.

[Fady Samuel, 2016/06/15 19:16:00]

Done.

+  switch (material) {
+    case cc::DrawQuad::INVALID:
+      break;
+    case cc::DrawQuad::DEBUG_BORDER:
+      return cc::mojom::Material::DEBUG_BORDER;
+    case cc::DrawQuad::PICTURE_CONTENT:
+      return cc::mojom::Material::PICTURE_CONTENT;
+    case cc::DrawQuad::RENDER_PASS:
+      return cc::mojom::Material::RENDER_PASS;
+    case cc::DrawQuad::SOLID_COLOR:
+      return cc::mojom::Material::SOLID_COLOR;
+    case cc::DrawQuad::STREAM_VIDEO_CONTENT:
+      return cc::mojom::Material::STREAM_VIDEO_CONTENT;
+    case cc::DrawQuad::SURFACE_CONTENT:
+      return cc::mojom::Material::SURFACE_CONTENT;
+    case cc::DrawQuad::TEXTURE_CONTENT:
+      return cc::mojom::Material::TEXTURE_CONTENT;
+    case cc::DrawQuad::TILED_CONTENT:
+      return cc::mojom::Material::TILED_CONTENT;
+    case cc::DrawQuad::YUV_VIDEO_CONTENT:
+      return cc::mojom::Material::YUV_VIDEO_CONTENT;
+  }
+  NOTREACHED();
+  return cc::mojom::Material::YUV_VIDEO_CONTENT;
+}
+
+cc::DrawQuad::Material MojoMaterialToCC(cc::mojom::Material material) {
+  switch (material) {
+    case cc::mojom::Material::DEBUG_BORDER:
+      return cc::DrawQuad::DEBUG_BORDER;
+    case cc::mojom::Material::PICTURE_CONTENT:
+      return cc::DrawQuad::PICTURE_CONTENT;
+    case cc::mojom::Material::RENDER_PASS:
+      return cc::DrawQuad::RENDER_PASS;
+    case cc::mojom::Material::SOLID_COLOR:
+      return cc::DrawQuad::SOLID_COLOR;
+    case cc::mojom::Material::STREAM_VIDEO_CONTENT:
+      return cc::DrawQuad::STREAM_VIDEO_CONTENT;
+    case cc::mojom::Material::SURFACE_CONTENT:
+      return cc::DrawQuad::SURFACE_CONTENT;
+    case cc::mojom::Material::TEXTURE_CONTENT:
+      return cc::DrawQuad::TEXTURE_CONTENT;
+    case cc::mojom::Material::TILED_CONTENT:
+      return cc::DrawQuad::TILED_CONTENT;
+    case cc::mojom::Material::YUV_VIDEO_CONTENT:
+      return cc::DrawQuad::YUV_VIDEO_CONTENT;
+  }
+  NOTREACHED();
+  return cc::DrawQuad::INVALID;
+}
+
+bool ReadDrawQuad(cc::mojom::DrawQuadDataView data, cc::DrawQuad* quad) {
+  quad->material = MojoMaterialToCC(data.material());
+  if (!data.ReadRect(&quad->rect) || !data.ReadOpaqueRect(&quad->opaque_rect) ||
+      !data.ReadVisibleRect(&quad->visible_rect)) {
+    return false;
+  }
+  quad->needs_blending = data.needs_blending();
+  return true;
+}
+
+void AllocateAndConstruct(cc::DrawQuad::Material material, cc::QuadList* list) {
+  switch (material) {
+    case cc::DrawQuad::INVALID:
+      break;
+    case cc::DrawQuad::DEBUG_BORDER:
+      list->AllocateAndConstruct<cc::DebugBorderDrawQuad>();
+      return;
+    case cc::DrawQuad::PICTURE_CONTENT:
+      list->AllocateAndConstruct<cc::PictureDrawQuad>();
+      return;
+    case cc::DrawQuad::RENDER_PASS:
+      list->AllocateAndConstruct<cc::RenderPassDrawQuad>();
+      return;
+    case cc::DrawQuad::SOLID_COLOR:
+      list->AllocateAndConstruct<cc::SolidColorDrawQuad>();
+      return;
+    case cc::DrawQuad::STREAM_VIDEO_CONTENT:
+      list->AllocateAndConstruct<cc::StreamVideoDrawQuad>();
+      return;
+    case cc::DrawQuad::SURFACE_CONTENT:
+      list->AllocateAndConstruct<cc::SurfaceDrawQuad>();
+      return;
+    case cc::DrawQuad::TEXTURE_CONTENT:
+      list->AllocateAndConstruct<cc::TextureDrawQuad>();
+      return;
+    case cc::DrawQuad::TILED_CONTENT:
+      list->AllocateAndConstruct<cc::TileDrawQuad>();
+      return;
+    case cc::DrawQuad::YUV_VIDEO_CONTENT:
+      list->AllocateAndConstruct<cc::YUVVideoDrawQuad>();
+      return;
+  }
+  NOTREACHED();
+}
+
+}  // namespace
+
+// static
+bool StructTraits<cc::mojom::DebugBorderQuadState, cc::DrawQuad>::Read(
+    cc::mojom::DebugBorderQuadStateDataView data,
+    cc::DrawQuad* out) {
+  cc::DebugBorderDrawQuad* quad = static_cast<cc::DebugBorderDrawQuad*>(out);
+  quad->color = data.color();
+  quad->width = data.width();
+  return true;
+}
+
+// static
+bool StructTraits<cc::mojom::RenderPassQuadState, cc::DrawQuad>::Read(
+    cc::mojom::RenderPassQuadStateDataView data,
+    cc::DrawQuad* out) {
+  cc::RenderPassDrawQuad* quad = static_cast<cc::RenderPassDrawQuad*>(out);
+  quad->resources.ids[cc::RenderPassDrawQuad::kMaskResourceIdIndex] =
+      data.mask_resource_id();
+  return data.ReadRenderPassId(&quad->render_pass_id) &&
+         data.ReadMaskUvScale(&quad->mask_uv_scale) &&
+         data.ReadMaskTextureSize(&quad->mask_texture_size) &&
+         data.ReadFilters(&quad->filters) &&
+         data.ReadFiltersScale(&quad->filters_scale) &&
+         data.ReadBackgroundFilters(&quad->background_filters);
+}
+
+// static
+bool StructTraits<cc::mojom::SolidColorQuadState, cc::DrawQuad>::Read(
+    cc::mojom::SolidColorQuadStateDataView data,
+    cc::DrawQuad* out) {
+  cc::SolidColorDrawQuad* quad = static_cast<cc::SolidColorDrawQuad*>(out);
+  quad->force_anti_aliasing_off = data.force_anti_aliasing_off();
+  quad->color = data.color();
+  return true;
+}
+
+// static
+bool StructTraits<cc::mojom::SurfaceQuadState, cc::DrawQuad>::Read(
+    cc::mojom::SurfaceQuadStateDataView data,
+    cc::DrawQuad* out) {
+  cc::SurfaceDrawQuad* quad = static_cast<cc::SurfaceDrawQuad*>(out);
+  return data.ReadSurface(&quad->surface_id);
+}
+
+// static
+bool StructTraits<cc::mojom::TextureQuadState, cc::DrawQuad>::Read(
+    cc::mojom::TextureQuadStateDataView data,
+    cc::DrawQuad* out) {
+  cc::TextureDrawQuad* quad = static_cast<cc::TextureDrawQuad*>(out);
+  quad->resources.ids[cc::TextureDrawQuad::kResourceIdIndex] =
+      data.resource_id();
+  quad->premultiplied_alpha = data.premultiplied_alpha();
+  if (!data.ReadUvTopLeft(&quad->uv_top_left) ||
+      !data.ReadUvBottomRight(&quad->uv_bottom_right)) {
+    return false;
+  }
+  quad->background_color = data.background_color();
+  CArray<float> vertex_opacity_array = {4, 4, &quad->vertex_opacity[0]};
+  if (!data.ReadVertexOpacity(&vertex_opacity_array))
+    return false;
+
+  quad->y_flipped = data.y_flipped();
+  quad->nearest_neighbor = data.nearest_neighbor();
+  quad->secure_output_only = data.secure_output_only();
+  return true;
+}
+
+// static
+bool StructTraits<cc::mojom::TileQuadState, cc::DrawQuad>::Read(
+    cc::mojom::TileQuadStateDataView data,
+    cc::DrawQuad* out) {
+  cc::TileDrawQuad* quad = static_cast<cc::TileDrawQuad*>(out);
+  if (!data.ReadTexCoordRect(&quad->tex_coord_rect) ||
+      !data.ReadTextureSize(&quad->texture_size)) {
+    return false;
+  }
+
+  quad->swizzle_contents = data.swizzle_contents();
+  quad->nearest_neighbor = data.nearest_neighbor();
+  quad->resources.ids[cc::TileDrawQuad::kResourceIdIndex] = data.resource_id();
+  return true;
+}
+
+// static
+cc::mojom::Material StructTraits<cc::mojom::DrawQuad, cc::DrawQuad>::material(
+    const cc::DrawQuad& quad) {
+  return CCMaterialToMojo(quad.material);
+}
+
+// static
+bool StructTraits<cc::mojom::DrawQuad, cc::DrawQuad>::Read(
+    cc::mojom::DrawQuadDataView data,
+    cc::DrawQuad* out) {
+  if (!ReadDrawQuad(data, out))
+    return false;
+  switch (data.material()) {
+    case cc::mojom::Material::DEBUG_BORDER:
+      return data.ReadDebugBorderQuadState(out);
+    case cc::mojom::Material::PICTURE_CONTENT:
+      // TODO(fsamuel): Implement PictureDrawQuad
+      // serialization/deserialization.
+      break;
+    case cc::mojom::Material::RENDER_PASS:
+      return data.ReadRenderPassQuadState(out);
+    case cc::mojom::Material::SOLID_COLOR:
+      return data.ReadSolidColorQuadState(out);
+    case cc::mojom::Material::STREAM_VIDEO_CONTENT:
+      // TODO(fsamuel): Implement StreamVideoContentDrawQuad
+      // serialization/deserialization.
+      break;
+    case cc::mojom::Material::SURFACE_CONTENT:
+      return data.ReadSurfaceQuadState(out);
+    case cc::mojom::Material::TEXTURE_CONTENT:
+      return data.ReadTextureQuadState(out);
+    case cc::mojom::Material::TILED_CONTENT:
+      return data.ReadTileQuadState(out);
+    case cc::mojom::Material::YUV_VIDEO_CONTENT:
+      // TODO(fsamuel): Implement YUVVideoDrawQuad
+      // serialization/deserialization.
+      break;
+  }
+  NOTREACHED();
+  return false;
+}
+
+// static
+mojo::Array<cc::mojom::Material>
+StructTraits<cc::mojom::QuadList, cc::QuadList>::quad_types(

[yzshen1, 2016/06/15 17:12:12]

Please note that this getter will be called multtiple times. So the calculation
of |materials| will be done twice. If that is undesirable, please do it in
SetUpContext().

[Fady Samuel, 2016/06/15 19:15:59]

Done.

+    const cc::QuadList& quad_list) {
+  mojo::Array<cc::mojom::Material> materials =
+      mojo::Array<cc::mojom::Material>::New(quad_list.size());
+  for (size_t i = 0; i < quad_list.size(); ++i)
+    materials[i] = CCMaterialToMojo(quad_list.ElementAt(i)->material);
+  return materials;
+}
+
+// static
+bool StructTraits<cc::mojom::QuadList, cc::QuadList>::Read(
+    cc::mojom::QuadListDataView data,
+    cc::QuadList* out) {
+  // TODO(fsamuel): Once we have ArrayTraits DataViews we can delete
+  // this field. This field exists so we can pre-allocate DrawQuads
+  // in the QuadList according to their material.
+  mojo::Array<cc::mojom::Material> materials;
+  if (!data.ReadQuadTypes(&materials))
+    return false;
+  for (size_t i = 0; i < materials.size(); ++i) {
+    cc::DrawQuad::Material material = MojoMaterialToCC(materials[i]);
+    AllocateAndConstruct(material, out);
+  }

[yzshen1, 2016/06/15 17:12:13]

It should be validated that the |quad_types| list agrees with the actual |quads|
list:
- the size of the two are the same. That could be checked in 
ArrayTraits<QuadListArray>::Resize().
- the types in |quad_types| matches those in |quads|. We can do that by checking
whether a cc::DrawQuad pointer (allocated according to |quad_types|) to a
subclass (determined by |quads|) in
StructTraits<cc::mojom::DebugBorderQuadState, cc::DrawQuad>::Read() and its
siblings.

It is sad that this is so complex. Hope the work of exposing DataView simplifies
it.

WDYT?

[yzshen1, 2016/06/15 17:15:07]

I mean, We can do that by checking whether a cc::DrawQuad pointer (allocated
according to |quad_types|) has the right type before casting it to a subclass
(determined by |quads|) in StructTraits<cc::mojom::DebugBorderQuadState,
cc::DrawQuad>::Read() and its siblings.

[Fady Samuel, 2016/06/15 19:15:59]

I have written the verification just once in ReadDrawQuad.

In AllocateAndConstruct we fill the material field in the DrawQuad. In
ReadDrawQuad we read the material field again but from the quads array. I verify
there that there's a match between the allocated DrawQuad and the one in the
quads array.

+  QuadListArray quad_list_array = {out};
+  return data.ReadQuads(&quad_list_array);
+}
+
+}  // namespace mojo