Implement DrawQuad StructTraits

cc/ipc/quads_struct_traits.h

+// 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.
+
+#ifndef CC_IPC_QUADS_STRUCT_TRAITS_H_
+#define CC_IPC_QUADS_STRUCT_TRAITS_H_
+
+#include "cc/ipc/filter_operation_struct_traits.h"
+#include "cc/ipc/filter_operations_struct_traits.h"
+#include "cc/ipc/quads.mojom.h"
+#include "cc/ipc/render_pass_id_struct_traits.h"
+#include "cc/ipc/surface_id_struct_traits.h"
+#include "cc/quads/debug_border_draw_quad.h"
+#include "cc/quads/picture_draw_quad.h"
+#include "cc/quads/render_pass_draw_quad.h"
+#include "cc/quads/solid_color_draw_quad.h"
+#include "cc/quads/stream_video_draw_quad.h"
+#include "cc/quads/surface_draw_quad.h"
+#include "cc/quads/texture_draw_quad.h"
+#include "cc/quads/tile_draw_quad.h"
+#include "cc/quads/yuv_video_draw_quad.h"
+#include "ui/gfx/geometry/mojo/geometry_struct_traits.h"
+
+namespace mojo {
+
+template <>
+struct EnumTraits<cc::mojom::Material, cc::DrawQuad::Material> {
+  static cc::mojom::Material ToMojom(cc::DrawQuad::Material material);
+  static bool FromMojom(cc::mojom::Material input, cc::DrawQuad::Material* out);
+};
+
+template <>
+struct StructTraits<cc::mojom::DebugBorderQuadState, cc::DrawQuad> {
+  static bool IsNull(const cc::DrawQuad& input) {
+    return input.material != cc::DrawQuad::DEBUG_BORDER;
+  }
+
+  static void SetToNull(cc::DrawQuad* output) {
+    // There is nothing to deserialize here if the DrawQuad is not a
+    // DebugBorderDrawQuad. If it is, then this should not be called.
+    DCHECK_NE(cc::DrawQuad::DEBUG_BORDER, output->material);
+  }
+
+  static uint32_t color(const cc::DrawQuad& input) {
+    const cc::DebugBorderDrawQuad* quad =
+        cc::DebugBorderDrawQuad::MaterialCast(&input);
+    return quad->color;
+  }
+
+  static int32_t width(const cc::DrawQuad& input) {
+    const cc::DebugBorderDrawQuad* quad =
+        cc::DebugBorderDrawQuad::MaterialCast(&input);
+    return quad->width;
+  }
+
+  static bool Read(cc::mojom::DebugBorderQuadStateDataView data,
+                   cc::DrawQuad* out);
+};
+
+template <>
+struct StructTraits<cc::mojom::RenderPassQuadState, cc::DrawQuad> {
+  static bool IsNull(const cc::DrawQuad& quad) {
+    return quad.material != cc::DrawQuad::RENDER_PASS;
+  }
+
+  static void SetToNull(cc::DrawQuad* output) {
+    // There is nothing to deserialize here if the DrawQuad is not a
+    // RenderPassDrawQuad. If it is, then this should not be called.
+    DCHECK_NE(cc::DrawQuad::RENDER_PASS, output->material);
+  }
+
+  static const cc::RenderPassId& render_pass_id(const cc::DrawQuad& input) {
+    const cc::RenderPassDrawQuad* quad =
+        cc::RenderPassDrawQuad::MaterialCast(&input);
+    return quad->render_pass_id;
+  }
+
+  static uint32_t mask_resource_id(const cc::DrawQuad& input) {
+    const cc::RenderPassDrawQuad* quad =
+        cc::RenderPassDrawQuad::MaterialCast(&input);
+    return quad->mask_resource_id();
+  }
+
+  static const gfx::Vector2dF& mask_uv_scale(const cc::DrawQuad& input) {
+    const cc::RenderPassDrawQuad* quad =
+        cc::RenderPassDrawQuad::MaterialCast(&input);
+    return quad->mask_uv_scale;
+  }
+
+  static const gfx::Size& mask_texture_size(const cc::DrawQuad& input) {
+    const cc::RenderPassDrawQuad* quad =
+        cc::RenderPassDrawQuad::MaterialCast(&input);
+    return quad->mask_texture_size;
+  }
+
+  static const cc::FilterOperations& filters(const cc::DrawQuad& input) {
+    const cc::RenderPassDrawQuad* quad =
+        cc::RenderPassDrawQuad::MaterialCast(&input);
+    return quad->filters;
+  }
+
+  static const gfx::Vector2dF& filters_scale(const cc::DrawQuad& input) {
+    const cc::RenderPassDrawQuad* quad =
+        cc::RenderPassDrawQuad::MaterialCast(&input);
+    return quad->filters_scale;
+  }
+
+  static const cc::FilterOperations& background_filters(
+      const cc::DrawQuad& input) {
+    const cc::RenderPassDrawQuad* quad =
+        cc::RenderPassDrawQuad::MaterialCast(&input);
+    return quad->background_filters;
+  }
+
+  static bool Read(cc::mojom::RenderPassQuadStateDataView data,
+                   cc::DrawQuad* out);
+};
+
+template <>
+struct StructTraits<cc::mojom::SolidColorQuadState, cc::DrawQuad> {
+  static bool IsNull(const cc::DrawQuad& input) {
+    return input.material != cc::DrawQuad::SOLID_COLOR;
+  }
+
+  static void SetToNull(cc::DrawQuad* output) {
+    // There is nothing to deserialize here if the DrawQuad is not a
+    // SolidColorDrawQuad. If it is, then this should not be called.
+    DCHECK_NE(cc::DrawQuad::SOLID_COLOR, output->material);
+  }
+
+  static uint32_t color(const cc::DrawQuad& input) {
+    const cc::SolidColorDrawQuad* quad =
+        cc::SolidColorDrawQuad::MaterialCast(&input);
+    return quad->color;
+  }
+
+  static bool force_anti_aliasing_off(const cc::DrawQuad& input) {
+    const cc::SolidColorDrawQuad* quad =
+        cc::SolidColorDrawQuad::MaterialCast(&input);
+    return quad->force_anti_aliasing_off;
+  }
+
+  static bool Read(cc::mojom::SolidColorQuadStateDataView data,
+                   cc::DrawQuad* out);
+};
+
+template <>
+struct StructTraits<cc::mojom::SurfaceQuadState, cc::DrawQuad> {
+  static bool IsNull(const cc::DrawQuad& input) {
+    return input.material != cc::DrawQuad::SURFACE_CONTENT;
+  }
+
+  static void SetToNull(cc::DrawQuad* output) {
+    // There is nothing to deserialize here if the DrawQuad is not a
+    // SolidColorDrawQuad. If it is, then this should not be called.

[yzshen1, 2016/06/15 19:47:51]

SurfaceDrawQuad?

[Fady Samuel, 2016/06/15 19:52:40]

Done.

+    DCHECK_NE(cc::DrawQuad::SURFACE_CONTENT, output->material);
+  }
+
+  static const cc::SurfaceId& surface(const cc::DrawQuad& input) {
+    const cc::SurfaceDrawQuad* quad = cc::SurfaceDrawQuad::MaterialCast(&input);
+    return quad->surface_id;
+  }
+
+  static bool Read(cc::mojom::SurfaceQuadStateDataView data, cc::DrawQuad* out);
+};
+
+template <>
+struct StructTraits<cc::mojom::TextureQuadState, cc::DrawQuad> {
+  static bool IsNull(const cc::DrawQuad& input) {
+    return input.material != cc::DrawQuad::TEXTURE_CONTENT;
+  }
+
+  static void SetToNull(cc::DrawQuad* output) {
+    // There is nothing to deserialize here if the DrawQuad is not a
+    // TextureContentDrawQuad. If it is, then this should not be called.
+    DCHECK_NE(cc::DrawQuad::TEXTURE_CONTENT, output->material);
+  }
+
+  static uint32_t resource_id(const cc::DrawQuad& input) {
+    const cc::TextureDrawQuad* quad = cc::TextureDrawQuad::MaterialCast(&input);
+    return quad->resource_id();
+  }
+
+  static bool premultiplied_alpha(const cc::DrawQuad& input) {
+    const cc::TextureDrawQuad* quad = cc::TextureDrawQuad::MaterialCast(&input);
+    return quad->premultiplied_alpha;
+  }
+
+  static const gfx::PointF& uv_top_left(const cc::DrawQuad& input) {
+    const cc::TextureDrawQuad* quad = cc::TextureDrawQuad::MaterialCast(&input);
+    return quad->uv_top_left;
+  }
+
+  static const gfx::PointF& uv_bottom_right(const cc::DrawQuad& input) {
+    const cc::TextureDrawQuad* quad = cc::TextureDrawQuad::MaterialCast(&input);
+    return quad->uv_bottom_right;
+  }
+
+  static uint32_t background_color(const cc::DrawQuad& input) {
+    const cc::TextureDrawQuad* quad = cc::TextureDrawQuad::MaterialCast(&input);
+    return quad->background_color;
+  }
+
+  static CArray<float> vertex_opacity(const cc::DrawQuad& input) {
+    const cc::TextureDrawQuad* quad = cc::TextureDrawQuad::MaterialCast(&input);
+    return {4, 4, const_cast<float*>(&quad->vertex_opacity[0])};
+  }
+
+  static bool y_flipped(const cc::DrawQuad& input) {
+    const cc::TextureDrawQuad* quad = cc::TextureDrawQuad::MaterialCast(&input);
+    return quad->y_flipped;
+  }
+
+  static bool nearest_neighbor(const cc::DrawQuad& input) {
+    const cc::TextureDrawQuad* quad = cc::TextureDrawQuad::MaterialCast(&input);
+    return quad->nearest_neighbor;
+  }
+
+  static bool secure_output_only(const cc::DrawQuad& input) {
+    const cc::TextureDrawQuad* quad = cc::TextureDrawQuad::MaterialCast(&input);
+    return quad->secure_output_only;
+  }
+
+  static bool Read(cc::mojom::TextureQuadStateDataView data, cc::DrawQuad* out);
+};
+
+template <>
+struct StructTraits<cc::mojom::TileQuadState, cc::DrawQuad> {
+  static bool IsNull(const cc::DrawQuad& input) {
+    return input.material != cc::DrawQuad::TILED_CONTENT;
+  }
+
+  static void SetToNull(cc::DrawQuad* output) {
+    // There is nothing to deserialize here if the DrawQuad is not a
+    // TileDrawQuad. If it is, then this should not be called.
+    DCHECK_NE(cc::DrawQuad::TILED_CONTENT, output->material);
+  }
+
+  static const gfx::RectF& tex_coord_rect(const cc::DrawQuad& input) {
+    const cc::TileDrawQuad* quad = cc::TileDrawQuad::MaterialCast(&input);
+    return quad->tex_coord_rect;
+  }
+
+  static const gfx::Size& texture_size(const cc::DrawQuad& input) {
+    const cc::TileDrawQuad* quad = cc::TileDrawQuad::MaterialCast(&input);
+    return quad->texture_size;
+  }
+
+  static bool swizzle_contents(const cc::DrawQuad& input) {
+    const cc::TileDrawQuad* quad = cc::TileDrawQuad::MaterialCast(&input);
+    return quad->swizzle_contents;
+  }
+
+  static bool nearest_neighbor(const cc::DrawQuad& input) {
+    const cc::TileDrawQuad* quad = cc::TileDrawQuad::MaterialCast(&input);
+    return quad->nearest_neighbor;
+  }
+
+  static uint32_t resource_id(const cc::DrawQuad& input) {
+    const cc::TileDrawQuad* quad = cc::TileDrawQuad::MaterialCast(&input);
+    return quad->resource_id();
+  }
+
+  static bool Read(cc::mojom::TileQuadStateDataView data, cc::DrawQuad* out);
+};
+
+template <>
+struct StructTraits<cc::mojom::DrawQuad, cc::DrawQuad> {
+  static cc::DrawQuad::Material material(const cc::DrawQuad& quad) {
+    return quad.material;
+  }
+
+  static const gfx::Rect& rect(const cc::DrawQuad& quad) { return quad.rect; }
+
+  static const gfx::Rect& opaque_rect(const cc::DrawQuad& quad) {
+    return quad.opaque_rect;
+  }
+
+  static const gfx::Rect& visible_rect(const cc::DrawQuad& quad) {
+    return quad.visible_rect;
+  }
+
+  static bool needs_blending(const cc::DrawQuad& quad) {
+    return quad.needs_blending;
+  }
+
+  static uint32_t shared_quad_state_index(const cc::DrawQuad& quad) {
+    // TODO(fsamuel): Add shared_quad_state_index field to cc::DrawQuad.
+    return 0;
+  }
+
+  static const cc::DrawQuad& debug_border_quad_state(const cc::DrawQuad& quad) {
+    return quad;
+  }
+
+  static const cc::DrawQuad& render_pass_quad_state(const cc::DrawQuad& quad) {
+    return quad;
+  }
+
+  static const cc::DrawQuad& solid_color_quad_state(const cc::DrawQuad& quad) {
+    return quad;
+  }
+
+  static const cc::DrawQuad& surface_quad_state(const cc::DrawQuad& quad) {
+    return quad;
+  }
+
+  static const cc::DrawQuad& texture_quad_state(const cc::DrawQuad& quad) {
+    return quad;
+  }
+
+  static const cc::DrawQuad& tile_quad_state(const cc::DrawQuad& quad) {
+    return quad;
+  }
+
+  static cc::mojom::StreamVideoQuadStatePtr stream_video_quad_state(
+      const cc::DrawQuad& data) {
+    return nullptr;
+  }
+
+  static cc::mojom::YUVVideoQuadStatePtr yuv_video_quad_state(
+      const cc::DrawQuad& data) {
+    return nullptr;
+  }
+
+  static bool Read(cc::mojom::DrawQuadDataView data, cc::DrawQuad* out);
+};
+
+struct QuadListArray {
+  // This is the expected size of the array.
+  size_t size;
+  cc::QuadList* list;
+};
+
+template <>
+struct ArrayTraits<QuadListArray> {
+  using Element = cc::DrawQuad;
+  using Iterator = cc::QuadList::Iterator;
+  using ConstIterator = cc::QuadList::ConstIterator;
+
+  static ConstIterator GetBegin(const QuadListArray& input) {
+    return input.list->begin();
+  }
+  static Iterator GetBegin(QuadListArray& input) { return input.list->begin(); }
+  static void AdvanceIterator(ConstIterator& iterator) { iterator++; }
+  static void AdvanceIterator(Iterator& iterator) { iterator++; }
+  static const Element& GetValue(ConstIterator& iterator) { return **iterator; }
+  static Element& GetValue(Iterator& iterator) { return **iterator; }
+  static size_t GetSize(const QuadListArray& input) {
+    return input.list->size();
+  }
+  static bool Resize(QuadListArray& input, size_t size) {
+    return input.size == size;
+  }
+};
+
+template <>
+struct StructTraits<cc::mojom::QuadList, cc::QuadList> {
+  static void* SetUpContext(const cc::QuadList& quad_list);
+  static void TearDownContext(const cc::QuadList& quad_list, void* context);
+  static const mojo::Array<cc::DrawQuad::Material>& quad_types(
+      const cc::QuadList& quad_list,
+      void* context);
+  static QuadListArray quads(const cc::QuadList& quad_list) {
+    return {quad_list.size(), const_cast<cc::QuadList*>(&quad_list)};
+  }
+  static bool Read(cc::mojom::QuadListDataView data, cc::QuadList* out);
+};
+
+}  // namespace mojo
+
+#endif  // CC_IPC_QUADS_STRUCT_TRAITS_H_