cc mojo: Use ArrayDataViews in RenderPasses

This CL makes use of the newly introduced Array DataViews
in cc StructTraits in order to improve serialization (and
to a lesser degree deserialization) performance.

This CL improves serialization performance by an average of
18% on an HP Z620. Deserialization performance improves
between 7 to 10%.

Prior to the ability to inspect Array and Struct DataViews
in parent StructTraits, we had to do extra work at
serialization time in order to capture state that spans
individual structs within a larger struct.

This CL addresses two of those cases:

1. Previously, QuadList maintained an extra array of
materials. This array existed so that we could preallocate
the appropriately typed DrawQuads during deserialization.
StructTraits assume a preallocated type and populated
fields in that type.

Alternatively we could have deserialized DrawQuads into
unique_ptrs, but cc required that we allocate DrawQuads
inline within a buffer in order to minimize the cost of
allocations (there can be hundreds of DrawQuads in a
CompositorFrame).

2. Previously, SharedQuadStates were serialized
independently of DrawQuads. However, in in-memory form,
DrawQuads refer to SharedQuadStates via raw pointers. In
order to allow DrawQuads and SharedQuadStates to deserialize
independently, as was required previously by StructTraits, a third
array was serialized "shared_quad_state_references" which was equal in
size to the QuadList. Each slot corresponded to an index in
the SharedQuadStateList. After the QuadList and SharedQuadStateList were
serialized,  shared_quad_state_references updated the raw
pointers in the DrawQuads in the quad list to refer to the
SharedQuadStates. This required revisiting all deserialized
DrawQuads again.

In both 1. and 2. additional state needed to be allocated on the heap
during serialization. In pprof profiling, it became apparent that much
of the cost of serialization was in SetupContext. This CL eliminates
that cost.

Performance measures are available here:
https://docs.google.com/a/google.com/spreadsheets/d/13Y0I-BVDrQC4RHIzMSs0vl0QPe8xFAhYMUAXaxoEqgg/pubhtml

BUG=624459
TBR=danakj@chromium.org
CQ_INCLUDE_TRYBOTS=master.tryserver.blink:linux_precise_blink_rel

Review-Url: https://codereview.chromium.org/2174843003
Cr-Commit-Position: refs/heads/master@{#408809}

cc/ipc/quads.mojom

@@ -6,6 +6,7 @@ module cc.mojom;
 
 import "cc/ipc/filter_operations.mojom";
 import "cc/ipc/render_pass_id.mojom";
+import "cc/ipc/shared_quad_state.mojom";
 import "cc/ipc/surface_id.mojom";
 import "ui/gfx/geometry/mojo/geometry.mojom";
 import "ui/gfx/mojo/transform.mojom";
@@ -127,13 +128,9 @@ struct DrawQuad {
   // should be clipped to |rect|. This rect lives in content space.
   bool needs_blending;
 
-  // Index into the containing pass' shared quad state array which has state
-  // (transforms etc) shared by multiple quads.
-  // TODO(fsamuel): This is not currently used because we store the
-  // indicies to SharedQuadStates in a separate array. This is more expensive
-  // than storing them inline here, but we need support for context propagation
-  // in Mojo StructTraits in order to store the sqs index here.
-  //uint32 shared_quad_state_index;
+  // Optionally holds a SharedQuadState (transforms etc) shared by multiple
+  // quads.
+  SharedQuadState? sqs;
 
   // Only one of the following will be set, depending on the material.
   DebugBorderQuadState? debug_border_quad_state;
@@ -145,9 +142,3 @@ struct DrawQuad {
   StreamVideoQuadState? stream_video_quad_state;
   YUVVideoQuadState? yuv_video_quad_state;
 };
-
-struct QuadList {
-  array<Material> quad_types;
-  array<DrawQuad> quads;
-};
-

cc/ipc/quads.typemap

-# 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.
-
-mojom = "//cc/ipc/quads.mojom"
-public_headers = [
-  "//cc/quads/draw_quad.h",
-  "//cc/quads/render_pass.h",
-]
-traits_headers = [ "//cc/ipc/quads_struct_traits.h" ]
-sources = [
-  "//cc/ipc/quads_struct_traits.cc",
-]
-public_deps = [
-  "//cc",
-]
-type_mappings = [
-  "cc.mojom.QuadList=cc::QuadList",
-  "cc.mojom.SharedQuadStateList=cc::SharedQuadStateList",
-]

cc/ipc/quads_struct_traits.cc

@@ -7,6 +7,52 @@
 
 namespace mojo {
 
+cc::DrawQuad* AllocateAndConstruct(cc::mojom::Material material,
+                                   cc::QuadList* list) {
+  cc::DrawQuad* quad = nullptr;
+  switch (material) {
+    case cc::mojom::Material::INVALID:
+      return nullptr;
+    case cc::mojom::Material::DEBUG_BORDER:
+      quad = list->AllocateAndConstruct<cc::DebugBorderDrawQuad>();
+      quad->material = cc::DrawQuad::DEBUG_BORDER;
+      return quad;
+    case cc::mojom::Material::PICTURE_CONTENT:
+      quad = list->AllocateAndConstruct<cc::PictureDrawQuad>();
+      quad->material = cc::DrawQuad::PICTURE_CONTENT;
+      return quad;
+    case cc::mojom::Material::RENDER_PASS:
+      quad = list->AllocateAndConstruct<cc::RenderPassDrawQuad>();
+      quad->material = cc::DrawQuad::RENDER_PASS;
+      return quad;
+    case cc::mojom::Material::SOLID_COLOR:
+      quad = list->AllocateAndConstruct<cc::SolidColorDrawQuad>();
+      quad->material = cc::DrawQuad::SOLID_COLOR;
+      return quad;
+    case cc::mojom::Material::STREAM_VIDEO_CONTENT:
+      quad = list->AllocateAndConstruct<cc::StreamVideoDrawQuad>();
+      quad->material = cc::DrawQuad::STREAM_VIDEO_CONTENT;
+      return quad;
+    case cc::mojom::Material::SURFACE_CONTENT:
+      quad = list->AllocateAndConstruct<cc::SurfaceDrawQuad>();
+      quad->material = cc::DrawQuad::SURFACE_CONTENT;
+      return quad;
+    case cc::mojom::Material::TEXTURE_CONTENT:
+      quad = list->AllocateAndConstruct<cc::TextureDrawQuad>();
+      quad->material = cc::DrawQuad::TEXTURE_CONTENT;
+      return quad;
+    case cc::mojom::Material::TILED_CONTENT:
+      quad = list->AllocateAndConstruct<cc::TileDrawQuad>();
+      quad->material = cc::DrawQuad::TILED_CONTENT;
+      return quad;
+    case cc::mojom::Material::YUV_VIDEO_CONTENT:
+      quad = list->AllocateAndConstruct<cc::YUVVideoDrawQuad>();
+      quad->material = cc::DrawQuad::YUV_VIDEO_CONTENT;
+      return quad;
+  }
+  NOTREACHED();
+  return nullptr;
+}
 namespace {
 
 bool ReadDrawQuad(cc::mojom::DrawQuadDataView data, cc::DrawQuad* quad) {
@@ -22,44 +68,6 @@ bool ReadDrawQuad(cc::mojom::DrawQuadDataView data, cc::DrawQuad* quad) {
   return true;
 }
 
-bool AllocateAndConstruct(cc::DrawQuad::Material material, cc::QuadList* list) {
-  cc::DrawQuad* quad = nullptr;
-  switch (material) {
-    case cc::DrawQuad::INVALID:
-      break;
-    case cc::DrawQuad::DEBUG_BORDER:
-      quad = list->AllocateAndConstruct<cc::DebugBorderDrawQuad>();
-      break;
-    case cc::DrawQuad::PICTURE_CONTENT:
-      quad = list->AllocateAndConstruct<cc::PictureDrawQuad>();
-      break;
-    case cc::DrawQuad::RENDER_PASS:
-      quad = list->AllocateAndConstruct<cc::RenderPassDrawQuad>();
-      break;
-    case cc::DrawQuad::SOLID_COLOR:
-      quad = list->AllocateAndConstruct<cc::SolidColorDrawQuad>();
-      break;
-    case cc::DrawQuad::STREAM_VIDEO_CONTENT:
-      quad = list->AllocateAndConstruct<cc::StreamVideoDrawQuad>();
-      break;
-    case cc::DrawQuad::SURFACE_CONTENT:
-      quad = list->AllocateAndConstruct<cc::SurfaceDrawQuad>();
-      break;
-    case cc::DrawQuad::TEXTURE_CONTENT:
-      quad = list->AllocateAndConstruct<cc::TextureDrawQuad>();
-      break;
-    case cc::DrawQuad::TILED_CONTENT:
-      quad = list->AllocateAndConstruct<cc::TileDrawQuad>();
-      break;
-    case cc::DrawQuad::YUV_VIDEO_CONTENT:
-      quad = list->AllocateAndConstruct<cc::YUVVideoDrawQuad>();
-      break;
-  }
-  if (quad)
-    quad->material = material;
-  return quad != nullptr;
-}
-
 }  // namespace
 
 // static
@@ -327,50 +335,4 @@ bool StructTraits<cc::mojom::DrawQuad, cc::DrawQuad>::Read(
   return false;
 }
 
-// static
-void* StructTraits<cc::mojom::QuadList, cc::QuadList>::SetUpContext(
-    const cc::QuadList& quad_list) {
-  mojo::Array<cc::DrawQuad::Material>* materials =
-      new mojo::Array<cc::DrawQuad::Material>(quad_list.size());
-  for (auto it = quad_list.begin(); it != quad_list.end(); ++it)
-    (*materials)[it.index()] = it->material;
-  return materials;
-}
-
-// static
-void StructTraits<cc::mojom::QuadList, cc::QuadList>::TearDownContext(
-    const cc::QuadList& quad_list,
-    void* context) {
-  // static_cast to ensure the destructor is called.
-  delete static_cast<mojo::Array<cc::DrawQuad::Material>*>(context);
-}
-
-// static
-const mojo::Array<cc::DrawQuad::Material>&
-StructTraits<cc::mojom::QuadList, cc::QuadList>::quad_types(
-    const cc::QuadList& quad_list,
-    void* context) {
-  return *static_cast<mojo::Array<cc::DrawQuad::Material>*>(context);
-}
-
-// static
-bool StructTraits<cc::mojom::QuadList, cc::QuadList>::Read(
-    cc::mojom::QuadListDataView data,
-    cc::QuadList* out) {
-  // TODO(fsamuel): Once we have ArrayTraits DataViews we can delete
-  // this field. This field exists so we can pre-allocate DrawQuads
-  // in the QuadList according to their material.
-  mojo::Array<cc::DrawQuad::Material> materials;
-  if (!data.ReadQuadTypes(&materials))
-    return false;
-  for (size_t i = 0; i < materials.size(); ++i) {
-    if (!AllocateAndConstruct(materials[i], out))
-      return false;
-  }
-  // The materials array and the quads array are expected to be the same size.
-  // If they are not, then deserialization will fail.
-  QuadListArray quad_list_array = {materials.size(), out};
-  return data.ReadQuads(&quad_list_array);
-}
-
 }  // namespace mojo

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,100 +393,120 @@ struct StructTraits<cc::mojom::YUVVideoQuadState, cc::DrawQuad> {
                    cc::DrawQuad* out);
 };
 
+struct DrawQuadWithSharedQuadState {
+  const 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 bool Read(cc::mojom::DrawQuadDataView data, cc::DrawQuad* out);
+  static OptSharedQuadState sqs(const DrawQuadWithSharedQuadState& input) {
+    OptSharedQuadState sqs;
+    sqs.sqs = input.include_sqs ? input.quad->shared_quad_state : nullptr;
+    return sqs;
+  }
 };
 
-struct QuadListArray {
-  // This is the expected size of the array.
-  size_t size;
-  cc::QuadList* list;
+// 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);
 };
 
 template <>
-struct ArrayTraits<QuadListArray> {
-  using Element = cc::DrawQuad;
-  using Iterator = cc::QuadList::Iterator;
-  using ConstIterator = cc::QuadList::ConstIterator;
+struct ArrayTraits<cc::QuadList> {
+  using Element = DrawQuadWithSharedQuadState;
+  struct ConstIterator {
+    ConstIterator(const cc::QuadList::ConstIterator& it,
+                  const cc::DrawQuad* last_quad)
+        : it(it), last_quad(last_quad) {}
 
-  static ConstIterator GetBegin(const QuadListArray& input) {
-    return input.list->begin();
+    cc::QuadList::ConstIterator it;
+    const cc::DrawQuad* last_quad;
+  };
+
+  static ConstIterator GetBegin(const cc::QuadList& input) {
+    return ConstIterator(input.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 = *iterator.it;
+    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 cc::QuadList& input) { return input.size(); }
 };
 
 }  // namespace mojo

cc/ipc/render_pass.mojom

@@ -6,7 +6,6 @@ module cc.mojom;
 
 import "cc/ipc/render_pass_id.mojom";
 import "cc/ipc/quads.mojom";
-import "cc/ipc/shared_quad_state.mojom";
 import "ui/gfx/geometry/mojo/geometry.mojom";
 import "ui/gfx/mojo/transform.mojom";
 
@@ -17,7 +16,5 @@ struct RenderPass {
   gfx.mojom.Rect damage_rect;
   gfx.mojom.Transform transform_to_root_target;
   bool has_transparent_background;
-  QuadList quad_list;
-  array<uint32> shared_quad_state_references;
-  SharedQuadStateList shared_quad_state_list;
+  array<DrawQuad> quad_list;
 };

cc/ipc/render_pass.typemap

@@ -3,13 +3,20 @@
 # found in the LICENSE file.
 
 mojom = "//cc/ipc/render_pass.mojom"
-public_headers = [ "//cc/quads/render_pass.h" ]
-traits_headers = [ "//cc/ipc/render_pass_struct_traits.h" ]
+public_headers = [
+  "//cc/quads/draw_quad.h",
+  "//cc/quads/render_pass.h",
+]
+traits_headers = [
+  "//cc/ipc/quads_struct_traits.h",
+  "//cc/ipc/render_pass_struct_traits.h",
+]
 sources = [
+  "//cc/ipc/quads_struct_traits.cc",
   "//cc/ipc/render_pass_struct_traits.cc",
 ]
 public_deps = [
   "//base",
   "//cc",
 ]
-type_mappings = [ "cc.mojom.RenderPass=std::unique_ptr<cc::RenderPass>" ]
+type_mappings = [ "cc.mojom.RenderPass=std::unique_ptr<cc::RenderPass>[move_only,nullable_is_same_type]" ]

cc/ipc/render_pass_struct_traits.cc

@@ -9,34 +9,6 @@
 
 namespace mojo {
 
-// static
-void* StructTraits<cc::mojom::RenderPass, std::unique_ptr<cc::RenderPass>>::
-    SetUpContext(const std::unique_ptr<cc::RenderPass>& input) {
-  std::unique_ptr<mojo::Array<uint32_t>> sqs_references(
-      new mojo::Array<uint32_t>(input->quad_list.size()));
-  cc::SharedQuadStateList::ConstIterator sqs_iter =
-      input->shared_quad_state_list.begin();
-  for (auto it = input->quad_list.begin(); it != input->quad_list.end(); ++it) {
-    if ((*it)->shared_quad_state != *sqs_iter)
-      ++sqs_iter;
-    (*sqs_references)[it.index()] =
-        base::checked_cast<uint32_t>(sqs_iter.index());
-    DCHECK_NE(nullptr, (*it)->shared_quad_state);
-    DCHECK_EQ(*sqs_iter, (*it)->shared_quad_state);
-  }
-  DCHECK(input->shared_quad_state_list.empty() ||
-         input->shared_quad_state_list.size() - 1 == sqs_iter.index());
-  return sqs_references.release();
-}
-
-// static
-void StructTraits<cc::mojom::RenderPass, std::unique_ptr<cc::RenderPass>>::
-    TearDownContext(const std::unique_ptr<cc::RenderPass>& input,
-                    void* context) {
-  // static_cast to ensure the destructor is called.
-  delete static_cast<mojo::Array<uint32_t>*>(context);
-}
-
 // static
 bool StructTraits<cc::mojom::RenderPass, std::unique_ptr<cc::RenderPass>>::Read(
     cc::mojom::RenderPassDataView data,
@@ -48,31 +20,35 @@ bool StructTraits<cc::mojom::RenderPass, std::unique_ptr<cc::RenderPass>>::Read(
     return false;
   }
   (*out)->has_transparent_background = data.has_transparent_background();
-  if (!data.ReadQuadList(&(*out)->quad_list) ||
-      !data.ReadSharedQuadStateList(&(*out)->shared_quad_state_list))
-    return false;
-
-  mojo::Array<uint32_t> shared_quad_state_references;
-  if (!data.ReadSharedQuadStateReferences(&shared_quad_state_references))
-    return false;
 
-  if ((*out)->quad_list.size() != shared_quad_state_references.size())
-    return false;
-
-  cc::SharedQuadStateList::ConstIterator sqs_iter =
-      (*out)->shared_quad_state_list.begin();
-  for (auto it = (*out)->quad_list.begin(); it != (*out)->quad_list.end();
-       ++it) {
-    if (sqs_iter.index() != shared_quad_state_references[it.index()])
-      ++sqs_iter;
-    if (shared_quad_state_references[it.index()] != sqs_iter.index())
+  mojo::ArrayDataView<cc::mojom::DrawQuadDataView> quads;
+  data.GetQuadListDataView(&quads);
+  cc::SharedQuadState* last_sqs = nullptr;
+  for (size_t i = 0; i < quads.size(); ++i) {
+    cc::mojom::DrawQuadDataView quad_data_view;
+    quads.GetDataView(i, &quad_data_view);
+    cc::DrawQuad* quad =
+        AllocateAndConstruct(quad_data_view.material(), &(*out)->quad_list);
+    if (!quad)
+      return false;
+    if (!quads.Read(i, quad))
       return false;
-    (*it)->shared_quad_state = *sqs_iter;
-    if (!(*it)->shared_quad_state)
+
+    // Read the SharedQuadState.
+    cc::mojom::SharedQuadStateDataView sqs_data_view;
+    quad_data_view.GetSqsDataView(&sqs_data_view);
+    // If there is no seralized SharedQuadState then used the last deseriaized
+    // one.
+    if (!sqs_data_view.is_null()) {
+      last_sqs = (*out)->CreateAndAppendSharedQuadState();
+      if (!quad_data_view.ReadSqs(last_sqs))
+        return false;
+    }
+    quad->shared_quad_state = last_sqs;
+    if (!quad->shared_quad_state)
       return false;
   }
-  return (*out)->shared_quad_state_list.empty() ||
-         sqs_iter.index() == (*out)->shared_quad_state_list.size() - 1;
+  return true;
 }
 
 }  // namespace mojo

cc/ipc/render_pass_struct_traits.h

@@ -15,10 +15,6 @@ namespace mojo {
 
 template <>
 struct StructTraits<cc::mojom::RenderPass, std::unique_ptr<cc::RenderPass>> {
-  static void* SetUpContext(const std::unique_ptr<cc::RenderPass>& input);
-  static void TearDownContext(const std::unique_ptr<cc::RenderPass>& input,
-                              void* context);
-
   static const cc::RenderPassId& id(
       const std::unique_ptr<cc::RenderPass>& input) {
     return input->id;
@@ -49,17 +45,6 @@ struct StructTraits<cc::mojom::RenderPass, std::unique_ptr<cc::RenderPass>> {
     return input->quad_list;
   }
 
-  static const mojo::Array<uint32_t>& shared_quad_state_references(
-      const std::unique_ptr<cc::RenderPass>& input,
-      void* context) {
-    return *static_cast<mojo::Array<uint32_t>*>(context);
-  }
-
-  static const cc::SharedQuadStateList& shared_quad_state_list(
-      const std::unique_ptr<cc::RenderPass>& input) {
-    return input->shared_quad_state_list;
-  }
-
   static bool Read(cc::mojom::RenderPassDataView data,
                    std::unique_ptr<cc::RenderPass>* out);
 };

cc/ipc/shared_quad_state.mojom

@@ -28,7 +28,3 @@ struct SharedQuadState {
   uint32 blend_mode;
   int32 sorting_context_id;
 };
-
-struct SharedQuadStateList {
-  array<SharedQuadState> shared_quad_states;
-};

cc/ipc/shared_quad_state_struct_traits.h

@@ -10,6 +10,51 @@
 
 namespace mojo {
 
+struct OptSharedQuadState {
+  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(
@@ -63,53 +108,6 @@ struct StructTraits<cc::mojom::SharedQuadState, cc::SharedQuadState> {
   }
 };
 
-struct SharedQuadStateListArray {
-  cc::SharedQuadStateList* list;
-};
-
-template <>
-struct ArrayTraits<SharedQuadStateListArray> {
-  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 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;
-  }
-};
-
-template <>
-struct StructTraits<cc::mojom::SharedQuadStateList, cc::SharedQuadStateList> {
-  static SharedQuadStateListArray shared_quad_states(
-      const cc::SharedQuadStateList& list) {
-    return {const_cast<cc::SharedQuadStateList*>(&list)};
-  }
-
-  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_

cc/ipc/struct_traits_unittest.cc

@@ -63,14 +63,9 @@ class StructTraitsTest : public testing::Test, public mojom::TraitsTestService {
     callback.Run(f);
   }
 
-  void EchoQuadList(const QuadList& q,
-                    const EchoQuadListCallback& callback) override {
-    callback.Run(q);
-  }
-
-  void EchoRenderPass(const std::unique_ptr<RenderPass>& r,
+  void EchoRenderPass(std::unique_ptr<RenderPass> r,
                       const EchoRenderPassCallback& callback) override {
-    callback.Run(r);
+    callback.Run(std::move(r));
   }
 
   void EchoRenderPassId(const RenderPassId& r,
@@ -414,27 +409,31 @@ TEST_F(StructTraitsTest, FilterOperations) {
 }
 
 TEST_F(StructTraitsTest, QuadListBasic) {
-  SharedQuadState sqs;
-  QuadList input;
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+  render_pass->SetNew(RenderPassId(1, 1), gfx::Rect(), gfx::Rect(),
+                      gfx::Transform());
+
+  SharedQuadState* sqs = render_pass->CreateAndAppendSharedQuadState();
 
   const gfx::Rect rect1(1234, 4321, 1357, 7531);
   const SkColor color1 = SK_ColorRED;
   const int32_t width1 = 1337;
   DebugBorderDrawQuad* debug_quad =
-      input.AllocateAndConstruct<DebugBorderDrawQuad>();
-  debug_quad->SetNew(&sqs, rect1, rect1, color1, width1);
+      render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
+  debug_quad->SetNew(sqs, rect1, rect1, color1, width1);
 
   const gfx::Rect rect2(2468, 8642, 4321, 1234);
   const uint32_t color2 = 0xffffffff;
   const bool force_anti_aliasing_off = true;
   SolidColorDrawQuad* solid_quad =
-      input.AllocateAndConstruct<SolidColorDrawQuad>();
-  solid_quad->SetNew(&sqs, rect2, rect2, color2, force_anti_aliasing_off);
+      render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
+  solid_quad->SetNew(sqs, rect2, rect2, color2, force_anti_aliasing_off);
 
   const gfx::Rect rect3(1029, 3847, 5610, 2938);
   const SurfaceId surface_id(1234, 5678, 2468);
-  SurfaceDrawQuad* surface_quad = input.AllocateAndConstruct<SurfaceDrawQuad>();
-  surface_quad->SetNew(&sqs, rect3, rect3, surface_id);
+  SurfaceDrawQuad* surface_quad =
+      render_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
+  surface_quad->SetNew(sqs, rect3, rect3, surface_id);
 
   const gfx::Rect rect4(1234, 5678, 9101112, 13141516);
   const ResourceId resource_id4(1337);
@@ -451,8 +450,8 @@ TEST_F(StructTraitsTest, QuadListBasic) {
   background_filters.Append(FilterOperation::CreateSaturateFilter(2.f));
 
   RenderPassDrawQuad* render_pass_quad =
-      input.AllocateAndConstruct<RenderPassDrawQuad>();
-  render_pass_quad->SetNew(&sqs, rect4, rect4, render_pass_id, resource_id4,
+      render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
+  render_pass_quad->SetNew(sqs, rect4, rect4, render_pass_id, resource_id4,
                            mask_uv_scale, mask_texture_size, filters,
                            filters_scale, background_filters);
 
@@ -467,8 +466,8 @@ TEST_F(StructTraitsTest, QuadListBasic) {
   const bool nearest_neighbor = true;
   const bool secure_output_only = true;
   TextureDrawQuad* texture_draw_quad =
-      input.AllocateAndConstruct<TextureDrawQuad>();
-  texture_draw_quad->SetNew(&sqs, rect5, rect5, rect5, resource_id5,
+      render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
+  texture_draw_quad->SetNew(sqs, rect5, rect5, rect5, resource_id5,
                             premultiplied_alpha, uv_top_left, uv_bottom_right,
                             background_color, vertex_opacity, y_flipped,
                             nearest_neighbor, secure_output_only);
@@ -480,25 +479,25 @@ TEST_F(StructTraitsTest, QuadListBasic) {
                               9.8f, 8.1f, 7.3f, 6.3f, 5.7f, 4.8f, 3.4f, 2.4f,
                               1.2f);
   StreamVideoDrawQuad* stream_video_draw_quad =
-      input.AllocateAndConstruct<StreamVideoDrawQuad>();
-  stream_video_draw_quad->SetNew(&sqs, rect6, rect6, rect6, resource_id6,
+      render_pass->CreateAndAppendDrawQuad<StreamVideoDrawQuad>();
+  stream_video_draw_quad->SetNew(sqs, rect6, rect6, rect6, resource_id6,
                                  resource_size_in_pixels, matrix);
 
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
-  QuadList output;
-  proxy->EchoQuadList(input, &output);
+  std::unique_ptr<RenderPass> output;
+  proxy->EchoRenderPass(render_pass->DeepCopy(), &output);
 
-  ASSERT_EQ(input.size(), output.size());
+  ASSERT_EQ(render_pass->quad_list.size(), output->quad_list.size());
 
   const DebugBorderDrawQuad* out_debug_border_draw_quad =
-      DebugBorderDrawQuad::MaterialCast(output.ElementAt(0));
+      DebugBorderDrawQuad::MaterialCast(output->quad_list.ElementAt(0));
   EXPECT_EQ(rect1, out_debug_border_draw_quad->rect);
   EXPECT_EQ(rect1, out_debug_border_draw_quad->visible_rect);
   EXPECT_EQ(color1, out_debug_border_draw_quad->color);
   EXPECT_EQ(width1, out_debug_border_draw_quad->width);
 
   const SolidColorDrawQuad* out_solid_color_draw_quad =
-      SolidColorDrawQuad::MaterialCast(output.ElementAt(1));
+      SolidColorDrawQuad::MaterialCast(output->quad_list.ElementAt(1));
   EXPECT_EQ(rect2, out_solid_color_draw_quad->rect);
   EXPECT_EQ(rect2, out_solid_color_draw_quad->visible_rect);
   EXPECT_EQ(color2, out_solid_color_draw_quad->color);
@@ -506,13 +505,13 @@ TEST_F(StructTraitsTest, QuadListBasic) {
             out_solid_color_draw_quad->force_anti_aliasing_off);
 
   const SurfaceDrawQuad* out_surface_draw_quad =
-      SurfaceDrawQuad::MaterialCast(output.ElementAt(2));
+      SurfaceDrawQuad::MaterialCast(output->quad_list.ElementAt(2));
   EXPECT_EQ(rect3, out_surface_draw_quad->rect);
   EXPECT_EQ(rect3, out_surface_draw_quad->visible_rect);
   EXPECT_EQ(surface_id, out_surface_draw_quad->surface_id);
 
   const RenderPassDrawQuad* out_render_pass_draw_quad =
-      RenderPassDrawQuad::MaterialCast(output.ElementAt(3));
+      RenderPassDrawQuad::MaterialCast(output->quad_list.ElementAt(3));
   EXPECT_EQ(rect4, out_render_pass_draw_quad->rect);
   EXPECT_EQ(rect4, out_render_pass_draw_quad->visible_rect);
   EXPECT_EQ(render_pass_id, out_render_pass_draw_quad->render_pass_id);
@@ -529,7 +528,7 @@ TEST_F(StructTraitsTest, QuadListBasic) {
               out_render_pass_draw_quad->background_filters.at(i));
 
   const TextureDrawQuad* out_texture_draw_quad =
-      TextureDrawQuad::MaterialCast(output.ElementAt(4));
+      TextureDrawQuad::MaterialCast(output->quad_list.ElementAt(4));
   EXPECT_EQ(rect5, out_texture_draw_quad->rect);
   EXPECT_EQ(rect5, out_texture_draw_quad->opaque_rect);
   EXPECT_EQ(rect5, out_texture_draw_quad->visible_rect);
@@ -547,7 +546,7 @@ TEST_F(StructTraitsTest, QuadListBasic) {
   EXPECT_EQ(secure_output_only, out_texture_draw_quad->secure_output_only);
 
   const StreamVideoDrawQuad* out_stream_video_draw_quad =
-      StreamVideoDrawQuad::MaterialCast(output.ElementAt(5));
+      StreamVideoDrawQuad::MaterialCast(output->quad_list.ElementAt(5));
   EXPECT_EQ(rect6, out_stream_video_draw_quad->rect);
   EXPECT_EQ(rect6, out_stream_video_draw_quad->opaque_rect);
   EXPECT_EQ(rect6, out_stream_video_draw_quad->visible_rect);
@@ -606,7 +605,7 @@ TEST_F(StructTraitsTest, RenderPass) {
 
   std::unique_ptr<RenderPass> output;
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
-  proxy->EchoRenderPass(input, &output);
+  proxy->EchoRenderPass(input->DeepCopy(), &output);
 
   EXPECT_EQ(input->quad_list.size(), output->quad_list.size());
   EXPECT_EQ(input->shared_quad_state_list.size(),
@@ -681,7 +680,7 @@ TEST_F(StructTraitsTest, RenderPassWithEmptySharedQuadStateList) {
   // verify that the serialization code can deal with that.
   std::unique_ptr<RenderPass> output;
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
-  proxy->EchoRenderPass(input, &output);
+  proxy->EchoRenderPass(input->DeepCopy(), &output);
 
   EXPECT_EQ(input->quad_list.size(), output->quad_list.size());
   EXPECT_EQ(input->shared_quad_state_list.size(),
@@ -858,6 +857,10 @@ TEST_F(StructTraitsTest, TransferableResource) {
 }
 
 TEST_F(StructTraitsTest, YUVDrawQuad) {
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+  render_pass->SetNew(RenderPassId(1, 1), gfx::Rect(), gfx::Rect(),
+                      gfx::Transform());
+
   const DrawQuad::Material material = DrawQuad::YUV_VIDEO_CONTENT;
   const gfx::Rect rect(1234, 4321, 1357, 7531);
   const gfx::Rect opaque_rect(1357, 8642, 432, 123);
@@ -875,24 +878,24 @@ TEST_F(StructTraitsTest, YUVDrawQuad) {
   const float resource_offset = 1337.5f;
   const float resource_multiplier = 1234.6f;
 
-  SharedQuadState sqs;
-  QuadList input;
-  YUVVideoDrawQuad* quad = input.AllocateAndConstruct<YUVVideoDrawQuad>();
-  quad->SetAll(&sqs, rect, opaque_rect, visible_rect, needs_blending,
+  SharedQuadState* sqs = render_pass->CreateAndAppendSharedQuadState();
+  YUVVideoDrawQuad* quad =
+      render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>();
+  quad->SetAll(sqs, rect, opaque_rect, visible_rect, needs_blending,
                ya_tex_coord_rect, uv_tex_coord_rect, ya_tex_size, uv_tex_size,
                y_plane_resource_id, u_plane_resource_id, v_plane_resource_id,
                a_plane_resource_id, color_space, resource_offset,
                resource_multiplier);
 
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
-  QuadList output;
-  proxy->EchoQuadList(input, &output);
+  std::unique_ptr<RenderPass> output;
+  proxy->EchoRenderPass(render_pass->DeepCopy(), &output);
 
-  ASSERT_EQ(input.size(), output.size());
+  ASSERT_EQ(render_pass->quad_list.size(), output->quad_list.size());
 
-  ASSERT_EQ(material, output.ElementAt(0)->material);
+  ASSERT_EQ(material, output->quad_list.ElementAt(0)->material);
   const YUVVideoDrawQuad* out_quad =
-      YUVVideoDrawQuad::MaterialCast(output.ElementAt(0));
+      YUVVideoDrawQuad::MaterialCast(output->quad_list.ElementAt(0));
   EXPECT_EQ(rect, out_quad->rect);
   EXPECT_EQ(opaque_rect, out_quad->opaque_rect);
   EXPECT_EQ(visible_rect, out_quad->visible_rect);

cc/ipc/traits_test_service.mojom

@@ -38,9 +38,6 @@ interface TraitsTestService {
   [Sync]
   EchoFilterOperations(FilterOperations f) => (FilterOperations pass);
 
-  [Sync]
-  EchoQuadList(QuadList q) => (QuadList pass);
-
   [Sync]
   EchoRenderPass(RenderPass r) => (RenderPass pass);
 

cc/ipc/typemaps.gni

@@ -8,7 +8,6 @@ typemaps = [
   "//cc/ipc/compositor_frame_metadata.typemap",
   "//cc/ipc/filter_operation.typemap",
   "//cc/ipc/filter_operations.typemap",
-  "//cc/ipc/quads.typemap",
   "//cc/ipc/render_pass.typemap",
   "//cc/ipc/render_pass_id.typemap",
   "//cc/ipc/returned_resource.typemap",

cc/quads/render_pass.cc

@@ -98,51 +98,50 @@ std::unique_ptr<RenderPass> RenderPass::Copy(RenderPassId new_id) const {
   return copy_pass;
 }
 
-// static
-void RenderPass::CopyAll(const std::vector<std::unique_ptr<RenderPass>>& in,
-                         std::vector<std::unique_ptr<RenderPass>>* out) {
-  for (const auto& source : in) {
-    // Since we can't copy these, it's wrong to use CopyAll in a situation where
-    // you may have copy_requests present.
-    DCHECK_EQ(source->copy_requests.size(), 0u);
-
-    std::unique_ptr<RenderPass> copy_pass(Create(
-        source->shared_quad_state_list.size(), source->quad_list.size()));
-    copy_pass->SetAll(source->id,
-                      source->output_rect,
-                      source->damage_rect,
-                      source->transform_to_root_target,
-                      source->has_transparent_background);
-    for (auto* shared_quad_state : source->shared_quad_state_list) {
-      SharedQuadState* copy_shared_quad_state =
-          copy_pass->CreateAndAppendSharedQuadState();
-      *copy_shared_quad_state = *shared_quad_state;
+std::unique_ptr<RenderPass> RenderPass::DeepCopy() const {
+  // Since we can't copy these, it's wrong to use DeepCopy in a situation where
+  // you may have copy_requests present.
+  DCHECK_EQ(copy_requests.size(), 0u);
+
+  std::unique_ptr<RenderPass> copy_pass(
+      Create(shared_quad_state_list.size(), quad_list.size()));
+  copy_pass->SetAll(id, output_rect, damage_rect, transform_to_root_target,
+                    has_transparent_background);
+  for (auto* shared_quad_state : shared_quad_state_list) {
+    SharedQuadState* copy_shared_quad_state =
+        copy_pass->CreateAndAppendSharedQuadState();
+    *copy_shared_quad_state = *shared_quad_state;
+  }
+  SharedQuadStateList::ConstIterator sqs_iter = shared_quad_state_list.begin();
+  SharedQuadStateList::Iterator copy_sqs_iter =
+      copy_pass->shared_quad_state_list.begin();
+  for (auto* quad : quad_list) {
+    while (quad->shared_quad_state != *sqs_iter) {
+      ++sqs_iter;
+      ++copy_sqs_iter;
+      DCHECK(sqs_iter != shared_quad_state_list.end());
     }
-    SharedQuadStateList::Iterator sqs_iter =
-        source->shared_quad_state_list.begin();
-    SharedQuadStateList::Iterator copy_sqs_iter =
-        copy_pass->shared_quad_state_list.begin();
-    for (auto* quad : source->quad_list) {
-      while (quad->shared_quad_state != *sqs_iter) {
-        ++sqs_iter;
-        ++copy_sqs_iter;
-        DCHECK(sqs_iter != source->shared_quad_state_list.end());
-      }
-      DCHECK(quad->shared_quad_state == *sqs_iter);
-
-      SharedQuadState* copy_shared_quad_state = *copy_sqs_iter;
-
-      if (quad->material == DrawQuad::RENDER_PASS) {
-        const RenderPassDrawQuad* pass_quad =
-            RenderPassDrawQuad::MaterialCast(quad);
-        copy_pass->CopyFromAndAppendRenderPassDrawQuad(
-            pass_quad, copy_shared_quad_state, pass_quad->render_pass_id);
-      } else {
-        copy_pass->CopyFromAndAppendDrawQuad(quad, copy_shared_quad_state);
-      }
+    DCHECK(quad->shared_quad_state == *sqs_iter);
+
+    SharedQuadState* copy_shared_quad_state = *copy_sqs_iter;
+
+    if (quad->material == DrawQuad::RENDER_PASS) {
+      const RenderPassDrawQuad* pass_quad =
+          RenderPassDrawQuad::MaterialCast(quad);
+      copy_pass->CopyFromAndAppendRenderPassDrawQuad(
+          pass_quad, copy_shared_quad_state, pass_quad->render_pass_id);
+    } else {
+      copy_pass->CopyFromAndAppendDrawQuad(quad, copy_shared_quad_state);
     }
-    out->push_back(std::move(copy_pass));
   }
+  return copy_pass;
+}
+
+// static
+void RenderPass::CopyAll(const std::vector<std::unique_ptr<RenderPass>>& in,
+                         std::vector<std::unique_ptr<RenderPass>>* out) {
+  for (const auto& source : in)
+    out->push_back(source->DeepCopy());
 }
 
 void RenderPass::SetNew(RenderPassId id,

cc/quads/render_pass.h

@@ -68,6 +68,9 @@ class CC_EXPORT RenderPass {
   // requests.
   std::unique_ptr<RenderPass> Copy(RenderPassId new_id) const;
 
+  // A deep copy of the render pass that includes quads.
+  std::unique_ptr<RenderPass> DeepCopy() const;
+
   // A deep copy of the render passes in the list including the quads.
   static void CopyAll(const std::vector<std::unique_ptr<RenderPass>>& in,
                       std::vector<std::unique_ptr<RenderPass>>* out);

mojo/public/cpp/bindings/array_traits.h

@@ -47,7 +47,9 @@ namespace mojo {
 //     static void AdvanceIterator(Iterator& iterator);
 //
 //     // Returns a reference to the value at the current position of
-//     // |iterator|.
+//     // |iterator|. Optionally, the ConstIterator version of GetValue can
+//     // return by value instead of by reference if it makes sense for the
+//     // type.
 //     static const T& GetValue(ConstIterator& iterator);
 //     static T& GetValue(Iterator& iterator);
 //

mojo/public/cpp/bindings/lib/array_serialization.h

@@ -46,7 +46,7 @@ class ArrayIterator<Traits, MaybeConstUserType, true> {
   using GetNextResult =
       decltype(Traits::GetValue(std::declval<IteratorType&>()));
   GetNextResult GetNext() {
-    auto& value = Traits::GetValue(iter_);
+    GetNextResult value = Traits::GetValue(iter_);
     Traits::AdvanceIterator(iter_);
     return value;
   }
@@ -306,7 +306,8 @@ struct ArraySerializer<
 
     size_t size = input->GetSize();
     for (size_t i = 0; i < size; ++i) {
-      Serialize<Element>(input->GetNext(), &output->at(i), context);
+      typename UserTypeIterator::GetNextResult next = input->GetNext();
+      Serialize<Element>(next, &output->at(i), context);
 
       static const ValidationError kError =
           BelongsTo<Element,
@@ -361,8 +362,10 @@ struct ArraySerializer<MojomType,
                                   SerializationContext* context) {
     size_t element_count = input->GetSize();
     size_t size = sizeof(Data) + element_count * sizeof(typename Data::Element);
-    for (size_t i = 0; i < element_count; ++i)
-      size += PrepareToSerialize<Element>(input->GetNext(), context);
+    for (size_t i = 0; i < element_count; ++i) {
+      typename UserTypeIterator::GetNextResult next = input->GetNext();
+      size += PrepareToSerialize<Element>(next, context);
+    }
     return size;
   }
 
@@ -374,7 +377,8 @@ struct ArraySerializer<MojomType,
     size_t size = input->GetSize();
     for (size_t i = 0; i < size; ++i) {
       DataElementPtr data_ptr;
-      SerializeCaller<Element>::Run(input->GetNext(), buf, &data_ptr,
+      typename UserTypeIterator::GetNextResult next = input->GetNext();
+      SerializeCaller<Element>::Run(next, buf, &data_ptr,
                                     validate_params->element_validate_params,
                                     context);
       output->at(i).Set(data_ptr);
@@ -455,7 +459,8 @@ struct ArraySerializer<
     for (size_t i = 0; i < element_count; ++i) {
       // Call with |inlined| set to false, so that it will account for both the
       // data in the union and the space in the array used to hold the union.
-      size += PrepareToSerialize<Element>(input->GetNext(), false, context);
+      typename UserTypeIterator::GetNextResult next = input->GetNext();
+      size += PrepareToSerialize<Element>(next, false, context);
     }
     return size;
   }
@@ -468,7 +473,8 @@ struct ArraySerializer<
     size_t size = input->GetSize();
     for (size_t i = 0; i < size; ++i) {
       typename Data::Element* result = output->storage() + i;
-      Serialize<Element>(input->GetNext(), buf, &result, true, context);
+      typename UserTypeIterator::GetNextResult next = input->GetNext();
+      Serialize<Element>(next, buf, &result, true, context);
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           !validate_params->element_is_nullable && output->at(i).is_null(),
           VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,

mojo/public/cpp/bindings/lib/map_serialization.h

@@ -46,12 +46,15 @@ class MapKeyReader : public MapReaderBase<MaybeConstUserType> {
  public:
   using Base = MapReaderBase<MaybeConstUserType>;
   using Traits = typename Base::Traits;
+  using MaybeConstIterator = typename Base::MaybeConstIterator;
 
   explicit MapKeyReader(MaybeConstUserType& input) : Base(input) {}
   ~MapKeyReader() {}
 
-  const typename Traits::Key& GetNext() {
-    const typename Traits::Key& key = Traits::GetKey(this->iter_);
+  using GetNextResult =
+      decltype(Traits::GetKey(std::declval<MaybeConstIterator&>()));
+  GetNextResult GetNext() {
+    GetNextResult key = Traits::GetKey(this->iter_);
     Traits::AdvanceIterator(this->iter_);
     return key;
   }