Implement DrawQuad StructTraits

cc/ipc/quads_struct_traits.h

Index: cc/ipc/quads_struct_traits.h
diff --git a/cc/ipc/quads_struct_traits.h b/cc/ipc/quads_struct_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..01b71de7f773fe1167c3a38e7742ae9e11df8b75
--- /dev/null
+++ b/cc/ipc/quads_struct_traits.h
@@ -0,0 +1,344 @@
+// 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/quads.mojom.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"
+
+namespace mojo {
+
+namespace {
+
+cc::mojom::Material CCMaterialToMojo(cc::DrawQuad::Material material) {
+  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::MATERIAL_LAST;
+}
+
+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::MyDrawQuadDataView data, uint8_t* out) {
+  cc::DrawQuad* quad = reinterpret_cast<cc::DrawQuad*>(out);
+  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
+
+template <>
+struct StructTraits<cc::mojom::SolidColorQuadState, uint8_t> {

[yzshen1, 2016/06/14 16:55:57]

can this be

struct StructTraits<cc::mojom::SolidColorQuadState, void*> ?

[Fady Samuel, 2016/06/14 21:56:49]

This doesn't work in general because ArrayTraits::GetValue returns an rvalue for
QuadLIst because QuadList::ElementAt returns an rvalue.

+  static bool IsNull(const uint8_t& input) {
+    const cc::DrawQuad* quad = reinterpret_cast<const cc::DrawQuad*>(&input);
+    return quad->material != cc::DrawQuad::SOLID_COLOR;
+  }
+
+  static void SetToNull(uint8_t* output) {}
+
+  static uint32_t color(const uint8_t& input) {
+    const cc::SolidColorDrawQuad* quad =
+        reinterpret_cast<const cc::SolidColorDrawQuad*>(&input);
+    return quad->color;
+  }
+
+  static bool force_anti_aliasing_off(const uint8_t& input) {
+    const cc::SolidColorDrawQuad* quad =
+        reinterpret_cast<const cc::SolidColorDrawQuad*>(&input);
+    return quad->force_anti_aliasing_off;
+  }
+
+  static bool Read(cc::mojom::SolidColorQuadStateDataView data, uint8_t* out) {
+    cc::SolidColorDrawQuad* quad =
+        reinterpret_cast<cc::SolidColorDrawQuad*>(out);
+    quad->force_anti_aliasing_off = data.force_anti_aliasing_off();
+    quad->color = data.color();
+    return true;
+  }
+};
+
+template <>
+struct StructTraits<cc::mojom::DebugBorderQuadState, uint8_t> {
+  static bool IsNull(const uint8_t& input) {
+    const cc::DrawQuad* quad = reinterpret_cast<const cc::DrawQuad*>(&input);
+    return quad->material != cc::DrawQuad::DEBUG_BORDER;
+  }
+
+  static void SetToNull(uint8_t* output) {}
+
+  static uint32_t color(const uint8_t& input) {
+    const cc::DebugBorderDrawQuad* quad =
+        reinterpret_cast<const cc::DebugBorderDrawQuad*>(&input);
+    return quad->color;
+  }
+
+  static int32_t width(const uint8_t& input) {
+    const cc::DebugBorderDrawQuad* quad =
+        reinterpret_cast<const cc::DebugBorderDrawQuad*>(&input);
+    return quad->width;
+  }
+
+  static bool Read(cc::mojom::DebugBorderQuadStateDataView data, uint8_t* out) {
+    cc::DebugBorderDrawQuad* quad =
+        reinterpret_cast<cc::DebugBorderDrawQuad*>(out);
+    quad->color = data.color();
+    quad->width = data.width();
+    return true;
+  }
+};
+
+template <>
+struct StructTraits<cc::mojom::MyDrawQuad, uint8_t> {
+  static cc::mojom::Material material(const uint8_t& data) {
+    const cc::DrawQuad* quad = reinterpret_cast<const cc::DrawQuad*>(&data);
+    return CCMaterialToMojo(quad->material);
+  }
+
+  static const gfx::Rect& rect(const uint8_t& data) {
+    const cc::DrawQuad* quad = reinterpret_cast<const cc::DrawQuad*>(&data);
+    return quad->rect;
+  }
+
+  static const gfx::Rect& opaque_rect(const uint8_t& data) {
+    const cc::DrawQuad* quad = reinterpret_cast<const cc::DrawQuad*>(&data);
+    return quad->opaque_rect;
+  }
+
+  static const gfx::Rect& visible_rect(const uint8_t& data) {
+    const cc::DrawQuad* quad = reinterpret_cast<const cc::DrawQuad*>(&data);
+    return quad->visible_rect;
+  }
+
+  static bool needs_blending(const uint8_t& data) {
+    const cc::DrawQuad* quad = reinterpret_cast<const cc::DrawQuad*>(&data);
+    return quad->needs_blending;
+  }
+
+  static uint32_t shared_quad_state_index(const uint8_t& data) { return 0; }
+
+  static uint8_t& debug_border_quad_state(const uint8_t& data) {
+    return const_cast<uint8_t&>(data);
+  }
+
+  static cc::mojom::IoSurfaceContentQuadStatePtr io_surface_quad_state(
+      const uint8_t& data) {
+    return nullptr;
+  }
+
+  static cc::mojom::RenderPassQuadStatePtr render_pass_quad_state(
+      const uint8_t& data) {
+    return nullptr;
+  }
+
+  static uint8_t& solid_color_quad_state(const uint8_t& data) {
+    return const_cast<uint8_t&>(data);
+  }
+
+  static cc::mojom::SurfaceQuadStatePtr surface_quad_state(
+      const uint8_t& data) {
+    return nullptr;
+  }
+
+  static cc::mojom::TextureQuadStatePtr texture_quad_state(
+      const uint8_t& data) {
+    return nullptr;
+  }
+
+  static cc::mojom::TileQuadStatePtr tile_quad_state(const uint8_t& data) {
+    return nullptr;
+  }
+
+  static cc::mojom::StreamVideoQuadStatePtr stream_video_quad_state(
+      const uint8_t& data) {
+    return nullptr;
+  }
+
+  static cc::mojom::YUVVideoQuadStatePtr yuv_video_quad_state(
+      const uint8_t& data) {
+    return nullptr;
+  }
+
+  static bool Read(cc::mojom::MyDrawQuadDataView data, uint8_t* 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:
+        break;
+      case cc::mojom::Material::RENDER_PASS:
+        break;
+      case cc::mojom::Material::SOLID_COLOR:
+        return data.ReadSolidColorQuadState(out);
+      case cc::mojom::Material::STREAM_VIDEO_CONTENT:
+        break;
+      case cc::mojom::Material::SURFACE_CONTENT:
+        break;
+      case cc::mojom::Material::TEXTURE_CONTENT:
+        break;
+      case cc::mojom::Material::TILED_CONTENT:
+        break;
+      case cc::mojom::Material::YUV_VIDEO_CONTENT:
+        break;
+    }
+    NOTREACHED();
+    return false;
+  }
+};
+
+struct QuadListArray {
+  cc::QuadList* list;
+};
+
+template <>
+struct ArrayTraits<QuadListArray> {
+  using Element = uint8_t;
+  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 *reinterpret_cast<const Element*>(*iterator);
+  }
+  static Element& GetValue(Iterator& iterator) {
+    return *reinterpret_cast<Element*>(*iterator);
+  }
+
+  static size_t GetSize(const QuadListArray& input) {
+    return input.list->size();
+  }
+
+  static bool Resize(QuadListArray& input, size_t size) { return true; }
+};
+
+template <>
+struct StructTraits<cc::mojom::QuadList, cc::QuadList> {
+  static mojo::Array<cc::mojom::Material> quad_types(
+      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 QuadListArray quads(const cc::QuadList& quad_list) {
+    return {const_cast<cc::QuadList*>(&quad_list)};
+  }
+
+  static bool Read(cc::mojom::QuadListDataView data, cc::QuadList* out) {
+    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);
+    }
+    QuadListArray quad_list_array = {out};
+    return data.ReadQuads(&quad_list_array);
+  }
+};
+
+}  // namespace mojo
+
+#endif  // CC_IPC_QUADS_STRUCT_TRAITS_H_