cc mojo: Use ArrayDataViews in RenderPasses

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/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"
 #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 {
 
+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);
   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;
@@ skipping 347 matching lines @@
   static float resource_multiplier(const cc::DrawQuad& input) {
     const cc::YUVVideoDrawQuad* quad =
         cc::YUVVideoDrawQuad::MaterialCast(&input);
     return quad->resource_multiplier;
   }
 
   static bool Read(cc::mojom::YUVVideoQuadStateDataView data,
                    cc::DrawQuad* out);
 };
 
+struct DrawQuadWithSharedQuadState {
+  cc::DrawQuad* quad;
+  bool include_sqs;
+};
+
+template <>
+struct StructTraits<cc::mojom::DrawQuad, DrawQuadWithSharedQuadState> {
+  static cc::DrawQuad::Material material(
+      const DrawQuadWithSharedQuadState& input) {
+    return input.quad->material;
+  }
+
+  static const gfx::Rect& rect(const DrawQuadWithSharedQuadState& input) {
+    return input.quad->rect;
+  }
+
+  static const gfx::Rect& opaque_rect(
+      const DrawQuadWithSharedQuadState& input) {
+    return input.quad->opaque_rect;
+  }
+
+  static const gfx::Rect& visible_rect(
+      const DrawQuadWithSharedQuadState& input) {
+    return input.quad->visible_rect;
+  }
+
+  static bool needs_blending(const DrawQuadWithSharedQuadState& input) {
+    return input.quad->needs_blending;
+  }
+
+  static const cc::DrawQuad& debug_border_quad_state(
+      const DrawQuadWithSharedQuadState& input) {
+    return *input.quad;
+  }
+
+  static const cc::DrawQuad& render_pass_quad_state(
+      const DrawQuadWithSharedQuadState& input) {
+    return *input.quad;
+  }
+
+  static const cc::DrawQuad& solid_color_quad_state(
+      const DrawQuadWithSharedQuadState& input) {
+    return *input.quad;
+  }
+
+  static const cc::DrawQuad& surface_quad_state(
+      const DrawQuadWithSharedQuadState& input) {
+    return *input.quad;
+  }
+
+  static const cc::DrawQuad& texture_quad_state(
+      const DrawQuadWithSharedQuadState& input) {
+    return *input.quad;
+  }
+
+  static const cc::DrawQuad& tile_quad_state(
+      const DrawQuadWithSharedQuadState& input) {
+    return *input.quad;
+  }
+
+  static const cc::DrawQuad& stream_video_quad_state(
+      const DrawQuadWithSharedQuadState& input) {
+    return *input.quad;
+  }
+
+  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;
+  }
+};
+
 template <>
 struct StructTraits<cc::mojom::DrawQuad, cc::DrawQuad> {

[yzshen1, 2016/07/26 17:56:03]

Is this StructTraits still needed after we introduce the one above?

[Fady Samuel, 2016/07/27 23:52:22]

No, I added a TODO to move over tests.

   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 cc::mojom::SharedQuadStatePtr sqs(const cc::DrawQuad& quad) {
+    return nullptr;
+  }
+
   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;
@@ skipping 19 matching lines @@
     return data;
   }
 
   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;
+  const cc::DrawQuad* last_quad;
 };
 
 template <>
 struct ArrayTraits<QuadListArray> {
-  using Element = cc::DrawQuad;
+  using Element = DrawQuadWithSharedQuadState;
   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 void AdvanceIterator(QuadListArray& input, ConstIterator& iterator) {

[yzshen1, 2016/07/26 17:56:03]

This API change seems pretty weird. |input| is non-const. :/

I have an idea: define a new iterator:

CustomConstIterator {
  const cc::DrawQuad* last_quad;
  cc::QuadList::ConstIterator;
};

(Because you only use this ArrayTraits for reading, those non-const
GetBegin/AdvanceIterator/... are not needed, I believe)


That way we don't need to introduce |input|.

[Fady Samuel, 2016/07/27 23:52:23]

Done.

+    input.last_quad = *iterator;
+    ++iterator;
+  }
+  static void AdvanceIterator(QuadListArray& input, Iterator& iterator) {
+    input.last_quad = *iterator;
+    ++iterator;
+  }
+  static const Element& GetValue(QuadListArray& input,
+                                 ConstIterator& iterator) {
+    static DrawQuadWithSharedQuadState dq;

[yzshen1, 2016/07/26 17:56:03]

This is pretty hacky. It won't work, for example, in multi-threaded environment.
Comparing with this, I would rather we support GetValue() returning a value (in
addition to returning a ref).

Have you considered the following alternatives:
(1) In the SetUpContext of RenderPass, const_cast the input so that we can
modify the contents, and then set |shared_quad_state| to null for quads as
needed. And in TearDownContext we restore those values. That simplifies the code
quite a bit.

(2) Or actually setup a real DrawQuadWithSharedQuadState array (and cache it as
context of the owning struct).

I wonder how the performance of those alternatives is. 

[Fady Samuel, 2016/07/27 23:52:22]

I added support for returning Element by value.

+    dq.quad = const_cast<cc::DrawQuad*>(*iterator);
+    dq.include_sqs =
+        !input.last_quad ||
+        input.last_quad->shared_quad_state != (*iterator)->shared_quad_state;
+    return dq;
+  }
+  static Element& GetValue(QuadListArray& input, Iterator& iterator) {
+    static DrawQuadWithSharedQuadState dq;
+    dq.quad = *iterator;
+    dq.include_sqs =
+        !input.last_quad ||
+        input.last_quad->shared_quad_state != (*iterator)->shared_quad_state;
+    return dq;
+  }
   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> {

[yzshen1, 2016/07/26 17:56:03]

Is it possible that we remove cc::mojom::QuadList? (That means we change the
cc::mojom::RenderPass::quad_list's type to array<DrawQuad>.)

[Fady Samuel, 2016/07/27 23:52:23]

Done.

-  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)};
+    return {quad_list.size(), const_cast<cc::QuadList*>(&quad_list), nullptr};
   }
   static bool Read(cc::mojom::QuadListDataView data, cc::QuadList* out);
 };
 
 }  // namespace mojo
 
 #endif  // CC_IPC_QUADS_STRUCT_TRAITS_H_