cc/resources/picture_layer_tiling_set_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/resources/picture_layer_tiling_set.h"
   6
   7 #include <map>
   8 #include <vector>
   9
  10 #include "cc/resources/resource_provider.h"
  11 #include "cc/test/fake_output_surface.h"
  12 #include "cc/test/fake_output_surface_client.h"
  13 #include "cc/test/fake_picture_layer_tiling_client.h"
  14 #include "cc/test/fake_picture_pile_impl.h"
  15 #include "cc/test/test_shared_bitmap_manager.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17 #include "ui/gfx/geometry/size_conversions.h"
  18
  19 namespace cc {
  20 namespace {
  21
  22 scoped_ptr<PictureLayerTilingSet> CreateTilingSet(
  23     PictureLayerTilingClient* client) {
  24   LayerTreeSettings defaults;
  25   return PictureLayerTilingSet::Create(
  26       client, defaults.max_tiles_for_interest_area,
  27       defaults.skewport_target_time_in_seconds,
  28       defaults.skewport_extrapolation_limit_in_content_pixels);
  29 }
  30
  31 TEST(PictureLayerTilingSetTest, NoResources) {
  32   FakePictureLayerTilingClient client;
  33   gfx::Size layer_bounds(1000, 800);
  34   scoped_ptr<PictureLayerTilingSet> set = CreateTilingSet(&client);
  35   client.SetTileSize(gfx::Size(256, 256));
  36
  37   scoped_refptr<FakePicturePileImpl> pile =
  38       FakePicturePileImpl::CreateEmptyPileWithDefaultTileSize(layer_bounds);
  39
  40   set->AddTiling(1.0, pile);
  41   set->AddTiling(1.5, pile);
  42   set->AddTiling(2.0, pile);
  43
  44   float contents_scale = 2.0;
  45   gfx::Size content_bounds(
  46       gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, contents_scale)));
  47   gfx::Rect content_rect(content_bounds);
  48
  49   Region remaining(content_rect);
  50   PictureLayerTilingSet::CoverageIterator iter(set.get(), contents_scale,
  51                                                content_rect, contents_scale);
  52   for (; iter; ++iter) {
  53     gfx::Rect geometry_rect = iter.geometry_rect();
  54     EXPECT_TRUE(content_rect.Contains(geometry_rect));
  55     ASSERT_TRUE(remaining.Contains(geometry_rect));
  56     remaining.Subtract(geometry_rect);
  57
  58     // No tiles have resources, so no iter represents a real tile.
  59     EXPECT_FALSE(*iter);
  60   }
  61   EXPECT_TRUE(remaining.IsEmpty());
  62 }
  63
  64 TEST(PictureLayerTilingSetTest, TilingRange) {
  65   FakePictureLayerTilingClient client;
  66   gfx::Size layer_bounds(10, 10);
  67   PictureLayerTilingSet::TilingRange higher_than_high_res_range(0, 0);
  68   PictureLayerTilingSet::TilingRange high_res_range(0, 0);
  69   PictureLayerTilingSet::TilingRange between_high_and_low_res_range(0, 0);
  70   PictureLayerTilingSet::TilingRange low_res_range(0, 0);
  71   PictureLayerTilingSet::TilingRange lower_than_low_res_range(0, 0);
  72   PictureLayerTiling* high_res_tiling;
  73   PictureLayerTiling* low_res_tiling;
  74
  75   scoped_refptr<FakePicturePileImpl> pile =
  76       FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
  77
  78   scoped_ptr<PictureLayerTilingSet> set = CreateTilingSet(&client);
  79   set->AddTiling(2.0, pile);
  80   high_res_tiling = set->AddTiling(1.0, pile);
  81   high_res_tiling->set_resolution(HIGH_RESOLUTION);
  82   set->AddTiling(0.5, pile);
  83   low_res_tiling = set->AddTiling(0.25, pile);
  84   low_res_tiling->set_resolution(LOW_RESOLUTION);
  85   set->AddTiling(0.125, pile);
  86
  87   higher_than_high_res_range =
  88       set->GetTilingRange(PictureLayerTilingSet::HIGHER_THAN_HIGH_RES);
  89   EXPECT_EQ(0u, higher_than_high_res_range.start);
  90   EXPECT_EQ(1u, higher_than_high_res_range.end);
  91
  92   high_res_range = set->GetTilingRange(PictureLayerTilingSet::HIGH_RES);
  93   EXPECT_EQ(1u, high_res_range.start);
  94   EXPECT_EQ(2u, high_res_range.end);
  95
  96   between_high_and_low_res_range =
  97       set->GetTilingRange(PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES);
  98   EXPECT_EQ(2u, between_high_and_low_res_range.start);
  99   EXPECT_EQ(3u, between_high_and_low_res_range.end);
 100
 101   low_res_range = set->GetTilingRange(PictureLayerTilingSet::LOW_RES);
 102   EXPECT_EQ(3u, low_res_range.start);
 103   EXPECT_EQ(4u, low_res_range.end);
 104
 105   lower_than_low_res_range =
 106       set->GetTilingRange(PictureLayerTilingSet::LOWER_THAN_LOW_RES);
 107   EXPECT_EQ(4u, lower_than_low_res_range.start);
 108   EXPECT_EQ(5u, lower_than_low_res_range.end);
 109
 110   scoped_ptr<PictureLayerTilingSet> set_without_low_res =
 111       CreateTilingSet(&client);
 112   set_without_low_res->AddTiling(2.0, pile);
 113   high_res_tiling = set_without_low_res->AddTiling(1.0, pile);
 114   high_res_tiling->set_resolution(HIGH_RESOLUTION);
 115   set_without_low_res->AddTiling(0.5, pile);
 116   set_without_low_res->AddTiling(0.25, pile);
 117
 118   higher_than_high_res_range = set_without_low_res->GetTilingRange(
 119       PictureLayerTilingSet::HIGHER_THAN_HIGH_RES);
 120   EXPECT_EQ(0u, higher_than_high_res_range.start);
 121   EXPECT_EQ(1u, higher_than_high_res_range.end);
 122
 123   high_res_range =
 124       set_without_low_res->GetTilingRange(PictureLayerTilingSet::HIGH_RES);
 125   EXPECT_EQ(1u, high_res_range.start);
 126   EXPECT_EQ(2u, high_res_range.end);
 127
 128   between_high_and_low_res_range = set_without_low_res->GetTilingRange(
 129       PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES);
 130   EXPECT_EQ(2u, between_high_and_low_res_range.start);
 131   EXPECT_EQ(4u, between_high_and_low_res_range.end);
 132
 133   low_res_range =
 134       set_without_low_res->GetTilingRange(PictureLayerTilingSet::LOW_RES);
 135   EXPECT_EQ(0u, low_res_range.end - low_res_range.start);
 136
 137   lower_than_low_res_range = set_without_low_res->GetTilingRange(
 138       PictureLayerTilingSet::LOWER_THAN_LOW_RES);
 139   EXPECT_EQ(0u, lower_than_low_res_range.end - lower_than_low_res_range.start);
 140
 141   scoped_ptr<PictureLayerTilingSet> set_with_only_high_and_low_res =
 142       CreateTilingSet(&client);
 143   high_res_tiling = set_with_only_high_and_low_res->AddTiling(1.0, pile);
 144   high_res_tiling->set_resolution(HIGH_RESOLUTION);
 145   low_res_tiling = set_with_only_high_and_low_res->AddTiling(0.5, pile);
 146   low_res_tiling->set_resolution(LOW_RESOLUTION);
 147
 148   higher_than_high_res_range = set_with_only_high_and_low_res->GetTilingRange(
 149       PictureLayerTilingSet::HIGHER_THAN_HIGH_RES);
 150   EXPECT_EQ(0u,
 151             higher_than_high_res_range.end - higher_than_high_res_range.start);
 152
 153   high_res_range = set_with_only_high_and_low_res->GetTilingRange(
 154       PictureLayerTilingSet::HIGH_RES);
 155   EXPECT_EQ(0u, high_res_range.start);
 156   EXPECT_EQ(1u, high_res_range.end);
 157
 158   between_high_and_low_res_range =
 159       set_with_only_high_and_low_res->GetTilingRange(
 160           PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES);
 161   EXPECT_EQ(0u, between_high_and_low_res_range.end -
 162                     between_high_and_low_res_range.start);
 163
 164   low_res_range = set_with_only_high_and_low_res->GetTilingRange(
 165       PictureLayerTilingSet::LOW_RES);
 166   EXPECT_EQ(1u, low_res_range.start);
 167   EXPECT_EQ(2u, low_res_range.end);
 168
 169   lower_than_low_res_range = set_with_only_high_and_low_res->GetTilingRange(
 170       PictureLayerTilingSet::LOWER_THAN_LOW_RES);
 171   EXPECT_EQ(0u, lower_than_low_res_range.end - lower_than_low_res_range.start);
 172
 173   scoped_ptr<PictureLayerTilingSet> set_with_only_high_res =
 174       CreateTilingSet(&client);
 175   high_res_tiling = set_with_only_high_res->AddTiling(1.0, pile);
 176   high_res_tiling->set_resolution(HIGH_RESOLUTION);
 177
 178   higher_than_high_res_range = set_with_only_high_res->GetTilingRange(
 179       PictureLayerTilingSet::HIGHER_THAN_HIGH_RES);
 180   EXPECT_EQ(0u,
 181             higher_than_high_res_range.end - higher_than_high_res_range.start);
 182
 183   high_res_range =
 184       set_with_only_high_res->GetTilingRange(PictureLayerTilingSet::HIGH_RES);
 185   EXPECT_EQ(0u, high_res_range.start);
 186   EXPECT_EQ(1u, high_res_range.end);
 187
 188   between_high_and_low_res_range = set_with_only_high_res->GetTilingRange(
 189       PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES);
 190   EXPECT_EQ(0u, between_high_and_low_res_range.end -
 191                     between_high_and_low_res_range.start);
 192
 193   low_res_range =
 194       set_with_only_high_res->GetTilingRange(PictureLayerTilingSet::LOW_RES);
 195   EXPECT_EQ(0u, low_res_range.end - low_res_range.start);
 196
 197   lower_than_low_res_range = set_with_only_high_res->GetTilingRange(
 198       PictureLayerTilingSet::LOWER_THAN_LOW_RES);
 199   EXPECT_EQ(0u, lower_than_low_res_range.end - lower_than_low_res_range.start);
 200 }
 201
 202 class PictureLayerTilingSetTestWithResources : public testing::Test {
 203  public:
 204   void runTest(
 205       int num_tilings,
 206       float min_scale,
 207       float scale_increment,
 208       float ideal_contents_scale,
 209       float expected_scale) {
 210     FakeOutputSurfaceClient output_surface_client;
 211     scoped_ptr<FakeOutputSurface> output_surface =
 212         FakeOutputSurface::Create3d();
 213     CHECK(output_surface->BindToClient(&output_surface_client));
 214
 215     scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
 216         new TestSharedBitmapManager());
 217     scoped_ptr<ResourceProvider> resource_provider =
 218         ResourceProvider::Create(output_surface.get(),
 219                                  shared_bitmap_manager.get(),
 220                                  NULL,
 221                                  NULL,
 222                                  0,
 223                                  false,
 224                                  1);
 225
 226     FakePictureLayerTilingClient client(resource_provider.get());
 227     client.SetTileSize(gfx::Size(256, 256));
 228     client.set_tree(PENDING_TREE);
 229     gfx::Size layer_bounds(1000, 800);
 230     scoped_ptr<PictureLayerTilingSet> set = CreateTilingSet(&client);
 231     scoped_refptr<FakePicturePileImpl> pile =
 232         FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
 233
 234     float scale = min_scale;
 235     for (int i = 0; i < num_tilings; ++i, scale += scale_increment) {
 236       PictureLayerTiling* tiling = set->AddTiling(scale, pile);
 237       tiling->CreateAllTilesForTesting();
 238       std::vector<Tile*> tiles = tiling->AllTilesForTesting();
 239       client.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
 240     }
 241
 242     float max_contents_scale = scale;
 243     gfx::Size content_bounds(
 244         gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, max_contents_scale)));
 245     gfx::Rect content_rect(content_bounds);
 246
 247     Region remaining(content_rect);
 248     PictureLayerTilingSet::CoverageIterator iter(
 249         set.get(), max_contents_scale, content_rect, ideal_contents_scale);
 250     for (; iter; ++iter) {
 251       gfx::Rect geometry_rect = iter.geometry_rect();
 252       EXPECT_TRUE(content_rect.Contains(geometry_rect));
 253       ASSERT_TRUE(remaining.Contains(geometry_rect));
 254       remaining.Subtract(geometry_rect);
 255
 256       float scale = iter.CurrentTiling()->contents_scale();
 257       EXPECT_EQ(expected_scale, scale);
 258
 259       if (num_tilings)
 260         EXPECT_TRUE(*iter);
 261       else
 262         EXPECT_FALSE(*iter);
 263     }
 264     EXPECT_TRUE(remaining.IsEmpty());
 265   }
 266 };
 267
 268 TEST_F(PictureLayerTilingSetTestWithResources, NoTilings) {
 269   runTest(0, 0.f, 0.f, 2.f, 0.f);
 270 }
 271 TEST_F(PictureLayerTilingSetTestWithResources, OneTiling_Smaller) {
 272   runTest(1, 1.f, 0.f, 2.f, 1.f);
 273 }
 274 TEST_F(PictureLayerTilingSetTestWithResources, OneTiling_Larger) {
 275   runTest(1, 3.f, 0.f, 2.f, 3.f);
 276 }
 277 TEST_F(PictureLayerTilingSetTestWithResources, TwoTilings_Smaller) {
 278   runTest(2, 1.f, 1.f, 3.f, 2.f);
 279 }
 280
 281 TEST_F(PictureLayerTilingSetTestWithResources, TwoTilings_SmallerEqual) {
 282   runTest(2, 1.f, 1.f, 2.f, 2.f);
 283 }
 284
 285 TEST_F(PictureLayerTilingSetTestWithResources, TwoTilings_LargerEqual) {
 286   runTest(2, 1.f, 1.f, 1.f, 1.f);
 287 }
 288
 289 TEST_F(PictureLayerTilingSetTestWithResources, TwoTilings_Larger) {
 290   runTest(2, 2.f, 8.f, 1.f, 2.f);
 291 }
 292
 293 TEST_F(PictureLayerTilingSetTestWithResources, ManyTilings_Equal) {
 294   runTest(10, 1.f, 1.f, 5.f, 5.f);
 295 }
 296
 297 TEST_F(PictureLayerTilingSetTestWithResources, ManyTilings_NotEqual) {
 298   runTest(10, 1.f, 1.f, 4.5f, 5.f);
 299 }
 300
 301 TEST(PictureLayerTilingSetTest, TileSizeChange) {
 302   FakePictureLayerTilingClient pending_client;
 303   FakePictureLayerTilingClient active_client;
 304   scoped_ptr<PictureLayerTilingSet> pending_set =
 305       PictureLayerTilingSet::Create(&pending_client, 1000, 1.f, 1000);
 306   scoped_ptr<PictureLayerTilingSet> active_set =
 307       PictureLayerTilingSet::Create(&active_client, 1000, 1.f, 1000);
 308
 309   gfx::Size layer_bounds(100, 100);
 310   scoped_refptr<FakePicturePileImpl> pile =
 311       FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
 312
 313   gfx::Size tile_size1(10, 10);
 314   gfx::Size tile_size2(30, 30);
 315   gfx::Size tile_size3(20, 20);
 316
 317   pending_client.SetTileSize(tile_size1);
 318   pending_set->AddTiling(1.f, pile);
 319   // New tilings get the correct tile size.
 320   EXPECT_EQ(tile_size1, pending_set->tiling_at(0)->tile_size());
 321
 322   // Set some expected things for the tiling set to function.
 323   pending_set->tiling_at(0)->set_resolution(HIGH_RESOLUTION);
 324   active_client.set_twin_tiling_set(pending_set.get());
 325
 326   // Set a priority rect so we get tiles.
 327   pending_set->UpdateTilePriorities(gfx::Rect(layer_bounds), 1.f, 1.0,
 328                                     Occlusion(), false);
 329   EXPECT_EQ(tile_size1, pending_set->tiling_at(0)->tile_size());
 330
 331   // The tiles should get the correct size.
 332   std::vector<Tile*> pending_tiles =
 333       pending_set->tiling_at(0)->AllTilesForTesting();
 334   EXPECT_GT(pending_tiles.size(), 0u);
 335   for (const auto& tile : pending_tiles)
 336     EXPECT_EQ(tile_size1, tile->content_rect().size());
 337
 338   // Update to a new source frame with a new tile size.
 339   pending_client.SetTileSize(tile_size2);
 340   pending_set->UpdateTilingsToCurrentRasterSource(pile.get(), nullptr, Region(),
 341                                                   1.f, 1.f);
 342   // The tiling should get the correct tile size.
 343   EXPECT_EQ(tile_size2, pending_set->tiling_at(0)->tile_size());
 344
 345   // Set a priority rect so we get tiles.
 346   pending_set->UpdateTilePriorities(gfx::Rect(layer_bounds), 1.f, 2.0,
 347                                     Occlusion(), false);
 348   EXPECT_EQ(tile_size2, pending_set->tiling_at(0)->tile_size());
 349
 350   // Tiles should have the new correct size.
 351   pending_tiles = pending_set->tiling_at(0)->AllTilesForTesting();
 352   EXPECT_GT(pending_tiles.size(), 0u);
 353   for (const auto& tile : pending_tiles)
 354     EXPECT_EQ(tile_size2, tile->content_rect().size());
 355
 356   // Clone from the pending to the active tree.
 357   active_client.SetTileSize(tile_size2);
 358   active_set->UpdateTilingsToCurrentRasterSource(pile.get(), pending_set.get(),
 359                                                  Region(), 1.f, 1.f);
 360   // The active tiling should get the right tile size.
 361   EXPECT_EQ(tile_size2, active_set->tiling_at(0)->tile_size());
 362
 363   // Cloned tiles should have the right size.
 364   std::vector<Tile*> active_tiles =
 365       active_set->tiling_at(0)->AllTilesForTesting();
 366   EXPECT_GT(active_tiles.size(), 0u);
 367   for (const auto& tile : active_tiles)
 368     EXPECT_EQ(tile_size2, tile->content_rect().size());
 369
 370   // A new source frame with a new tile size.
 371   pending_client.SetTileSize(tile_size3);
 372   pending_set->UpdateTilingsToCurrentRasterSource(pile.get(), nullptr, Region(),
 373                                                   1.f, 1.f);
 374   // The tiling gets the new size correctly.
 375   EXPECT_EQ(tile_size3, pending_set->tiling_at(0)->tile_size());
 376
 377   // Set a priority rect so we get tiles.
 378   pending_set->UpdateTilePriorities(gfx::Rect(layer_bounds), 1.f, 3.0,
 379                                     Occlusion(), false);
 380   EXPECT_EQ(tile_size3, pending_set->tiling_at(0)->tile_size());
 381
 382   // Tiles are resized for the new size.
 383   pending_tiles = pending_set->tiling_at(0)->AllTilesForTesting();
 384   EXPECT_GT(pending_tiles.size(), 0u);
 385   for (const auto& tile : pending_tiles)
 386     EXPECT_EQ(tile_size3, tile->content_rect().size());
 387
 388   // Now we activate with a different tile size for the active tiling.
 389   active_client.SetTileSize(tile_size3);
 390   active_set->UpdateTilingsToCurrentRasterSource(pile.get(), pending_set.get(),
 391                                                  Region(), 1.f, 1.f);
 392   // The active tiling changes its tile size.
 393   EXPECT_EQ(tile_size3, active_set->tiling_at(0)->tile_size());
 394
 395   // And its tiles are resized.
 396   active_tiles = active_set->tiling_at(0)->AllTilesForTesting();
 397   EXPECT_GT(active_tiles.size(), 0u);
 398   for (const auto& tile : active_tiles)
 399     EXPECT_EQ(tile_size3, tile->content_rect().size());
 400 }
 401
 402 TEST(PictureLayerTilingSetTest, MaxContentScale) {
 403   FakePictureLayerTilingClient pending_client;
 404   FakePictureLayerTilingClient active_client;
 405   scoped_ptr<PictureLayerTilingSet> pending_set =
 406       PictureLayerTilingSet::Create(&pending_client, 1000, 1.f, 1000);
 407   scoped_ptr<PictureLayerTilingSet> active_set =
 408       PictureLayerTilingSet::Create(&active_client, 1000, 1.f, 1000);
 409
 410   gfx::Size layer_bounds(100, 105);
 411   scoped_refptr<FakePicturePileImpl> pile =
 412       FakePicturePileImpl::CreateEmptyPileWithDefaultTileSize(layer_bounds);
 413
 414   // Tilings can be added of any scale, the tiling client can controls this.
 415   pending_set->AddTiling(1.f, pile);
 416   pending_set->AddTiling(2.f, pile);
 417   pending_set->AddTiling(3.f, pile);
 418
 419   // Set some expected things for the tiling set to function.
 420   pending_set->tiling_at(0)->set_resolution(HIGH_RESOLUTION);
 421   active_client.set_twin_tiling_set(pending_set.get());
 422
 423   // Update to a new source frame with a max content scale that is larger than
 424   // everything.
 425   float max_content_scale = 3.f;
 426   pending_set->UpdateTilingsToCurrentRasterSource(pile.get(), nullptr, Region(),
 427                                                   1.f, max_content_scale);
 428   // All the tilings are there still.
 429   EXPECT_EQ(3u, pending_set->num_tilings());
 430
 431   // Clone from the pending to the active tree with the same max content size.
 432   active_set->UpdateTilingsToCurrentRasterSource(
 433       pile.get(), pending_set.get(), Region(), 1.f, max_content_scale);
 434   // All the tilings are on the active tree.
 435   EXPECT_EQ(3u, active_set->num_tilings());
 436
 437   // Update to a new source frame with a max content scale that will drop one
 438   // tiling.
 439   max_content_scale = 2.9f;
 440   pending_set->UpdateTilingsToCurrentRasterSource(pile.get(), nullptr, Region(),
 441                                                   1.f, max_content_scale);
 442   // All the tilings are there still.
 443   EXPECT_EQ(2u, pending_set->num_tilings());
 444
 445   pending_set->tiling_at(0)->set_resolution(HIGH_RESOLUTION);
 446
 447   // Clone from the pending to the active tree with the same max content size.
 448   active_set->UpdateTilingsToCurrentRasterSource(
 449       pile.get(), pending_set.get(), Region(), 1.f, max_content_scale);
 450   // All the tilings are on the active tree.
 451   EXPECT_EQ(2u, active_set->num_tilings());
 452 }
 453
 454 }  // namespace
 455 }  // namespace cc