Implement RenderPass StructTraits

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 f958558e2b86acfb3f5e6a2979a5e6a70af45752..b3b7b3df82cbcc084fead4b7ad63dbe8cd1776e9 100644
--- a/cc/ipc/struct_traits_unittest.cc
+++ b/cc/ipc/struct_traits_unittest.cc
@@ -11,6 +11,7 @@
 #include "cc/quads/render_pass_id.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
+#include "cc/quads/texture_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -60,6 +61,11 @@ class StructTraitsTest : public testing::Test, public mojom::TraitsTestService {
     callback.Run(q);
   }
 
+  void EchoRenderPass(const std::unique_ptr<RenderPass>& r,
+                      const EchoRenderPassCallback& callback) override {
+    callback.Run(r);
+  }
+
   void EchoRenderPassId(const RenderPassId& r,
                         const EchoRenderPassIdCallback& callback) override {
     callback.Run(r);
@@ -283,14 +289,17 @@ TEST_F(StructTraitsTest, QuadListBasic) {
   const DrawQuad::Material material2 = DrawQuad::SOLID_COLOR;
   const DrawQuad::Material material3 = DrawQuad::SURFACE_CONTENT;
   const DrawQuad::Material material4 = DrawQuad::RENDER_PASS;
+  const DrawQuad::Material material5 = DrawQuad::TEXTURE_CONTENT;
   const gfx::Rect rect1(1234, 4321, 1357, 7531);
   const gfx::Rect rect2(2468, 8642, 4321, 1234);
   const gfx::Rect rect3(1029, 3847, 5610, 2938);
   const gfx::Rect rect4(1234, 5678, 9101112, 13141516);
+  const gfx::Rect rect5(123, 567, 91011, 131415);
   const int32_t width1 = 1337;
   const uint32_t color2 = 0xffffffff;
   const SurfaceId surface_id(1234, 5678, 2468);
   const RenderPassId render_pass_id(1234, 5678);
+  const float vertex_opacity[4] = {1.f, 2.f, 3.f, 4.f};
 
   QuadList input;
   DebugBorderDrawQuad* debug_quad =
@@ -316,6 +325,15 @@ TEST_F(StructTraitsTest, QuadListBasic) {
   render_pass_quad->rect = rect4;
   render_pass_quad->render_pass_id = render_pass_id;
 
+  TextureDrawQuad* texture_draw_quad =
+      input.AllocateAndConstruct<TextureDrawQuad>();
+  texture_draw_quad->material = material5;

[danakj, 2016/06/22 00:05:09]

You should be calling TextureDrawQuad::SetNew() or SetAll(), not setting fields
manually. Otherwise it's easy to miss fields now or when they get added.

The same goes for all the other quads here.

[Fady Samuel, 2016/06/22 20:08:14]

We don't serialize SharedQuadState here, and so attaching it to a DrawQuad to
avoid a DCHECK.

+  texture_draw_quad->rect = rect5;
+  texture_draw_quad->vertex_opacity[0] = vertex_opacity[0];
+  texture_draw_quad->vertex_opacity[1] = vertex_opacity[1];
+  texture_draw_quad->vertex_opacity[2] = vertex_opacity[2];
+  texture_draw_quad->vertex_opacity[3] = vertex_opacity[3];
+
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
   QuadList output;
   proxy->EchoQuadList(input, &output);
@@ -342,6 +360,69 @@ TEST_F(StructTraitsTest, QuadListBasic) {
   EXPECT_EQ(
       render_pass_id,
       static_cast<RenderPassDrawQuad*>(output.ElementAt(3))->render_pass_id);
+
+  ASSERT_EQ(material5, output.ElementAt(4)->material);
+  EXPECT_EQ(rect5, output.ElementAt(4)->rect);
+  EXPECT_EQ(
+      vertex_opacity[0],
+      static_cast<TextureDrawQuad*>(output.ElementAt(4))->vertex_opacity[0]);
+  EXPECT_EQ(
+      vertex_opacity[1],
+      static_cast<TextureDrawQuad*>(output.ElementAt(4))->vertex_opacity[1]);
+  EXPECT_EQ(
+      vertex_opacity[2],
+      static_cast<TextureDrawQuad*>(output.ElementAt(4))->vertex_opacity[2]);
+  EXPECT_EQ(
+      vertex_opacity[3],
+      static_cast<TextureDrawQuad*>(output.ElementAt(4))->vertex_opacity[3]);
+}
+
+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 = input->CreateAndAppendSharedQuadState();
+  shared_state->SetAll(gfx::Transform(), gfx::Size(), gfx::Rect(), gfx::Rect(),

[danakj, 2016/06/22 00:05:09]

how about using some non-0/false stuff, its easy to pass with 0s when it
shouldn't

[Fady Samuel, 2016/06/22 20:08:14]

Done.

+                       false, 1, SkXfermode::kSrcOver_Mode, 0);
+
+  SolidColorDrawQuad* color_quad =
+      input->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
+  color_quad->SetNew(input->shared_quad_state_list.back(), gfx::Rect(),
+                     gfx::Rect(), SkColor(), false);

[danakj, 2016/06/22 00:05:09]

dittos

[Fady Samuel, 2016/06/22 20:08:14]

Done.

+  std::unique_ptr<RenderPass> output;
+  mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
+  proxy->EchoRenderPass(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(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_sqs = output->shared_quad_state_list.ElementAt(0);
+  EXPECT_EQ(shared_state->quad_to_target_transform,
+            out_sqs->quad_to_target_transform);
+  EXPECT_EQ(shared_state->quad_layer_bounds, out_sqs->quad_layer_bounds);
+  EXPECT_EQ(shared_state->visible_quad_layer_rect,
+            out_sqs->visible_quad_layer_rect);
+  EXPECT_EQ(shared_state->clip_rect, out_sqs->clip_rect);
+  EXPECT_EQ(shared_state->is_clipped, out_sqs->is_clipped);
+  EXPECT_EQ(shared_state->opacity, out_sqs->opacity);
+  EXPECT_EQ(shared_state->blend_mode, out_sqs->blend_mode);
+  EXPECT_EQ(shared_state->sorting_context_id, out_sqs->sorting_context_id);
+
+  DrawQuad* out_draw_quad = output->quad_list.ElementAt(0);

[danakj, 2016/06/22 00:05:09]

Can you test with multiple quads in 1 SQS, and multiple SQSs? I think this test
is a bit too trivial right now

[Fady Samuel, 2016/06/22 20:08:14]

Done.

+  EXPECT_EQ(out_draw_quad->shared_quad_state, out_sqs);
 }
 
 TEST_F(StructTraitsTest, RenderPassId) {