cc mojo: Use ArrayDataViews in RenderPasses

cc/ipc/struct_traits_unittest.cc

Index: cc/ipc/struct_traits_unittest.cc
diff --git a/cc/ipc/struct_traits_unittest.cc b/cc/ipc/struct_traits_unittest.cc
index 7f49066890113247456814e00af77f54399eca57..e2fa608ce4ef20a2e86b2864f86cf5f57e7300fd 100644
--- a/cc/ipc/struct_traits_unittest.cc
+++ b/cc/ipc/struct_traits_unittest.cc
@@ -63,11 +63,6 @@ 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,
                       const EchoRenderPassCallback& callback) override {
     callback.Run(r);
@@ -414,6 +409,8 @@ TEST_F(StructTraitsTest, FilterOperations) {
 }
 
 TEST_F(StructTraitsTest, QuadListBasic) {
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+
   SharedQuadState sqs;
   QuadList input;

[danakj, 2016/07/28 23:37:51]

unused?

 
@@ -421,19 +418,20 @@ TEST_F(StructTraitsTest, QuadListBasic) {
   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);
@@ -451,7 +449,7 @@ TEST_F(StructTraitsTest, QuadListBasic) {
   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);
@@ -467,7 +465,7 @@ TEST_F(StructTraitsTest, QuadListBasic) {
   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,
@@ -480,25 +478,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>();
+      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, &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 +504,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 +527,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 +545,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);
@@ -858,6 +856,8 @@ TEST_F(StructTraitsTest, TransferableResource) {
 }
 
 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);
@@ -876,8 +876,8 @@ TEST_F(StructTraitsTest, YUVDrawQuad) {
   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,
@@ -885,14 +885,14 @@ TEST_F(StructTraitsTest, YUVDrawQuad) {
                resource_multiplier);
 
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
-  QuadList output;
-  proxy->EchoQuadList(input, &output);
+  std::unique_ptr<RenderPass> output;
+  proxy->EchoRenderPass(render_pass, &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);