cc/trees/quad_culler_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/trees/quad_culler.h"
   6
   7 #include <vector>
   8
   9 #include "cc/base/math_util.h"
  10 #include "cc/debug/overdraw_metrics.h"
  11 #include "cc/layers/append_quads_data.h"
  12 #include "cc/layers/render_surface_impl.h"
  13 #include "cc/layers/tiled_layer_impl.h"
  14 #include "cc/quads/tile_draw_quad.h"
  15 #include "cc/resources/layer_tiling_data.h"
  16 #include "cc/test/fake_impl_proxy.h"
  17 #include "cc/test/fake_layer_tree_host_impl.h"
  18 #include "cc/trees/occlusion_tracker.h"
  19 #include "cc/trees/single_thread_proxy.h"
  20 #include "testing/gmock/include/gmock/gmock.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22 #include "ui/gfx/transform.h"
  23
  24 namespace cc {
  25 namespace {
  26
  27 class TestOcclusionTrackerImpl : public OcclusionTrackerImpl {
  28  public:
  29   TestOcclusionTrackerImpl(gfx::Rect scissor_rect_in_screen,
  30                            bool record_metrics_for_frame = true)
  31       : OcclusionTrackerImpl(scissor_rect_in_screen, record_metrics_for_frame),
  32         scissor_rect_in_screen_(scissor_rect_in_screen) {}
  33
  34  protected:
  35   virtual gfx::Rect LayerScissorRectInTargetSurface(
  36       const LayerImpl* layer) const {
  37     return scissor_rect_in_screen_;
  38   }
  39
  40  private:
  41   gfx::Rect scissor_rect_in_screen_;
  42
  43   DISALLOW_COPY_AND_ASSIGN(TestOcclusionTrackerImpl);
  44 };
  45
  46 typedef LayerIterator<LayerImpl,
  47                       LayerImplList,
  48                       RenderSurfaceImpl,
  49                       LayerIteratorActions::FrontToBack> LayerIteratorType;
  50
  51 class QuadCullerTest : public testing::Test {
  52  public:
  53   QuadCullerTest()
  54       : host_impl_(&proxy_),
  55         layer_id_(1) {}
  56
  57   scoped_ptr<TiledLayerImpl> MakeLayer(
  58       TiledLayerImpl* parent,
  59       const gfx::Transform& draw_transform,
  60       gfx::Rect layer_rect,
  61       float opacity,
  62       bool opaque,
  63       gfx::Rect layer_opaque_rect,
  64       LayerImplList& surface_layer_list) {
  65     scoped_ptr<TiledLayerImpl> layer =
  66         TiledLayerImpl::Create(host_impl_.active_tree(), layer_id_++);
  67     scoped_ptr<LayerTilingData> tiler = LayerTilingData::Create(
  68         gfx::Size(100, 100), LayerTilingData::NO_BORDER_TEXELS);
  69     tiler->SetBounds(layer_rect.size());
  70     layer->SetTilingData(*tiler);
  71     layer->set_skips_draw(false);
  72     layer->draw_properties().target_space_transform = draw_transform;
  73     layer->draw_properties().screen_space_transform = draw_transform;
  74     layer->draw_properties().visible_content_rect = layer_rect;
  75     layer->draw_properties().opacity = opacity;
  76     layer->SetContentsOpaque(opaque);
  77     layer->SetBounds(layer_rect.size());
  78     layer->SetContentBounds(layer_rect.size());
  79
  80     ResourceProvider::ResourceId resource_id = 1;
  81     for (int i = 0; i < tiler->num_tiles_x(); ++i) {
  82       for (int j = 0; j < tiler->num_tiles_y(); ++j) {
  83         gfx::Rect tile_opaque_rect =
  84             opaque
  85             ? tiler->tile_bounds(i, j)
  86             : gfx::IntersectRects(tiler->tile_bounds(i, j), layer_opaque_rect);
  87         layer->PushTileProperties(i, j, resource_id++, tile_opaque_rect, false);
  88       }
  89     }
  90
  91     gfx::Rect rect_in_target = MathUtil::MapClippedRect(
  92         layer->draw_transform(), layer->visible_content_rect());
  93     if (!parent) {
  94       layer->CreateRenderSurface();
  95       layer->render_surface()->SetContentRect(rect_in_target);
  96       surface_layer_list.push_back(layer.get());
  97       layer->render_surface()->layer_list().push_back(layer.get());
  98     } else {
  99       layer->draw_properties().render_target = parent->render_target();
 100       parent->render_surface()->layer_list().push_back(layer.get());
 101       rect_in_target.Union(MathUtil::MapClippedRect(
 102           parent->draw_transform(), parent->visible_content_rect()));
 103       parent->render_surface()->SetContentRect(rect_in_target);
 104     }
 105     layer->draw_properties().drawable_content_rect = rect_in_target;
 106
 107     return layer.Pass();
 108   }
 109
 110   void AppendQuads(QuadList* quad_list,
 111                    SharedQuadStateList* shared_state_list,
 112                    TiledLayerImpl* layer,
 113                    LayerIteratorType* it,
 114                    OcclusionTrackerImpl* occlusion_tracker) {
 115     occlusion_tracker->EnterLayer(*it, false);
 116     QuadCuller quad_culler(
 117         quad_list, shared_state_list, layer, *occlusion_tracker, false, false);
 118     AppendQuadsData data;
 119     layer->AppendQuads(&quad_culler, &data);
 120     occlusion_tracker->LeaveLayer(*it);
 121     ++it;
 122   }
 123
 124  protected:
 125   FakeImplProxy proxy_;
 126   FakeLayerTreeHostImpl host_impl_;
 127   int layer_id_;
 128
 129   DISALLOW_COPY_AND_ASSIGN(QuadCullerTest);
 130 };
 131
 132 #define DECLARE_AND_INITIALIZE_TEST_QUADS()                                    \
 133   QuadList quad_list;                                                          \
 134   SharedQuadStateList shared_state_list;                                       \
 135   LayerImplList render_surface_layer_list;                                     \
 136   gfx::Transform child_transform;                                              \
 137   gfx::Size root_size = gfx::Size(300, 300);                                   \
 138   gfx::Rect root_rect = gfx::Rect(root_size);                                  \
 139   gfx::Size child_size = gfx::Size(200, 200);                                  \
 140   gfx::Rect child_rect = gfx::Rect(child_size);
 141
 142 TEST_F(QuadCullerTest, VerifyNoCulling) {
 143   DECLARE_AND_INITIALIZE_TEST_QUADS();
 144
 145   scoped_ptr<TiledLayerImpl> root_layer =
 146       MakeLayer(NULL,
 147                 gfx::Transform(),
 148                 root_rect,
 149                 1,
 150                 true,
 151                 gfx::Rect(),
 152                 render_surface_layer_list);
 153   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
 154                                                      gfx::Transform(),
 155                                                      child_rect,
 156                                                      1,
 157                                                      false,
 158                                                      gfx::Rect(),
 159                                                      render_surface_layer_list);
 160   TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
 161   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 162
 163   AppendQuads(&quad_list,
 164               &shared_state_list,
 165               child_layer.get(),
 166               &it,
 167               &occlusion_tracker);
 168   AppendQuads(&quad_list,
 169               &shared_state_list,
 170               root_layer.get(),
 171               &it,
 172               &occlusion_tracker);
 173   EXPECT_EQ(quad_list.size(), 13u);
 174   EXPECT_NEAR(
 175       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 90000, 1);
 176   EXPECT_NEAR(occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(),
 177               40000,
 178               1);
 179   EXPECT_NEAR(
 180       occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(), 0, 1);
 181 }
 182
 183 TEST_F(QuadCullerTest, VerifyCullChildLinesUpTopLeft) {
 184   DECLARE_AND_INITIALIZE_TEST_QUADS();
 185
 186   scoped_ptr<TiledLayerImpl> root_layer =
 187       MakeLayer(NULL,
 188                 gfx::Transform(),
 189                 root_rect,
 190                 1,
 191                 true,
 192                 gfx::Rect(),
 193                 render_surface_layer_list);
 194   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
 195                                                      gfx::Transform(),
 196                                                      child_rect,
 197                                                      1,
 198                                                      true,
 199                                                      gfx::Rect(),
 200                                                      render_surface_layer_list);
 201   TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
 202   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 203
 204   AppendQuads(&quad_list,
 205               &shared_state_list,
 206               child_layer.get(),
 207               &it,
 208               &occlusion_tracker);
 209   AppendQuads(&quad_list,
 210               &shared_state_list,
 211               root_layer.get(),
 212               &it,
 213               &occlusion_tracker);
 214   EXPECT_EQ(quad_list.size(), 9u);
 215   EXPECT_NEAR(
 216       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 90000, 1);
 217   EXPECT_NEAR(
 218       occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(), 0, 1);
 219   EXPECT_NEAR(occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(),
 220               40000,
 221               1);
 222 }
 223
 224 TEST_F(QuadCullerTest, VerifyCullWhenChildOpacityNotOne) {
 225   DECLARE_AND_INITIALIZE_TEST_QUADS();
 226
 227   scoped_ptr<TiledLayerImpl> root_layer =
 228       MakeLayer(NULL,
 229                 gfx::Transform(),
 230                 root_rect,
 231                 1,
 232                 true,
 233                 gfx::Rect(),
 234                 render_surface_layer_list);
 235   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
 236                                                      child_transform,
 237                                                      child_rect,
 238                                                      0.9f,
 239                                                      true,
 240                                                      gfx::Rect(),
 241                                                      render_surface_layer_list);
 242   TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
 243   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 244
 245   AppendQuads(&quad_list,
 246               &shared_state_list,
 247               child_layer.get(),
 248               &it,
 249               &occlusion_tracker);
 250   AppendQuads(&quad_list,
 251               &shared_state_list,
 252               root_layer.get(),
 253               &it,
 254               &occlusion_tracker);
 255   EXPECT_EQ(quad_list.size(), 13u);
 256   EXPECT_NEAR(
 257       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 90000, 1);
 258   EXPECT_NEAR(occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(),
 259               40000,
 260               1);
 261   EXPECT_NEAR(
 262       occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(), 0, 1);
 263 }
 264
 265 TEST_F(QuadCullerTest, VerifyCullWhenChildOpaqueFlagFalse) {
 266   DECLARE_AND_INITIALIZE_TEST_QUADS();
 267
 268   scoped_ptr<TiledLayerImpl> root_layer =
 269       MakeLayer(NULL,
 270                 gfx::Transform(),
 271                 root_rect,
 272                 1,
 273                 true,
 274                 gfx::Rect(),
 275                 render_surface_layer_list);
 276   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
 277                                                      child_transform,
 278                                                      child_rect,
 279                                                      1,
 280                                                      false,
 281                                                      gfx::Rect(),
 282                                                      render_surface_layer_list);
 283   TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
 284   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 285
 286   AppendQuads(&quad_list,
 287               &shared_state_list,
 288               child_layer.get(),
 289               &it,
 290               &occlusion_tracker);
 291   AppendQuads(&quad_list,
 292               &shared_state_list,
 293               root_layer.get(),
 294               &it,
 295               &occlusion_tracker);
 296   EXPECT_EQ(quad_list.size(), 13u);
 297   EXPECT_NEAR(
 298       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 90000, 1);
 299   EXPECT_NEAR(occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(),
 300               40000,
 301               1);
 302   EXPECT_NEAR(
 303       occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(), 0, 1);
 304 }
 305
 306 TEST_F(QuadCullerTest, VerifyCullCenterTileOnly) {
 307   DECLARE_AND_INITIALIZE_TEST_QUADS();
 308
 309   child_transform.Translate(50, 50);
 310   scoped_ptr<TiledLayerImpl> root_layer = MakeLayer(NULL,
 311                                                     gfx::Transform(),
 312                                                     root_rect,
 313                                                     1,
 314                                                     true,
 315                                                     gfx::Rect(),
 316                                                     render_surface_layer_list);
 317   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
 318                                                      child_transform,
 319                                                      child_rect,
 320                                                      1,
 321                                                      true,
 322                                                      gfx::Rect(),
 323                                                      render_surface_layer_list);
 324   TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
 325   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 326
 327   AppendQuads(&quad_list,
 328               &shared_state_list,
 329               child_layer.get(),
 330               &it,
 331               &occlusion_tracker);
 332   AppendQuads(&quad_list,
 333               &shared_state_list,
 334               root_layer.get(),
 335               &it,
 336               &occlusion_tracker);
 337   ASSERT_EQ(quad_list.size(), 12u);
 338
 339   gfx::Rect quad_visible_rect1 = quad_list[5]->visible_rect;
 340   EXPECT_EQ(quad_visible_rect1.height(), 50);
 341
 342   gfx::Rect quad_visible_rect3 = quad_list[7]->visible_rect;
 343   EXPECT_EQ(quad_visible_rect3.width(), 50);
 344
 345   // Next index is 8, not 9, since centre quad culled.
 346   gfx::Rect quad_visible_rect4 = quad_list[8]->visible_rect;
 347   EXPECT_EQ(quad_visible_rect4.width(), 50);
 348   EXPECT_EQ(quad_visible_rect4.x(), 250);
 349
 350   gfx::Rect quad_visible_rect6 = quad_list[10]->visible_rect;
 351   EXPECT_EQ(quad_visible_rect6.height(), 50);
 352   EXPECT_EQ(quad_visible_rect6.y(), 250);
 353
 354   EXPECT_NEAR(
 355       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 100000, 1);
 356   EXPECT_NEAR(
 357       occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(), 0, 1);
 358   EXPECT_NEAR(occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(),
 359               30000,
 360               1);
 361 }
 362
 363 TEST_F(QuadCullerTest, VerifyCullCenterTileNonIntegralSize1) {
 364   DECLARE_AND_INITIALIZE_TEST_QUADS();
 365
 366   child_transform.Translate(100, 100);
 367
 368   // Make the root layer's quad have extent (99.1, 99.1) -> (200.9, 200.9) to
 369   // make sure it doesn't get culled due to transform rounding.
 370   gfx::Transform root_transform;
 371   root_transform.Translate(99.1, 99.1);
 372   root_transform.Scale(1.018, 1.018);
 373
 374   root_rect = child_rect = gfx::Rect(0, 0, 100, 100);
 375
 376   scoped_ptr<TiledLayerImpl> root_layer = MakeLayer(NULL,
 377                                                     root_transform,
 378                                                     root_rect,
 379                                                     1,
 380                                                     true,
 381                                                     gfx::Rect(),
 382                                                     render_surface_layer_list);
 383   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
 384                                                      child_transform,
 385                                                      child_rect,
 386                                                      1,
 387                                                      true,
 388                                                      gfx::Rect(),
 389                                                      render_surface_layer_list);
 390   TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
 391   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 392
 393   AppendQuads(&quad_list,
 394               &shared_state_list,
 395               child_layer.get(),
 396               &it,
 397               &occlusion_tracker);
 398   AppendQuads(&quad_list,
 399               &shared_state_list,
 400               root_layer.get(),
 401               &it,
 402               &occlusion_tracker);
 403   EXPECT_EQ(quad_list.size(), 2u);
 404
 405   EXPECT_NEAR(
 406       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 20363, 1);
 407   EXPECT_NEAR(
 408       occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(), 0, 1);
 409   EXPECT_NEAR(
 410       occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(), 0, 1);
 411 }
 412
 413 TEST_F(QuadCullerTest, VerifyCullCenterTileNonIntegralSize2) {
 414   DECLARE_AND_INITIALIZE_TEST_QUADS();
 415
 416   // Make the child's quad slightly smaller than, and centred over, the root
 417   // layer tile.  Verify the child does not cause the quad below to be culled
 418   // due to rounding.
 419   child_transform.Translate(100.1, 100.1);
 420   child_transform.Scale(0.982, 0.982);
 421
 422   gfx::Transform root_transform;
 423   root_transform.Translate(100, 100);
 424
 425   root_rect = child_rect = gfx::Rect(0, 0, 100, 100);
 426
 427   scoped_ptr<TiledLayerImpl> root_layer = MakeLayer(NULL,
 428                                                     root_transform,
 429                                                     root_rect,
 430                                                     1,
 431                                                     true,
 432                                                     gfx::Rect(),
 433                                                     render_surface_layer_list);
 434   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
 435                                                      child_transform,
 436                                                      child_rect,
 437                                                      1,
 438                                                      true,
 439                                                      gfx::Rect(),
 440                                                      render_surface_layer_list);
 441   TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
 442   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 443
 444   AppendQuads(&quad_list,
 445               &shared_state_list,
 446               child_layer.get(),
 447               &it,
 448               &occlusion_tracker);
 449   AppendQuads(&quad_list,
 450               &shared_state_list,
 451               root_layer.get(),
 452               &it,
 453               &occlusion_tracker);
 454   EXPECT_EQ(quad_list.size(), 2u);
 455
 456   EXPECT_NEAR(
 457       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 19643, 1);
 458   EXPECT_NEAR(
 459       occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(), 0, 1);
 460   EXPECT_NEAR(
 461       occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(), 0, 1);
 462 }
 463
 464 TEST_F(QuadCullerTest, VerifyCullChildLinesUpBottomRight) {
 465   DECLARE_AND_INITIALIZE_TEST_QUADS();
 466
 467   child_transform.Translate(100, 100);
 468   scoped_ptr<TiledLayerImpl> root_layer = MakeLayer(NULL,
 469                                                     gfx::Transform(),
 470                                                     root_rect,
 471                                                     1,
 472                                                     true,
 473                                                     gfx::Rect(),
 474                                                     render_surface_layer_list);
 475   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
 476                                                      child_transform,
 477                                                      child_rect,
 478                                                      1,
 479                                                      true,
 480                                                      gfx::Rect(),
 481                                                      render_surface_layer_list);
 482   TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
 483   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 484
 485   AppendQuads(&quad_list,
 486               &shared_state_list,
 487               child_layer.get(),
 488               &it,
 489               &occlusion_tracker);
 490   AppendQuads(&quad_list,
 491               &shared_state_list,
 492               root_layer.get(),
 493               &it,
 494               &occlusion_tracker);
 495   EXPECT_EQ(quad_list.size(), 9u);
 496   EXPECT_NEAR(
 497       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 90000, 1);
 498   EXPECT_NEAR(
 499       occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(), 0, 1);
 500   EXPECT_NEAR(occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(),
 501               40000,
 502               1);
 503 }
 504
 505 TEST_F(QuadCullerTest, VerifyCullSubRegion) {
 506   DECLARE_AND_INITIALIZE_TEST_QUADS();
 507
 508   child_transform.Translate(50, 50);
 509   scoped_ptr<TiledLayerImpl> root_layer = MakeLayer(NULL,
 510                                                     gfx::Transform(),
 511                                                     root_rect,
 512                                                     1,
 513                                                     true,
 514                                                     gfx::Rect(),
 515                                                     render_surface_layer_list);
 516   gfx::Rect child_opaque_rect(child_rect.x() + child_rect.width() / 4,
 517                               child_rect.y() + child_rect.height() / 4,
 518                               child_rect.width() / 2,
 519                               child_rect.height() / 2);
 520   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
 521                                                      child_transform,
 522                                                      child_rect,
 523                                                      1,
 524                                                      false,
 525                                                      child_opaque_rect,
 526                                                      render_surface_layer_list);
 527   TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
 528   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 529
 530   AppendQuads(&quad_list,
 531               &shared_state_list,
 532               child_layer.get(),
 533               &it,
 534               &occlusion_tracker);
 535   AppendQuads(&quad_list,
 536               &shared_state_list,
 537               root_layer.get(),
 538               &it,
 539               &occlusion_tracker);
 540   EXPECT_EQ(quad_list.size(), 12u);
 541   EXPECT_NEAR(
 542       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 90000, 1);
 543   EXPECT_NEAR(occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(),
 544               30000,
 545               1);
 546   EXPECT_NEAR(occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(),
 547               10000,
 548               1);
 549 }
 550
 551 TEST_F(QuadCullerTest, VerifyCullSubRegion2) {
 552   DECLARE_AND_INITIALIZE_TEST_QUADS();
 553
 554   child_transform.Translate(50, 10);
 555   scoped_ptr<TiledLayerImpl> root_layer = MakeLayer(NULL,
 556                                                     gfx::Transform(),
 557                                                     root_rect,
 558                                                     1,
 559                                                     true,
 560                                                     gfx::Rect(),
 561                                                     render_surface_layer_list);
 562   gfx::Rect child_opaque_rect(child_rect.x() + child_rect.width() / 4,
 563                               child_rect.y() + child_rect.height() / 4,
 564                               child_rect.width() / 2,
 565                               child_rect.height() * 3 / 4);
 566   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
 567                                                      child_transform,
 568                                                      child_rect,
 569                                                      1,
 570                                                      false,
 571                                                      child_opaque_rect,
 572                                                      render_surface_layer_list);
 573   TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
 574   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 575
 576   AppendQuads(&quad_list,
 577               &shared_state_list,
 578               child_layer.get(),
 579               &it,
 580               &occlusion_tracker);
 581   AppendQuads(&quad_list,
 582               &shared_state_list,
 583               root_layer.get(),
 584               &it,
 585               &occlusion_tracker);
 586   EXPECT_EQ(quad_list.size(), 12u);
 587   EXPECT_NEAR(
 588       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 90000, 1);
 589   EXPECT_NEAR(occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(),
 590               25000,
 591               1);
 592   EXPECT_NEAR(occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(),
 593               15000,
 594               1);
 595 }
 596
 597 TEST_F(QuadCullerTest, VerifyCullSubRegionCheckOvercull) {
 598   DECLARE_AND_INITIALIZE_TEST_QUADS();
 599
 600   child_transform.Translate(50, 49);
 601   scoped_ptr<TiledLayerImpl> root_layer = MakeLayer(NULL,
 602                                                     gfx::Transform(),
 603                                                     root_rect,
 604                                                     1,
 605                                                     true,
 606                                                     gfx::Rect(),
 607                                                     render_surface_layer_list);
 608   gfx::Rect child_opaque_rect(child_rect.x() + child_rect.width() / 4,
 609                               child_rect.y() + child_rect.height() / 4,
 610                               child_rect.width() / 2,
 611                               child_rect.height() / 2);
 612   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
 613                                                      child_transform,
 614                                                      child_rect,
 615                                                      1,
 616                                                      false,
 617                                                      child_opaque_rect,
 618                                                      render_surface_layer_list);
 619   TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
 620   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 621
 622   AppendQuads(&quad_list,
 623               &shared_state_list,
 624               child_layer.get(),
 625               &it,
 626               &occlusion_tracker);
 627   AppendQuads(&quad_list,
 628               &shared_state_list,
 629               root_layer.get(),
 630               &it,
 631               &occlusion_tracker);
 632   EXPECT_EQ(quad_list.size(), 13u);
 633   EXPECT_NEAR(
 634       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 90000, 1);
 635   EXPECT_NEAR(occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(),
 636               30000,
 637               1);
 638   EXPECT_NEAR(occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(),
 639               10000,
 640               1);
 641 }
 642
 643 TEST_F(QuadCullerTest, VerifyNonAxisAlignedQuadsDontOcclude) {
 644   DECLARE_AND_INITIALIZE_TEST_QUADS();
 645
 646   // Use a small rotation so as to not disturb the geometry significantly.
 647   child_transform.Rotate(1);
 648
 649   scoped_ptr<TiledLayerImpl> root_layer = MakeLayer(NULL,
 650                                                     gfx::Transform(),
 651                                                     root_rect,
 652                                                     1,
 653                                                     true,
 654                                                     gfx::Rect(),
 655                                                     render_surface_layer_list);
 656   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
 657                                                      child_transform,
 658                                                      child_rect,
 659                                                      1,
 660                                                      true,
 661                                                      gfx::Rect(),
 662                                                      render_surface_layer_list);
 663   TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
 664   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 665
 666   AppendQuads(&quad_list,
 667               &shared_state_list,
 668               child_layer.get(),
 669               &it,
 670               &occlusion_tracker);
 671   AppendQuads(&quad_list,
 672               &shared_state_list,
 673               root_layer.get(),
 674               &it,
 675               &occlusion_tracker);
 676   EXPECT_EQ(quad_list.size(), 13u);
 677   EXPECT_NEAR(
 678       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 130000, 1);
 679   EXPECT_NEAR(
 680       occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(), 0, 1);
 681   EXPECT_NEAR(
 682       occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(), 0, 1);
 683 }
 684
 685 // This test requires some explanation: here we are rotating the quads to be
 686 // culled.  The 2x2 tile child layer remains in the top-left corner, unrotated,
 687 // but the 3x3 tile parent layer is rotated by 1 degree. Of the four tiles the
 688 // child would normally occlude, three will move (slightly) out from under the
 689 // child layer, and one moves further under the child. Only this last tile
 690 // should be culled.
 691 TEST_F(QuadCullerTest, VerifyNonAxisAlignedQuadsSafelyCulled) {
 692   DECLARE_AND_INITIALIZE_TEST_QUADS();
 693
 694   // Use a small rotation so as to not disturb the geometry significantly.
 695   gfx::Transform parent_transform;
 696   parent_transform.Rotate(1);
 697
 698   scoped_ptr<TiledLayerImpl> root_layer = MakeLayer(NULL,
 699                                                     parent_transform,
 700                                                     root_rect,
 701                                                     1,
 702                                                     true,
 703                                                     gfx::Rect(),
 704                                                     render_surface_layer_list);
 705   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
 706                                                      gfx::Transform(),
 707                                                      child_rect,
 708                                                      1,
 709                                                      true,
 710                                                      gfx::Rect(),
 711                                                      render_surface_layer_list);
 712   TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
 713   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 714
 715   AppendQuads(&quad_list,
 716               &shared_state_list,
 717               child_layer.get(),
 718               &it,
 719               &occlusion_tracker);
 720   AppendQuads(&quad_list,
 721               &shared_state_list,
 722               root_layer.get(),
 723               &it,
 724               &occlusion_tracker);
 725   EXPECT_EQ(quad_list.size(), 12u);
 726   EXPECT_NEAR(
 727       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 100600, 1);
 728   EXPECT_NEAR(
 729       occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(), 0, 1);
 730   EXPECT_NEAR(occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(),
 731               29400,
 732               1);
 733 }
 734
 735 TEST_F(QuadCullerTest, VerifyCullOutsideScissorOverTile) {
 736   DECLARE_AND_INITIALIZE_TEST_QUADS();
 737   scoped_ptr<TiledLayerImpl> root_layer =
 738       MakeLayer(NULL,
 739                 gfx::Transform(),
 740                 root_rect,
 741                 1,
 742                 true,
 743                 gfx::Rect(),
 744                 render_surface_layer_list);
 745   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
 746                                                      gfx::Transform(),
 747                                                      child_rect,
 748                                                      1,
 749                                                      true,
 750                                                      gfx::Rect(),
 751                                                      render_surface_layer_list);
 752   TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(200, 100, 100, 100));
 753   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 754
 755   AppendQuads(&quad_list,
 756               &shared_state_list,
 757               child_layer.get(),
 758               &it,
 759               &occlusion_tracker);
 760   AppendQuads(&quad_list,
 761               &shared_state_list,
 762               root_layer.get(),
 763               &it,
 764               &occlusion_tracker);
 765   EXPECT_EQ(quad_list.size(), 1u);
 766   EXPECT_NEAR(
 767       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 10000, 1);
 768   EXPECT_NEAR(
 769       occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(), 0, 1);
 770   EXPECT_NEAR(occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(),
 771               120000,
 772               1);
 773 }
 774
 775 TEST_F(QuadCullerTest, VerifyCullOutsideScissorOverCulledTile) {
 776   DECLARE_AND_INITIALIZE_TEST_QUADS();
 777   scoped_ptr<TiledLayerImpl> root_layer =
 778       MakeLayer(NULL,
 779                 gfx::Transform(),
 780                 root_rect,
 781                 1,
 782                 true,
 783                 gfx::Rect(),
 784                 render_surface_layer_list);
 785   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
 786                                                      gfx::Transform(),
 787                                                      child_rect,
 788                                                      1,
 789                                                      true,
 790                                                      gfx::Rect(),
 791                                                      render_surface_layer_list);
 792   TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(100, 100, 100, 100));
 793   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 794
 795   AppendQuads(&quad_list,
 796               &shared_state_list,
 797               child_layer.get(),
 798               &it,
 799               &occlusion_tracker);
 800   AppendQuads(&quad_list,
 801               &shared_state_list,
 802               root_layer.get(),
 803               &it,
 804               &occlusion_tracker);
 805   EXPECT_EQ(quad_list.size(), 1u);
 806   EXPECT_NEAR(
 807       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 10000, 1);
 808   EXPECT_NEAR(
 809       occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(), 0, 1);
 810   EXPECT_NEAR(occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(),
 811               120000,
 812               1);
 813 }
 814
 815 TEST_F(QuadCullerTest, VerifyCullOutsideScissorOverPartialTiles) {
 816   DECLARE_AND_INITIALIZE_TEST_QUADS();
 817   scoped_ptr<TiledLayerImpl> root_layer =
 818       MakeLayer(NULL,
 819                 gfx::Transform(),
 820                 root_rect,
 821                 1,
 822                 true,
 823                 gfx::Rect(),
 824                 render_surface_layer_list);
 825   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
 826                                                      gfx::Transform(),
 827                                                      child_rect,
 828                                                      1,
 829                                                      true,
 830                                                      gfx::Rect(),
 831                                                      render_surface_layer_list);
 832   TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(50, 50, 200, 200));
 833   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 834
 835   AppendQuads(&quad_list,
 836               &shared_state_list,
 837               child_layer.get(),
 838               &it,
 839               &occlusion_tracker);
 840   AppendQuads(&quad_list,
 841               &shared_state_list,
 842               root_layer.get(),
 843               &it,
 844               &occlusion_tracker);
 845   EXPECT_EQ(quad_list.size(), 9u);
 846   EXPECT_NEAR(
 847       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 40000, 1);
 848   EXPECT_NEAR(
 849       occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(), 0, 1);
 850   EXPECT_NEAR(occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(),
 851               90000,
 852               1);
 853 }
 854
 855 TEST_F(QuadCullerTest, VerifyCullOutsideScissorOverNoTiles) {
 856   DECLARE_AND_INITIALIZE_TEST_QUADS();
 857   scoped_ptr<TiledLayerImpl> root_layer =
 858       MakeLayer(NULL,
 859                 gfx::Transform(),
 860                 root_rect,
 861                 1,
 862                 true,
 863                 gfx::Rect(),
 864                 render_surface_layer_list);
 865   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
 866                                                      gfx::Transform(),
 867                                                      child_rect,
 868                                                      1,
 869                                                      true,
 870                                                      gfx::Rect(),
 871                                                      render_surface_layer_list);
 872   TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(500, 500, 100, 100));
 873   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 874
 875   AppendQuads(&quad_list,
 876               &shared_state_list,
 877               child_layer.get(),
 878               &it,
 879               &occlusion_tracker);
 880   AppendQuads(&quad_list,
 881               &shared_state_list,
 882               root_layer.get(),
 883               &it,
 884               &occlusion_tracker);
 885   EXPECT_EQ(quad_list.size(), 0u);
 886   EXPECT_NEAR(
 887       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 0, 1);
 888   EXPECT_NEAR(
 889       occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(), 0, 1);
 890   EXPECT_NEAR(occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(),
 891               130000,
 892               1);
 893 }
 894
 895 TEST_F(QuadCullerTest, VerifyWithoutMetrics) {
 896   DECLARE_AND_INITIALIZE_TEST_QUADS();
 897   scoped_ptr<TiledLayerImpl> root_layer =
 898       MakeLayer(NULL,
 899                 gfx::Transform(),
 900                 root_rect,
 901                 1,
 902                 true,
 903                 gfx::Rect(),
 904                 render_surface_layer_list);
 905   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
 906                                                      gfx::Transform(),
 907                                                      child_rect,
 908                                                      1,
 909                                                      true,
 910                                                      gfx::Rect(),
 911                                                      render_surface_layer_list);
 912   TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(50, 50, 200, 200),
 913                                              false);
 914   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 915
 916   AppendQuads(&quad_list,
 917               &shared_state_list,
 918               child_layer.get(),
 919               &it,
 920               &occlusion_tracker);
 921   AppendQuads(&quad_list,
 922               &shared_state_list,
 923               root_layer.get(),
 924               &it,
 925               &occlusion_tracker);
 926   EXPECT_EQ(quad_list.size(), 9u);
 927   EXPECT_NEAR(
 928       occlusion_tracker.overdraw_metrics()->pixels_drawn_opaque(), 0, 1);
 929   EXPECT_NEAR(
 930       occlusion_tracker.overdraw_metrics()->pixels_drawn_translucent(), 0, 1);
 931   EXPECT_NEAR(
 932       occlusion_tracker.overdraw_metrics()->pixels_culled_for_drawing(), 0, 1);
 933 }
 934
 935 }  // namespace
 936 }  // namespace cc