cc mojo: Use ArrayDataViews in RenderPasses

cc/ipc/shared_quad_state_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_SHARED_QUAD_STATE_STRUCT_TRAITS_H_
 #define CC_IPC_SHARED_QUAD_STATE_STRUCT_TRAITS_H_
 
 #include "cc/ipc/shared_quad_state.mojom.h"
 #include "cc/quads/shared_quad_state.h"
 
 namespace mojo {
 
+struct OptSharedQuadState {

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

Could you use base::Optional<cc::SharedQuadState>? It will automatically use the
StructTraits<cc::mojom::SharedQuadState, cc::SharedQuadState>, so you don't need
to duplicate the code.

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

I don't think I can. I don't want to create another instance of SharedQuadState.
I'm passing around a SharedQuadState pointer that is owned elsewhere.

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

It is still possible if I let T* automatically use T's StructTraits (like what I
have done for base::Optional<T>). But that is a separate improvement that I can
consider later.

+  const cc::SharedQuadState* sqs;
+};
+
+template <>
+struct StructTraits<cc::mojom::SharedQuadState, OptSharedQuadState> {
+  static bool IsNull(const OptSharedQuadState& input) { return !input.sqs; }
+
+  static void SetToNull(OptSharedQuadState* output) { output->sqs = nullptr; }
+
+  static const gfx::Transform& quad_to_target_transform(
+      const OptSharedQuadState& input) {
+    return input.sqs->quad_to_target_transform;
+  }
+
+  static const gfx::Size& quad_layer_bounds(const OptSharedQuadState& input) {
+    return input.sqs->quad_layer_bounds;
+  }
+
+  static const gfx::Rect& visible_quad_layer_rect(
+      const OptSharedQuadState& input) {
+    return input.sqs->visible_quad_layer_rect;
+  }
+
+  static const gfx::Rect& clip_rect(const OptSharedQuadState& input) {
+    return input.sqs->clip_rect;
+  }
+
+  static bool is_clipped(const OptSharedQuadState& input) {
+    return input.sqs->is_clipped;
+  }
+
+  static float opacity(const OptSharedQuadState& input) {
+    return input.sqs->opacity;
+  }
+
+  static uint32_t blend_mode(const OptSharedQuadState& input) {
+    return input.sqs->blend_mode;
+  }
+
+  static int32_t sorting_context_id(const OptSharedQuadState& input) {
+    return input.sqs->sorting_context_id;
+  }
+};
+
 template <>
 struct StructTraits<cc::mojom::SharedQuadState, cc::SharedQuadState> {
   static const gfx::Transform& quad_to_target_transform(
       const cc::SharedQuadState& sqs) {
     return sqs.quad_to_target_transform;
   }
 
   static const gfx::Size& quad_layer_bounds(const cc::SharedQuadState& sqs) {
     return sqs.quad_layer_bounds;
   }
@@ skipping 49 matching lines @@
   using Element = cc::SharedQuadState;
   using Iterator = cc::SharedQuadStateList::Iterator;
   using ConstIterator = cc::SharedQuadStateList::ConstIterator;
 
   static ConstIterator GetBegin(const SharedQuadStateListArray& input) {
     return input.list->begin();
   }
   static Iterator GetBegin(SharedQuadStateListArray& 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(SharedQuadStateListArray& input,
+                              ConstIterator& iterator) {
+    ++iterator;
+  }
+  static void AdvanceIterator(SharedQuadStateListArray& input,
+                              Iterator& iterator) {
+    ++iterator;
+  }
+  static const Element& GetValue(SharedQuadStateListArray& input,
+                                 ConstIterator& iterator) {
+    return **iterator;
+  }
+  static Element& GetValue(SharedQuadStateListArray& input,
+                           Iterator& iterator) {
+    return **iterator;
+  }
   static size_t GetSize(const SharedQuadStateListArray& input) {
     return input.list->size();
   }
   static bool Resize(SharedQuadStateListArray& input, size_t size) {
     if (input.list->size() == size)
       return true;
     input.list->clear();
     for (size_t i = 0; i < size; ++i)
       input.list->AllocateAndConstruct<cc::SharedQuadState>();
     return true;
@@ skipping 10 matching lines @@
   static bool Read(cc::mojom::SharedQuadStateListDataView data,
                    cc::SharedQuadStateList* out) {
     SharedQuadStateListArray sqs_array = {out};
     return data.ReadSharedQuadStates(&sqs_array);
   }
 };
 
 }  // namespace mojo
 
 #endif  // CC_IPC_SHARED_QUAD_STATE_STRUCT_TRAITS_H_