src/cc/quads/render_pass_unittest.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/quads/render_pass.h"
   6
   7 #include "cc/base/math_util.h"
   8 #include "cc/base/scoped_ptr_vector.h"
   9 #include "cc/output/copy_output_request.h"
  10 #include "cc/quads/checkerboard_draw_quad.h"
  11 #include "cc/quads/render_pass_draw_quad.h"
  12 #include "cc/test/geometry_test_utils.h"
  13 #include "cc/test/render_pass_test_common.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
  16 #include "ui/gfx/transform.h"
  17
  18 using cc::TestRenderPass;
  19
  20 namespace cc {
  21 namespace {
  22
  23 struct RenderPassSize {
  24   // If you add a new field to this class, make sure to add it to the
  25   // Copy() tests.
  26   RenderPass::Id id;
  27   QuadList quad_list;
  28   SharedQuadStateList shared_quad_state_list;
  29   gfx::Transform transform_to_root_target;
  30   gfx::Rect output_rect;
  31   gfx::RectF damage_rect;
  32   bool has_transparent_background;
  33   ScopedPtrVector<CopyOutputRequest> copy_callbacks;
  34 };
  35
  36 static void CompareRenderPassLists(const RenderPassList& expected_list,
  37                                    const RenderPassList& actual_list) {
  38   EXPECT_EQ(expected_list.size(), actual_list.size());
  39   for (size_t i = 0; i < actual_list.size(); ++i) {
  40     RenderPass* expected = expected_list[i];
  41     RenderPass* actual = actual_list[i];
  42
  43     EXPECT_EQ(expected->id, actual->id);
  44     EXPECT_RECT_EQ(expected->output_rect, actual->output_rect);
  45     EXPECT_EQ(expected->transform_to_root_target,
  46               actual->transform_to_root_target);
  47     EXPECT_RECT_EQ(expected->damage_rect, actual->damage_rect);
  48     EXPECT_EQ(expected->has_transparent_background,
  49               actual->has_transparent_background);
  50
  51     EXPECT_EQ(expected->shared_quad_state_list.size(),
  52               actual->shared_quad_state_list.size());
  53     EXPECT_EQ(expected->quad_list.size(), actual->quad_list.size());
  54
  55     for (size_t i = 0; i < expected->quad_list.size(); ++i) {
  56       EXPECT_EQ(expected->quad_list[i]->rect.ToString(),
  57                 actual->quad_list[i]->rect.ToString());
  58       EXPECT_EQ(
  59           expected->quad_list[i]->shared_quad_state->content_bounds.ToString(),
  60           actual->quad_list[i]->shared_quad_state->content_bounds.ToString());
  61     }
  62   }
  63 }
  64
  65 TEST(RenderPassTest, CopyShouldBeIdenticalExceptIdAndQuads) {
  66   RenderPass::Id id(3, 2);
  67   gfx::Rect output_rect(45, 22, 120, 13);
  68   gfx::Transform transform_to_root =
  69       gfx::Transform(1.0, 0.5, 0.5, -0.5, -1.0, 0.0);
  70   gfx::Rect damage_rect(56, 123, 19, 43);
  71   bool has_transparent_background = true;
  72
  73   scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
  74   pass->SetAll(id,
  75                output_rect,
  76                damage_rect,
  77                transform_to_root,
  78                has_transparent_background);
  79   pass->copy_requests.push_back(CopyOutputRequest::CreateEmptyRequest());
  80
  81   // Stick a quad in the pass, this should not get copied.
  82   scoped_ptr<SharedQuadState> shared_state = SharedQuadState::Create();
  83   shared_state->SetAll(
  84       gfx::Transform(), gfx::Size(), gfx::Rect(), gfx::Rect(), false, 1);
  85   pass->AppendSharedQuadState(shared_state.Pass());
  86
  87   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad =
  88       CheckerboardDrawQuad::Create();
  89   checkerboard_quad->SetNew(
  90       pass->shared_quad_state_list.back(), gfx::Rect(), SkColor());
  91   pass->quad_list.push_back(checkerboard_quad.PassAs<DrawQuad>());
  92
  93   RenderPass::Id new_id(63, 4);
  94
  95   scoped_ptr<RenderPass> copy = pass->Copy(new_id);
  96   EXPECT_EQ(new_id, copy->id);
  97   EXPECT_RECT_EQ(pass->output_rect, copy->output_rect);
  98   EXPECT_EQ(pass->transform_to_root_target, copy->transform_to_root_target);
  99   EXPECT_RECT_EQ(pass->damage_rect, copy->damage_rect);
 100   EXPECT_EQ(pass->has_transparent_background, copy->has_transparent_background);
 101   EXPECT_EQ(0u, copy->quad_list.size());
 102
 103   // The copy request should not be copied/duplicated.
 104   EXPECT_EQ(1u, pass->copy_requests.size());
 105   EXPECT_EQ(0u, copy->copy_requests.size());
 106
 107   EXPECT_EQ(sizeof(RenderPassSize), sizeof(RenderPass));
 108 }
 109
 110 TEST(RenderPassTest, CopyAllShouldBeIdentical) {
 111   RenderPassList pass_list;
 112
 113   RenderPass::Id id(3, 2);
 114   gfx::Rect output_rect(45, 22, 120, 13);
 115   gfx::Transform transform_to_root =
 116       gfx::Transform(1.0, 0.5, 0.5, -0.5, -1.0, 0.0);
 117   gfx::Rect damage_rect(56, 123, 19, 43);
 118   bool has_transparent_background = true;
 119
 120   scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
 121   pass->SetAll(id,
 122                output_rect,
 123                damage_rect,
 124                transform_to_root,
 125                has_transparent_background);
 126
 127   // Two quads using one shared state.
 128   scoped_ptr<SharedQuadState> shared_state1 = SharedQuadState::Create();
 129   shared_state1->SetAll(
 130       gfx::Transform(), gfx::Size(1, 1), gfx::Rect(), gfx::Rect(), false, 1);
 131   pass->AppendSharedQuadState(shared_state1.Pass());
 132
 133   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad1 =
 134       CheckerboardDrawQuad::Create();
 135   checkerboard_quad1->SetNew(
 136       pass->shared_quad_state_list.back(), gfx::Rect(1, 1, 1, 1), SkColor());
 137   pass->quad_list.push_back(checkerboard_quad1.PassAs<DrawQuad>());
 138
 139   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad2 =
 140       CheckerboardDrawQuad::Create();
 141   checkerboard_quad2->SetNew(
 142       pass->shared_quad_state_list.back(), gfx::Rect(2, 2, 2, 2), SkColor());
 143   pass->quad_list.push_back(checkerboard_quad2.PassAs<DrawQuad>());
 144
 145   // And two quads using another shared state.
 146   scoped_ptr<SharedQuadState> shared_state2 = SharedQuadState::Create();
 147   shared_state2->SetAll(
 148       gfx::Transform(), gfx::Size(2, 2), gfx::Rect(), gfx::Rect(), false, 1);
 149   pass->AppendSharedQuadState(shared_state2.Pass());
 150
 151   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad3 =
 152       CheckerboardDrawQuad::Create();
 153   checkerboard_quad3->SetNew(
 154       pass->shared_quad_state_list.back(), gfx::Rect(3, 3, 3, 3), SkColor());
 155   pass->quad_list.push_back(checkerboard_quad3.PassAs<DrawQuad>());
 156
 157   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad4 =
 158       CheckerboardDrawQuad::Create();
 159   checkerboard_quad4->SetNew(
 160       pass->shared_quad_state_list.back(), gfx::Rect(4, 4, 4, 4), SkColor());
 161   pass->quad_list.push_back(checkerboard_quad4.PassAs<DrawQuad>());
 162
 163   // A second render pass with a quad.
 164   RenderPass::Id contrib_id(4, 1);
 165   gfx::Rect contrib_output_rect(10, 15, 12, 17);
 166   gfx::Transform contrib_transform_to_root =
 167       gfx::Transform(1.0, 0.5, 0.5, -0.5, -1.0, 0.0);
 168   gfx::Rect contrib_damage_rect(11, 16, 10, 15);
 169   bool contrib_has_transparent_background = true;
 170
 171   scoped_ptr<TestRenderPass> contrib = TestRenderPass::Create();
 172   contrib->SetAll(contrib_id,
 173                   contrib_output_rect,
 174                   contrib_damage_rect,
 175                   contrib_transform_to_root,
 176                   contrib_has_transparent_background);
 177
 178   scoped_ptr<SharedQuadState> contrib_shared_state = SharedQuadState::Create();
 179   contrib_shared_state->SetAll(
 180       gfx::Transform(), gfx::Size(2, 2), gfx::Rect(), gfx::Rect(), false, 1);
 181   contrib->AppendSharedQuadState(contrib_shared_state.Pass());
 182
 183   scoped_ptr<CheckerboardDrawQuad> contrib_quad =
 184       CheckerboardDrawQuad::Create();
 185   contrib_quad->SetNew(
 186       contrib->shared_quad_state_list.back(), gfx::Rect(3, 3, 3, 3), SkColor());
 187   contrib->quad_list.push_back(contrib_quad.PassAs<DrawQuad>());
 188
 189   // And a RenderPassDrawQuad for the contributing pass.
 190   scoped_ptr<RenderPassDrawQuad> pass_quad = RenderPassDrawQuad::Create();
 191   pass_quad->SetNew(pass->shared_quad_state_list.back(),
 192                     contrib_output_rect,
 193                     contrib_id,
 194                     false,  // is_replica
 195                     0,      // mask_resource_id
 196                     contrib_damage_rect,
 197                     gfx::RectF(),  // mask_uv_rect
 198                     FilterOperations(),
 199                     FilterOperations());
 200   pass->quad_list.push_back(pass_quad.PassAs<DrawQuad>());
 201
 202   pass_list.push_back(pass.PassAs<RenderPass>());
 203   pass_list.push_back(contrib.PassAs<RenderPass>());
 204
 205   // Make a copy with CopyAll().
 206   RenderPassList copy_list;
 207   RenderPass::CopyAll(pass_list, &copy_list);
 208
 209   CompareRenderPassLists(pass_list, copy_list);
 210 }
 211
 212 TEST(RenderPassTest, CopyAllWithCulledQuads) {
 213   RenderPassList pass_list;
 214
 215   RenderPass::Id id(3, 2);
 216   gfx::Rect output_rect(45, 22, 120, 13);
 217   gfx::Transform transform_to_root =
 218       gfx::Transform(1.0, 0.5, 0.5, -0.5, -1.0, 0.0);
 219   gfx::Rect damage_rect(56, 123, 19, 43);
 220   bool has_transparent_background = true;
 221
 222   scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
 223   pass->SetAll(id,
 224                output_rect,
 225                damage_rect,
 226                transform_to_root,
 227                has_transparent_background);
 228
 229   // A shared state with a quad.
 230   scoped_ptr<SharedQuadState> shared_state1 = SharedQuadState::Create();
 231   shared_state1->SetAll(
 232       gfx::Transform(), gfx::Size(1, 1), gfx::Rect(), gfx::Rect(), false, 1);
 233   pass->AppendSharedQuadState(shared_state1.Pass());
 234
 235   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad1 =
 236       CheckerboardDrawQuad::Create();
 237   checkerboard_quad1->SetNew(
 238       pass->shared_quad_state_list.back(), gfx::Rect(1, 1, 1, 1), SkColor());
 239   pass->quad_list.push_back(checkerboard_quad1.PassAs<DrawQuad>());
 240
 241   // A shared state with no quads, they were culled.
 242   scoped_ptr<SharedQuadState> shared_state2 = SharedQuadState::Create();
 243   shared_state2->SetAll(
 244       gfx::Transform(), gfx::Size(2, 2), gfx::Rect(), gfx::Rect(), false, 1);
 245   pass->AppendSharedQuadState(shared_state2.Pass());
 246
 247   // A second shared state with no quads.
 248   scoped_ptr<SharedQuadState> shared_state3 = SharedQuadState::Create();
 249   shared_state3->SetAll(
 250       gfx::Transform(), gfx::Size(2, 2), gfx::Rect(), gfx::Rect(), false, 1);
 251   pass->AppendSharedQuadState(shared_state3.Pass());
 252
 253   // A last shared state with a quad again.
 254   scoped_ptr<SharedQuadState> shared_state4 = SharedQuadState::Create();
 255   shared_state4->SetAll(
 256       gfx::Transform(), gfx::Size(2, 2), gfx::Rect(), gfx::Rect(), false, 1);
 257   pass->AppendSharedQuadState(shared_state4.Pass());
 258
 259   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad2 =
 260       CheckerboardDrawQuad::Create();
 261   checkerboard_quad2->SetNew(
 262       pass->shared_quad_state_list.back(), gfx::Rect(3, 3, 3, 3), SkColor());
 263   pass->quad_list.push_back(checkerboard_quad2.PassAs<DrawQuad>());
 264
 265   pass_list.push_back(pass.PassAs<RenderPass>());
 266
 267   // Make a copy with CopyAll().
 268   RenderPassList copy_list;
 269   RenderPass::CopyAll(pass_list, &copy_list);
 270
 271   CompareRenderPassLists(pass_list, copy_list);
 272 }
 273
 274 }  // namespace
 275 }  // namespace cc