cc mojo: Use ArrayDataViews in RenderPasses

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
index ed602beb8f1aed81776fde2c93b702e2fca5fa19..71651e1156ad39348deb90aeaba07061a89f82d8 100644
--- a/cc/ipc/quads_struct_traits.h
+++ b/cc/ipc/quads_struct_traits.h
@@ -9,6 +9,7 @@
 #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/shared_quad_state_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"
@@ -23,6 +24,8 @@
 
 namespace mojo {
 
+cc::DrawQuad* AllocateAndConstruct(cc::mojom::Material material,
+                                   cc::QuadList* list);
 template <>
 struct EnumTraits<cc::mojom::Material, cc::DrawQuad::Material> {
   static cc::mojom::Material ToMojom(cc::DrawQuad::Material material);
@@ -390,58 +393,86 @@ struct StructTraits<cc::mojom::YUVVideoQuadState, cc::DrawQuad> {
                    cc::DrawQuad* out);
 };
 
+struct DrawQuadWithSharedQuadState {
+  cc::DrawQuad* quad;
+  bool include_sqs;
+};
+
 template <>
-struct StructTraits<cc::mojom::DrawQuad, cc::DrawQuad> {
-  static cc::DrawQuad::Material material(const cc::DrawQuad& quad) {
-    return quad.material;
+struct StructTraits<cc::mojom::DrawQuad, DrawQuadWithSharedQuadState> {
+  static cc::DrawQuad::Material material(
+      const DrawQuadWithSharedQuadState& input) {
+    return input.quad->material;
   }
 
-  static const gfx::Rect& rect(const cc::DrawQuad& quad) { return quad.rect; }
+  static const gfx::Rect& rect(const DrawQuadWithSharedQuadState& input) {
+    return input.quad->rect;
+  }
 
-  static const gfx::Rect& opaque_rect(const cc::DrawQuad& quad) {
-    return quad.opaque_rect;
+  static const gfx::Rect& opaque_rect(
+      const DrawQuadWithSharedQuadState& input) {
+    return input.quad->opaque_rect;
   }
 
-  static const gfx::Rect& visible_rect(const cc::DrawQuad& quad) {
-    return quad.visible_rect;
+  static const gfx::Rect& visible_rect(
+      const DrawQuadWithSharedQuadState& input) {
+    return input.quad->visible_rect;
   }
 
-  static bool needs_blending(const cc::DrawQuad& quad) {
-    return quad.needs_blending;
+  static bool needs_blending(const DrawQuadWithSharedQuadState& input) {
+    return input.quad->needs_blending;
   }
 
-  static const cc::DrawQuad& debug_border_quad_state(const cc::DrawQuad& quad) {
-    return quad;
+  static const cc::DrawQuad& debug_border_quad_state(
+      const DrawQuadWithSharedQuadState& input) {
+    return *input.quad;
   }
 
-  static const cc::DrawQuad& render_pass_quad_state(const cc::DrawQuad& quad) {
-    return quad;
+  static const cc::DrawQuad& render_pass_quad_state(
+      const DrawQuadWithSharedQuadState& input) {
+    return *input.quad;
   }
 
-  static const cc::DrawQuad& solid_color_quad_state(const cc::DrawQuad& quad) {
-    return quad;
+  static const cc::DrawQuad& solid_color_quad_state(
+      const DrawQuadWithSharedQuadState& input) {
+    return *input.quad;
   }
 
-  static const cc::DrawQuad& surface_quad_state(const cc::DrawQuad& quad) {
-    return quad;
+  static const cc::DrawQuad& surface_quad_state(
+      const DrawQuadWithSharedQuadState& input) {
+    return *input.quad;
   }
 
-  static const cc::DrawQuad& texture_quad_state(const cc::DrawQuad& quad) {
-    return quad;
+  static const cc::DrawQuad& texture_quad_state(
+      const DrawQuadWithSharedQuadState& input) {
+    return *input.quad;
   }
 
-  static const cc::DrawQuad& tile_quad_state(const cc::DrawQuad& quad) {
-    return quad;
+  static const cc::DrawQuad& tile_quad_state(
+      const DrawQuadWithSharedQuadState& input) {
+    return *input.quad;
   }
 
-  static const cc::DrawQuad& stream_video_quad_state(const cc::DrawQuad& quad) {
-    return quad;
+  static const cc::DrawQuad& stream_video_quad_state(
+      const DrawQuadWithSharedQuadState& input) {
+    return *input.quad;
   }
 
-  static const cc::DrawQuad& yuv_video_quad_state(const cc::DrawQuad& data) {
-    return data;
+  static const cc::DrawQuad& yuv_video_quad_state(
+      const DrawQuadWithSharedQuadState& input) {
+    return *input.quad;
   }
 
+  static OptSharedQuadState sqs(const DrawQuadWithSharedQuadState& input) {
+    OptSharedQuadState sqs;
+    sqs.sqs = input.include_sqs ? input.quad->shared_quad_state : nullptr;
+    return sqs;
+  }
+};
+
+// This StructTraits is only used for deserialization within RenderPasses.
+template <>
+struct StructTraits<cc::mojom::DrawQuad, cc::DrawQuad> {
   static bool Read(cc::mojom::DrawQuadDataView data, cc::DrawQuad* out);
 };
 
@@ -449,41 +480,44 @@ struct QuadListArray {
   // This is the expected size of the array.
   size_t size;
   cc::QuadList* list;
+  const cc::DrawQuad* last_quad;
+};
+
+struct QuadListConstIterator {

[yzshen1, 2016/07/28 18:25:19]

This looks so much better than the previous code! :D

nit: you could directly define this as ConstIterator in the ArrayTraits below,
instead of defining it out-of-line and then adding an alias.

[Fady Samuel, 2016/07/28 19:53:31]

Done.

+  QuadListConstIterator(const cc::QuadList::ConstIterator& it,
+                        const cc::DrawQuad* last_quad)
+      : it(it), last_quad(last_quad) {}
+
+  cc::QuadList::ConstIterator it;
+  const cc::DrawQuad* last_quad;
 };
 
 template <>
 struct ArrayTraits<QuadListArray> {
-  using Element = cc::DrawQuad;
-  using Iterator = cc::QuadList::Iterator;
-  using ConstIterator = cc::QuadList::ConstIterator;
+  using Element = DrawQuadWithSharedQuadState;
+  using ConstIterator = QuadListConstIterator;
 
   static ConstIterator GetBegin(const QuadListArray& input) {
-    return input.list->begin();
+    return QuadListConstIterator(input.list->begin(), nullptr);
   }
-  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 void AdvanceIterator(ConstIterator& iterator) {
+    iterator.last_quad = *iterator.it;
+    ++iterator.it;
   }
-  static bool Resize(QuadListArray& input, size_t size) {
-    return input.size == size;
+
+  static Element GetValue(ConstIterator& iterator) {
+    DrawQuadWithSharedQuadState dq;
+    dq.quad = const_cast<cc::DrawQuad*>(*iterator.it);

[yzshen1, 2016/07/28 18:25:19]

Why do we need a non-const pointer here?

[Fady Samuel, 2016/07/28 19:53:31]

Done.

+    dq.include_sqs = !iterator.last_quad ||
+                     iterator.last_quad->shared_quad_state !=
+                         (*iterator.it)->shared_quad_state;
+    return dq;
   }
-};
 
-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);
+  static size_t GetSize(const QuadListArray& input) {
+    return input.list->size();
+  }
 };
 
 }  // namespace mojo