cc mojo: Use ArrayDataViews in RenderPasses

cc/ipc/struct_traits_unittest.cc

 // 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.
 
 #include "base/message_loop/message_loop.h"
 #include "cc/input/selection.h"
 #include "cc/ipc/traits_test_service.mojom.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
@@ skipping 45 matching lines @@
       const EchoFilterOperationCallback& callback) override {
     callback.Run(f);
   }
 
   void EchoFilterOperations(
       const FilterOperations& f,
       const EchoFilterOperationsCallback& callback) override {
     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,
                         const EchoRenderPassIdCallback& callback) override {
     callback.Run(r);
   }
 
   void EchoReturnedResource(
       const ReturnedResource& r,
       const EchoReturnedResourceCallback& callback) override {
@@ skipping 323 matching lines @@
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
   FilterOperations output;
   proxy->EchoFilterOperations(input, &output);
   EXPECT_EQ(input.size(), output.size());
   for (size_t i = 0; i < input.size(); ++i) {
     EXPECT_EQ(input.at(i), output.at(i));
   }
 }
 
 TEST_F(StructTraitsTest, QuadListBasic) {
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+
   SharedQuadState sqs;
-  QuadList input;
 
   const gfx::Rect rect1(1234, 4321, 1357, 7531);
   const SkColor color1 = SK_ColorRED;
   const int32_t width1 = 1337;
   DebugBorderDrawQuad* debug_quad =
-      input.AllocateAndConstruct<DebugBorderDrawQuad>();
+      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>();
+      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>();
+  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);
   const RenderPassId render_pass_id(1234, 5678);
   const gfx::Vector2dF mask_uv_scale(1337.1f, 1234.2f);
   const gfx::Size mask_texture_size(1234, 5678);
   FilterOperations filters;
   filters.Append(FilterOperation::CreateBlurFilter(0.f));
   filters.Append(FilterOperation::CreateZoomFilter(2.0f, 1));
   gfx::Vector2dF filters_scale(1234.1f, 4321.2f);
   FilterOperations background_filters;
   background_filters.Append(FilterOperation::CreateSaturateFilter(4.f));
   background_filters.Append(FilterOperation::CreateZoomFilter(2.0f, 1));
   background_filters.Append(FilterOperation::CreateSaturateFilter(2.f));
 
   RenderPassDrawQuad* render_pass_quad =
-      input.AllocateAndConstruct<RenderPassDrawQuad>();
+      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);
 
   const gfx::Rect rect5(123, 567, 91011, 131415);
   const ResourceId resource_id5(1337);
   const float vertex_opacity[4] = {1.f, 2.f, 3.f, 4.f};
   const bool premultiplied_alpha = true;
   const gfx::PointF uv_top_left(12.1f, 34.2f);
   const gfx::PointF uv_bottom_right(56.3f, 78.4f);
   const SkColor background_color = SK_ColorGREEN;
   const bool y_flipped = true;
   const bool nearest_neighbor = true;
   const bool secure_output_only = true;
   TextureDrawQuad* texture_draw_quad =
-      input.AllocateAndConstruct<TextureDrawQuad>();
+      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);
 
   const gfx::Rect rect6(321, 765, 11109, 151413);
   const ResourceId resource_id6(1234);
   const gfx::Size resource_size_in_pixels(1234, 5678);
   const gfx::Transform matrix(16.1f, 15.3f, 14.3f, 13.7f, 12.2f, 11.4f, 10.4f,
                               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>();
+      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(std::move(render_pass), &output);
 
-  ASSERT_EQ(input.size(), output.size());
+  ASSERT_EQ(6u, output->quad_list.size());

[danakj, 2016/07/29 20:35:57]

store this before moving it rather than hardcoding?

[Fady Samuel, 2016/07/29 21:06:31]

Restored original code.

 
   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);
   EXPECT_EQ(force_anti_aliasing_off,
             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);
   EXPECT_EQ(resource_id4, out_render_pass_draw_quad->mask_resource_id());
   EXPECT_EQ(mask_texture_size, out_render_pass_draw_quad->mask_texture_size);
   EXPECT_EQ(filters.size(), out_render_pass_draw_quad->filters.size());
   for (size_t i = 0; i < filters.size(); ++i)
     EXPECT_EQ(filters.at(i), out_render_pass_draw_quad->filters.at(i));
   EXPECT_EQ(filters_scale, out_render_pass_draw_quad->filters_scale);
   EXPECT_EQ(background_filters.size(),
             out_render_pass_draw_quad->background_filters.size());
   for (size_t i = 0; i < background_filters.size(); ++i)
     EXPECT_EQ(background_filters.at(i),
               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);
   EXPECT_EQ(resource_id5, out_texture_draw_quad->resource_id());
   EXPECT_EQ(premultiplied_alpha, out_texture_draw_quad->premultiplied_alpha);
   EXPECT_EQ(uv_top_left, out_texture_draw_quad->uv_top_left);
   EXPECT_EQ(uv_bottom_right, out_texture_draw_quad->uv_bottom_right);
   EXPECT_EQ(background_color, out_texture_draw_quad->background_color);
   EXPECT_EQ(vertex_opacity[0], out_texture_draw_quad->vertex_opacity[0]);
   EXPECT_EQ(vertex_opacity[1], out_texture_draw_quad->vertex_opacity[1]);
   EXPECT_EQ(vertex_opacity[2], out_texture_draw_quad->vertex_opacity[2]);
   EXPECT_EQ(vertex_opacity[3], out_texture_draw_quad->vertex_opacity[3]);
   EXPECT_EQ(y_flipped, out_texture_draw_quad->y_flipped);
   EXPECT_EQ(nearest_neighbor, out_texture_draw_quad->nearest_neighbor);
   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);
   EXPECT_EQ(resource_id6, out_stream_video_draw_quad->resource_id());
   EXPECT_EQ(resource_size_in_pixels,
             out_stream_video_draw_quad->resource_size_in_pixels());
   EXPECT_EQ(matrix, out_stream_video_draw_quad->matrix);
 }
 
 TEST_F(StructTraitsTest, RenderPass) {
   const RenderPassId id(3, 2);
   const gfx::Rect output_rect(45, 22, 120, 13);
   const gfx::Transform transform_to_root =
       gfx::Transform(1.0, 0.5, 0.5, -0.5, -1.0, 0.0);
   const gfx::Rect damage_rect(56, 123, 19, 43);
   const bool has_transparent_background = true;
   std::unique_ptr<RenderPass> input = RenderPass::Create();
+
   input->SetAll(id, output_rect, damage_rect, transform_to_root,
                 has_transparent_background);
 
   SharedQuadState* shared_state_1 = input->CreateAndAppendSharedQuadState();
   shared_state_1->SetAll(
       gfx::Transform(16.1f, 15.3f, 14.3f, 13.7f, 12.2f, 11.4f, 10.4f, 9.8f,
                      8.1f, 7.3f, 6.3f, 5.7f, 4.8f, 3.4f, 2.4f, 1.2f),
       gfx::Size(1, 2), gfx::Rect(1337, 5679, 9101112, 131415),
       gfx::Rect(1357, 2468, 121314, 1337), true, 2, SkXfermode::kSrcOver_Mode,
       1);
@@ skipping 19 matching lines @@
   const gfx::Rect color_quad_rect(123, 456, 789, 101);
   color_quad->SetNew(shared_state_2, color_quad_rect, color_quad_rect,
                      SK_ColorRED, true);
 
   SurfaceDrawQuad* surface_quad =
       input->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   const gfx::Rect surface_quad_rect(1337, 2448, 1234, 5678);
   surface_quad->SetNew(shared_state_2, surface_quad_rect, surface_quad_rect,
                        SurfaceId(1337, 1234, 2468));
 
+  std::unique_ptr<RenderPass> input_echo;
+  {
+    RenderPassList pass_list;

[danakj, 2016/07/29 20:35:57]

This is pretty roundabout to make a copy of a RenderPass.

Can you either
- leave a comment explaining that this is deep-copying the |input| render pass
into |input_echo|.
- make a helper function with a name that explains that and call it
- split RenderPass::CopyAll into RenderPass::Copy which CopyAll calls, and use
that.

Or.. alternatively.. is it possible to have EchoRenderPass return ownership of
the input?

[Fady Samuel, 2016/07/29 21:06:31]

I agree. I hate it too :P I introduced RenderPass::DeepCopy. I now pass
EchoRenderPass a DeepCopy instead and most code remains unchanged! Thanks!

+    pass_list.push_back(std::move(input));
+
+    RenderPassList echo_pass_list;
+    RenderPass::CopyAll(pass_list, &echo_pass_list);
+
+    input = std::move(pass_list.front());
+    input_echo = std::move(echo_pass_list.front());
+  }
+
   std::unique_ptr<RenderPass> output;
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
-  proxy->EchoRenderPass(input, &output);
+  proxy->EchoRenderPass(std::move(input_echo), &output);
 
-  EXPECT_EQ(input->quad_list.size(), output->quad_list.size());
-  EXPECT_EQ(input->shared_quad_state_list.size(),
-            output->shared_quad_state_list.size());
+  EXPECT_EQ(3u, output->quad_list.size());

[danakj, 2016/07/29 20:35:57]

save it here also?

[Fady Samuel, 2016/07/29 21:06:31]

Restored original.

+  EXPECT_EQ(2u, output->shared_quad_state_list.size());
   EXPECT_EQ(id, output->id);
   EXPECT_EQ(output_rect, output->output_rect);
   EXPECT_EQ(damage_rect, output->damage_rect);
   EXPECT_EQ(transform_to_root, output->transform_to_root_target);
   EXPECT_EQ(has_transparent_background, output->has_transparent_background);
 
   SharedQuadState* out_sqs1 = output->shared_quad_state_list.ElementAt(0);
   EXPECT_EQ(shared_state_1->quad_to_target_transform,
             out_sqs1->quad_to_target_transform);
   EXPECT_EQ(shared_state_1->quad_layer_bounds, out_sqs1->quad_layer_bounds);
@@ skipping 50 matching lines @@
   const gfx::Rect damage_rect(56, 123, 19, 43);
   const bool has_transparent_background = true;
   std::unique_ptr<RenderPass> input = RenderPass::Create();
   input->SetAll(id, output_rect, damage_rect, transform_to_root,
                 has_transparent_background);
 
   // Unlike the previous test, don't add any quads to the list; we need to
   // verify that the serialization code can deal with that.
   std::unique_ptr<RenderPass> output;
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
-  proxy->EchoRenderPass(input, &output);
+  proxy->EchoRenderPass(std::move(input), &output);
 
-  EXPECT_EQ(input->quad_list.size(), output->quad_list.size());
-  EXPECT_EQ(input->shared_quad_state_list.size(),
-            output->shared_quad_state_list.size());
+  EXPECT_EQ(0u, output->quad_list.size());
+  EXPECT_EQ(0u, output->shared_quad_state_list.size());
   EXPECT_EQ(id, output->id);
   EXPECT_EQ(output_rect, output->output_rect);
   EXPECT_EQ(damage_rect, output->damage_rect);
   EXPECT_EQ(transform_to_root, output->transform_to_root_target);
   EXPECT_EQ(has_transparent_background, output->has_transparent_background);
 }
 
 TEST_F(StructTraitsTest, RenderPassId) {
   const int layer_id = 1337;
   const uint32_t index = 0xdeadbeef;
@@ skipping 152 matching lines @@
   EXPECT_EQ(mailbox_holder.mailbox, output.mailbox_holder.mailbox);
   EXPECT_EQ(mailbox_holder.sync_token, output.mailbox_holder.sync_token);
   EXPECT_EQ(mailbox_holder.texture_target,
             output.mailbox_holder.texture_target);
   EXPECT_EQ(read_lock_fences_enabled, output.read_lock_fences_enabled);
   EXPECT_EQ(is_software, output.is_software);
   EXPECT_EQ(is_overlay_candidate, output.is_overlay_candidate);
 }
 
 TEST_F(StructTraitsTest, YUVDrawQuad) {
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+
   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);
   const gfx::Rect visible_rect(1337, 7331, 561, 293);
   const bool needs_blending = true;
   const gfx::RectF ya_tex_coord_rect(1234.1f, 5678.2f, 9101112.3f, 13141516.4f);
   const gfx::RectF uv_tex_coord_rect(1234.1f, 4321.2f, 1357.3f, 7531.4f);
   const gfx::Size ya_tex_size(1234, 5678);
   const gfx::Size uv_tex_size(4321, 8765);
   const uint32_t y_plane_resource_id = 1337;
   const uint32_t u_plane_resource_id = 1234;
   const uint32_t v_plane_resource_id = 2468;
   const uint32_t a_plane_resource_id = 7890;
   const YUVVideoDrawQuad::ColorSpace color_space = YUVVideoDrawQuad::JPEG;
   const float resource_offset = 1337.5f;
   const float resource_multiplier = 1234.6f;
 
   SharedQuadState sqs;
-  QuadList input;
-  YUVVideoDrawQuad* quad = input.AllocateAndConstruct<YUVVideoDrawQuad>();
+  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(std::move(render_pass), &output);
 
-  ASSERT_EQ(input.size(), output.size());
+  ASSERT_EQ(1u, output->quad_list.size());

[danakj, 2016/07/29 20:35:57]

ditto, save it?

[Fady Samuel, 2016/07/29 21:06:31]

Restored.

 
-  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);
   EXPECT_EQ(needs_blending, out_quad->needs_blending);
   EXPECT_EQ(ya_tex_coord_rect, out_quad->ya_tex_coord_rect);
   EXPECT_EQ(uv_tex_coord_rect, out_quad->uv_tex_coord_rect);
   EXPECT_EQ(ya_tex_size, out_quad->ya_tex_size);
   EXPECT_EQ(uv_tex_size, out_quad->uv_tex_size);
   EXPECT_EQ(y_plane_resource_id, out_quad->y_plane_resource_id());
   EXPECT_EQ(u_plane_resource_id, out_quad->u_plane_resource_id());
   EXPECT_EQ(v_plane_resource_id, out_quad->v_plane_resource_id());
   EXPECT_EQ(a_plane_resource_id, out_quad->a_plane_resource_id());
   EXPECT_EQ(color_space, out_quad->color_space);
   EXPECT_EQ(resource_offset, out_quad->resource_offset);
   EXPECT_EQ(resource_multiplier, out_quad->resource_multiplier);
 }
 
 }  // namespace cc