Implement RenderPass StructTraits

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"
 #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"
 #include "third_party/skia/include/core/SkString.h"
 #include "third_party/skia/include/effects/SkDropShadowImageFilter.h"
 
 namespace cc {
 
 namespace {
 
@@ skipping 29 matching lines @@
       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,
+                      const EchoRenderPassCallback& callback) override {
+    callback.Run(r);
+  }
+
   void EchoRenderPassId(const RenderPassId& r,
                         const EchoRenderPassIdCallback& callback) override {
     callback.Run(r);
   }
 
   void EchoReturnedResource(
       const ReturnedResource& r,
       const EchoReturnedResourceCallback& callback) override {
     callback.Run(r);
   }
@@ skipping 203 matching lines @@
   for (size_t i = 0; i < input.size(); ++i) {
     EXPECT_EQ(input.at(i), output.at(i));
   }
 }
 
 TEST_F(StructTraitsTest, QuadListBasic) {
   const DrawQuad::Material material1 = DrawQuad::DEBUG_BORDER;
   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 =
       input.AllocateAndConstruct<DebugBorderDrawQuad>();
   debug_quad->material = material1;
   debug_quad->rect = rect1;
   debug_quad->width = width1;
 
   SolidColorDrawQuad* solid_quad =
       input.AllocateAndConstruct<SolidColorDrawQuad>();
   solid_quad->material = material2;
   solid_quad->rect = rect2;
   solid_quad->color = color2;
 
   SurfaceDrawQuad* surface_quad = input.AllocateAndConstruct<SurfaceDrawQuad>();
   surface_quad->material = material3;
   surface_quad->rect = rect3;
   surface_quad->surface_id = surface_id;
 
   RenderPassDrawQuad* render_pass_quad =
       input.AllocateAndConstruct<RenderPassDrawQuad>();
   render_pass_quad->material = material4;
   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);
 
   ASSERT_EQ(input.size(), output.size());
 
   ASSERT_EQ(material1, output.ElementAt(0)->material);
   EXPECT_EQ(rect1, output.ElementAt(0)->rect);
   EXPECT_EQ(width1,
             static_cast<DebugBorderDrawQuad*>(output.ElementAt(0))->width);
 
   ASSERT_EQ(material2, output.ElementAt(1)->material);
   EXPECT_EQ(rect2, output.ElementAt(1)->rect);
   EXPECT_EQ(color2,
             static_cast<SolidColorDrawQuad*>(output.ElementAt(1))->color);
 
   ASSERT_EQ(material3, output.ElementAt(2)->material);
   EXPECT_EQ(rect3, output.ElementAt(2)->rect);
   EXPECT_EQ(surface_id,
             static_cast<SurfaceDrawQuad*>(output.ElementAt(2))->surface_id);
 
   ASSERT_EQ(material4, output.ElementAt(3)->material);
   EXPECT_EQ(rect4, output.ElementAt(3)->rect);
   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) {
   const int layer_id = 1337;
   const uint32_t index = 0xdeadbeef;
   RenderPassId input(layer_id, index);
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
   RenderPassId output;
   proxy->EchoRenderPassId(input, &output);
   EXPECT_EQ(layer_id, output.layer_id);
@@ skipping 203 matching lines @@
   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