cc/resources/prioritized_tile_set_unittest.cc

   1 // Copyright 2013 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 <algorithm>
   6 #include <vector>
   7
   8 #include "cc/resources/managed_tile_state.h"
   9 #include "cc/resources/prioritized_tile_set.h"
  10 #include "cc/resources/tile.h"
  11 #include "cc/test/fake_output_surface.h"
  12 #include "cc/test/fake_output_surface_client.h"
  13 #include "cc/test/fake_picture_pile_impl.h"
  14 #include "cc/test/fake_tile_manager.h"
  15 #include "cc/test/fake_tile_manager_client.h"
  16 #include "cc/test/test_shared_bitmap_manager.h"
  17 #include "cc/test/test_tile_priorities.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 namespace cc {
  21
  22 class BinComparator {
  23  public:
  24   bool operator()(const scoped_refptr<Tile>& a,
  25                   const scoped_refptr<Tile>& b) const {
  26     const ManagedTileState& ams = a->managed_state();
  27     const ManagedTileState& bms = b->managed_state();
  28
  29     if (ams.priority_bin != bms.priority_bin)
  30       return ams.priority_bin < bms.priority_bin;
  31
  32     if (ams.required_for_activation != bms.required_for_activation)
  33       return ams.required_for_activation;
  34
  35     if (ams.resolution != bms.resolution)
  36       return ams.resolution < bms.resolution;
  37
  38     if (ams.distance_to_visible != bms.distance_to_visible)
  39       return ams.distance_to_visible < bms.distance_to_visible;
  40
  41     gfx::Rect a_rect = a->content_rect();
  42     gfx::Rect b_rect = b->content_rect();
  43     if (a_rect.y() != b_rect.y())
  44       return a_rect.y() < b_rect.y();
  45     return a_rect.x() < b_rect.x();
  46   }
  47 };
  48
  49 namespace {
  50
  51 class PrioritizedTileSetTest : public testing::Test {
  52  public:
  53   PrioritizedTileSetTest() {
  54     output_surface_ = FakeOutputSurface::Create3d().Pass();
  55     CHECK(output_surface_->BindToClient(&output_surface_client_));
  56
  57     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
  58     resource_provider_ =
  59         ResourceProvider::Create(
  60             output_surface_.get(), shared_bitmap_manager_.get(), 0, false, 1,
  61             false)
  62             .Pass();
  63     resource_pool_ = ResourcePool::Create(
  64         resource_provider_.get(), GL_TEXTURE_2D, RGBA_8888);
  65     tile_manager_.reset(
  66         new FakeTileManager(&tile_manager_client_, resource_pool_.get()));
  67     picture_pile_ = FakePicturePileImpl::CreateInfiniteFilledPile();
  68   }
  69
  70   scoped_refptr<Tile> CreateTile() {
  71     return tile_manager_->CreateTile(picture_pile_.get(),
  72                                      settings_.default_tile_size,
  73                                      gfx::Rect(),
  74                                      gfx::Rect(),
  75                                      1.0,
  76                                      0,
  77                                      0,
  78                                      0);
  79   }
  80   void ReleaseTiles(std::vector<scoped_refptr<Tile> >* tiles) {
  81     for (std::vector<scoped_refptr<Tile> >::iterator it = tiles->begin();
  82          it != tiles->end();
  83          it++) {
  84       Tile* tile = *it;
  85       tile->SetPriority(ACTIVE_TREE, TilePriority());
  86       tile->SetPriority(PENDING_TREE, TilePriority());
  87     }
  88   }
  89
  90  private:
  91   LayerTreeSettings settings_;
  92   FakeOutputSurfaceClient output_surface_client_;
  93   scoped_ptr<FakeOutputSurface> output_surface_;
  94   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
  95   scoped_ptr<ResourceProvider> resource_provider_;
  96   scoped_ptr<ResourcePool> resource_pool_;
  97   FakeTileManagerClient tile_manager_client_;
  98   scoped_ptr<FakeTileManager> tile_manager_;
  99   scoped_refptr<FakePicturePileImpl> picture_pile_;
 100 };
 101
 102 TEST_F(PrioritizedTileSetTest, EmptyIterator) {
 103   // Creating an iterator to an empty set should work (but create iterator that
 104   // isn't valid).
 105
 106   PrioritizedTileSet set;
 107
 108   PrioritizedTileSet::Iterator it(&set, true);
 109   EXPECT_FALSE(it);
 110 }
 111
 112 TEST_F(PrioritizedTileSetTest, NonEmptyIterator) {
 113   PrioritizedTileSet set;
 114   scoped_refptr<Tile> tile = CreateTile();
 115   set.InsertTile(tile, NOW_BIN);
 116
 117   PrioritizedTileSet::Iterator it(&set, true);
 118   EXPECT_TRUE(it);
 119   EXPECT_TRUE(*it == tile.get());
 120   ++it;
 121   EXPECT_FALSE(it);
 122 }
 123
 124 TEST_F(PrioritizedTileSetTest, NowAndReadyToDrawBin) {
 125   // Ensure that tiles in NOW_AND_READY_TO_DRAW_BIN aren't sorted.
 126
 127   PrioritizedTileSet set;
 128   TilePriority priorities[4] = {
 129       TilePriorityForEventualBin(),
 130       TilePriorityForNowBin(),
 131       TilePriority(),
 132       TilePriorityForSoonBin()};
 133
 134   std::vector<scoped_refptr<Tile> > tiles;
 135   for (int priority = 0; priority < 4; ++priority) {
 136     for (int i = 0; i < 5; ++i) {
 137       scoped_refptr<Tile> tile = CreateTile();
 138       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
 139       tile->SetPriority(PENDING_TREE, priorities[priority]);
 140       tiles.push_back(tile);
 141       set.InsertTile(tile, NOW_AND_READY_TO_DRAW_BIN);
 142     }
 143   }
 144
 145   // Tiles should appear in the same order as inserted.
 146   int i = 0;
 147   for (PrioritizedTileSet::Iterator it(&set, true);
 148        it;
 149        ++it) {
 150     EXPECT_TRUE(*it == tiles[i].get());
 151     ++i;
 152   }
 153   EXPECT_EQ(20, i);
 154
 155   ReleaseTiles(&tiles);
 156 }
 157
 158 TEST_F(PrioritizedTileSetTest, NowBin) {
 159   // Ensure that tiles in NOW_BIN are sorted according to BinComparator.
 160
 161   PrioritizedTileSet set;
 162   TilePriority priorities[4] = {
 163       TilePriorityForEventualBin(),
 164       TilePriorityForNowBin(),
 165       TilePriority(),
 166       TilePriorityForSoonBin()};
 167
 168   std::vector<scoped_refptr<Tile> > tiles;
 169   for (int priority = 0; priority < 4; ++priority) {
 170     for (int i = 0; i < 5; ++i) {
 171       scoped_refptr<Tile> tile = CreateTile();
 172       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
 173       tile->SetPriority(PENDING_TREE, priorities[priority]);
 174       tiles.push_back(tile);
 175       set.InsertTile(tile, NOW_BIN);
 176     }
 177   }
 178
 179   // Tiles should appear in BinComparator order.
 180   std::sort(tiles.begin(), tiles.end(), BinComparator());
 181
 182   int i = 0;
 183   for (PrioritizedTileSet::Iterator it(&set, true);
 184        it;
 185        ++it) {
 186     EXPECT_TRUE(*it == tiles[i].get());
 187     ++i;
 188   }
 189   EXPECT_EQ(20, i);
 190
 191   ReleaseTiles(&tiles);
 192 }
 193
 194 TEST_F(PrioritizedTileSetTest, SoonBin) {
 195   // Ensure that tiles in SOON_BIN are sorted according to BinComparator.
 196
 197   PrioritizedTileSet set;
 198   TilePriority priorities[4] = {
 199       TilePriorityForEventualBin(),
 200       TilePriorityForNowBin(),
 201       TilePriority(),
 202       TilePriorityForSoonBin()};
 203
 204   std::vector<scoped_refptr<Tile> > tiles;
 205   for (int priority = 0; priority < 4; ++priority) {
 206     for (int i = 0; i < 5; ++i) {
 207       scoped_refptr<Tile> tile = CreateTile();
 208       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
 209       tile->SetPriority(PENDING_TREE, priorities[priority]);
 210       tiles.push_back(tile);
 211       set.InsertTile(tile, SOON_BIN);
 212     }
 213   }
 214
 215   // Tiles should appear in BinComparator order.
 216   std::sort(tiles.begin(), tiles.end(), BinComparator());
 217
 218   int i = 0;
 219   for (PrioritizedTileSet::Iterator it(&set, true);
 220        it;
 221        ++it) {
 222     EXPECT_TRUE(*it == tiles[i].get());
 223     ++i;
 224   }
 225   EXPECT_EQ(20, i);
 226
 227   ReleaseTiles(&tiles);
 228 }
 229
 230 TEST_F(PrioritizedTileSetTest, SoonBinNoPriority) {
 231   // Ensure that when not using priority iterator, SOON_BIN tiles
 232   // are not sorted.
 233
 234   PrioritizedTileSet set;
 235   TilePriority priorities[4] = {
 236       TilePriorityForEventualBin(),
 237       TilePriorityForNowBin(),
 238       TilePriority(),
 239       TilePriorityForSoonBin()};
 240
 241   std::vector<scoped_refptr<Tile> > tiles;
 242   for (int priority = 0; priority < 4; ++priority) {
 243     for (int i = 0; i < 5; ++i) {
 244       scoped_refptr<Tile> tile = CreateTile();
 245       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
 246       tile->SetPriority(PENDING_TREE, priorities[priority]);
 247       tiles.push_back(tile);
 248       set.InsertTile(tile, SOON_BIN);
 249     }
 250   }
 251
 252   int i = 0;
 253   for (PrioritizedTileSet::Iterator it(&set, false);
 254        it;
 255        ++it) {
 256     EXPECT_TRUE(*it == tiles[i].get());
 257     ++i;
 258   }
 259   EXPECT_EQ(20, i);
 260
 261   ReleaseTiles(&tiles);
 262 }
 263
 264 TEST_F(PrioritizedTileSetTest, EventuallyAndActiveBin) {
 265   // Ensure that EVENTUALLY_AND_ACTIVE_BIN tiles are sorted.
 266
 267   PrioritizedTileSet set;
 268   TilePriority priorities[4] = {
 269       TilePriorityForEventualBin(),
 270       TilePriorityForNowBin(),
 271       TilePriority(),
 272       TilePriorityForSoonBin()};
 273
 274   std::vector<scoped_refptr<Tile> > tiles;
 275   for (int priority = 0; priority < 4; ++priority) {
 276     for (int i = 0; i < 5; ++i) {
 277       scoped_refptr<Tile> tile = CreateTile();
 278       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
 279       tile->SetPriority(PENDING_TREE, priorities[priority]);
 280       tiles.push_back(tile);
 281       set.InsertTile(tile, EVENTUALLY_AND_ACTIVE_BIN);
 282     }
 283   }
 284
 285   // Tiles should appear in BinComparator order.
 286   std::sort(tiles.begin(), tiles.end(), BinComparator());
 287
 288   int i = 0;
 289   for (PrioritizedTileSet::Iterator it(&set, true);
 290        it;
 291        ++it) {
 292     EXPECT_TRUE(*it == tiles[i].get());
 293     ++i;
 294   }
 295   EXPECT_EQ(20, i);
 296
 297   ReleaseTiles(&tiles);
 298 }
 299
 300 TEST_F(PrioritizedTileSetTest, EventuallyBin) {
 301   // Ensure that EVENTUALLY_BIN tiles are sorted.
 302
 303   PrioritizedTileSet set;
 304   TilePriority priorities[4] = {
 305       TilePriorityForEventualBin(),
 306       TilePriorityForNowBin(),
 307       TilePriority(),
 308       TilePriorityForSoonBin()};
 309
 310   std::vector<scoped_refptr<Tile> > tiles;
 311   for (int priority = 0; priority < 4; ++priority) {
 312     for (int i = 0; i < 5; ++i) {
 313       scoped_refptr<Tile> tile = CreateTile();
 314       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
 315       tile->SetPriority(PENDING_TREE, priorities[priority]);
 316       tiles.push_back(tile);
 317       set.InsertTile(tile, EVENTUALLY_BIN);
 318     }
 319   }
 320
 321   // Tiles should appear in BinComparator order.
 322   std::sort(tiles.begin(), tiles.end(), BinComparator());
 323
 324   int i = 0;
 325   for (PrioritizedTileSet::Iterator it(&set, true);
 326        it;
 327        ++it) {
 328     EXPECT_TRUE(*it == tiles[i].get());
 329     ++i;
 330   }
 331   EXPECT_EQ(20, i);
 332
 333   ReleaseTiles(&tiles);
 334 }
 335
 336 TEST_F(PrioritizedTileSetTest, AtLastAndActiveBin) {
 337   // Ensure that AT_LAST_AND_ACTIVE_BIN tiles are sorted.
 338
 339   PrioritizedTileSet set;
 340   TilePriority priorities[4] = {
 341       TilePriorityForEventualBin(),
 342       TilePriorityForNowBin(),
 343       TilePriority(),
 344       TilePriorityForSoonBin()};
 345
 346   std::vector<scoped_refptr<Tile> > tiles;
 347   for (int priority = 0; priority < 4; ++priority) {
 348     for (int i = 0; i < 5; ++i) {
 349       scoped_refptr<Tile> tile = CreateTile();
 350       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
 351       tile->SetPriority(PENDING_TREE, priorities[priority]);
 352       tiles.push_back(tile);
 353       set.InsertTile(tile, AT_LAST_AND_ACTIVE_BIN);
 354     }
 355   }
 356
 357   // Tiles should appear in BinComparator order.
 358   std::sort(tiles.begin(), tiles.end(), BinComparator());
 359
 360   int i = 0;
 361   for (PrioritizedTileSet::Iterator it(&set, true);
 362        it;
 363        ++it) {
 364     EXPECT_TRUE(*it == tiles[i].get());
 365     ++i;
 366   }
 367   EXPECT_EQ(20, i);
 368
 369   ReleaseTiles(&tiles);
 370 }
 371
 372 TEST_F(PrioritizedTileSetTest, AtLastBin) {
 373   // Ensure that AT_LAST_BIN tiles are sorted.
 374
 375   PrioritizedTileSet set;
 376   TilePriority priorities[4] = {
 377       TilePriorityForEventualBin(),
 378       TilePriorityForNowBin(),
 379       TilePriority(),
 380       TilePriorityForSoonBin()};
 381
 382   std::vector<scoped_refptr<Tile> > tiles;
 383   for (int priority = 0; priority < 4; ++priority) {
 384     for (int i = 0; i < 5; ++i) {
 385       scoped_refptr<Tile> tile = CreateTile();
 386       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
 387       tile->SetPriority(PENDING_TREE, priorities[priority]);
 388       tiles.push_back(tile);
 389       set.InsertTile(tile, AT_LAST_BIN);
 390     }
 391   }
 392
 393   // Tiles should appear in BinComparator order.
 394   std::sort(tiles.begin(), tiles.end(), BinComparator());
 395
 396   int i = 0;
 397   for (PrioritizedTileSet::Iterator it(&set, true);
 398        it;
 399        ++it) {
 400     EXPECT_TRUE(*it == tiles[i].get());
 401     ++i;
 402   }
 403   EXPECT_EQ(20, i);
 404
 405   ReleaseTiles(&tiles);
 406 }
 407
 408 TEST_F(PrioritizedTileSetTest, TilesForEachBin) {
 409   // Aggregate test with one tile for each of the bins, which
 410   // should appear in order of the bins.
 411
 412   scoped_refptr<Tile> now_and_ready_to_draw_bin = CreateTile();
 413   scoped_refptr<Tile> now_bin = CreateTile();
 414   scoped_refptr<Tile> soon_bin = CreateTile();
 415   scoped_refptr<Tile> eventually_and_active_bin = CreateTile();
 416   scoped_refptr<Tile> eventually_bin = CreateTile();
 417   scoped_refptr<Tile> at_last_bin = CreateTile();
 418   scoped_refptr<Tile> at_last_and_active_bin = CreateTile();
 419
 420   PrioritizedTileSet set;
 421   set.InsertTile(soon_bin, SOON_BIN);
 422   set.InsertTile(at_last_and_active_bin, AT_LAST_AND_ACTIVE_BIN);
 423   set.InsertTile(eventually_bin, EVENTUALLY_BIN);
 424   set.InsertTile(now_bin, NOW_BIN);
 425   set.InsertTile(eventually_and_active_bin, EVENTUALLY_AND_ACTIVE_BIN);
 426   set.InsertTile(at_last_bin, AT_LAST_BIN);
 427   set.InsertTile(now_and_ready_to_draw_bin, NOW_AND_READY_TO_DRAW_BIN);
 428
 429   // Tiles should appear in order.
 430   PrioritizedTileSet::Iterator it(&set, true);
 431   EXPECT_TRUE(*it == now_and_ready_to_draw_bin.get());
 432   ++it;
 433   EXPECT_TRUE(*it == now_bin.get());
 434   ++it;
 435   EXPECT_TRUE(*it == soon_bin.get());
 436   ++it;
 437   EXPECT_TRUE(*it == eventually_and_active_bin.get());
 438   ++it;
 439   EXPECT_TRUE(*it == eventually_bin.get());
 440   ++it;
 441   EXPECT_TRUE(*it == at_last_and_active_bin.get());
 442   ++it;
 443   EXPECT_TRUE(*it == at_last_bin.get());
 444   ++it;
 445   EXPECT_FALSE(it);
 446 }
 447
 448 TEST_F(PrioritizedTileSetTest, ManyTilesForEachBin) {
 449   // Aggregate test with many tiles in each of the bins of various
 450   // priorities. Ensure that they are all returned in a sorted order.
 451
 452   std::vector<scoped_refptr<Tile> > now_and_ready_to_draw_bins;
 453   std::vector<scoped_refptr<Tile> > now_bins;
 454   std::vector<scoped_refptr<Tile> > soon_bins;
 455   std::vector<scoped_refptr<Tile> > eventually_and_active_bins;
 456   std::vector<scoped_refptr<Tile> > eventually_bins;
 457   std::vector<scoped_refptr<Tile> > at_last_bins;
 458   std::vector<scoped_refptr<Tile> > at_last_and_active_bins;
 459
 460   TilePriority priorities[4] = {
 461       TilePriorityForEventualBin(),
 462       TilePriorityForNowBin(),
 463       TilePriority(),
 464       TilePriorityForSoonBin()};
 465
 466   PrioritizedTileSet set;
 467   for (int priority = 0; priority < 4; ++priority) {
 468     for (int i = 0; i < 5; ++i) {
 469       scoped_refptr<Tile> tile = CreateTile();
 470       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
 471       tile->SetPriority(PENDING_TREE, priorities[priority]);
 472
 473       now_and_ready_to_draw_bins.push_back(tile);
 474       now_bins.push_back(tile);
 475       soon_bins.push_back(tile);
 476       eventually_and_active_bins.push_back(tile);
 477       eventually_bins.push_back(tile);
 478       at_last_bins.push_back(tile);
 479       at_last_and_active_bins.push_back(tile);
 480
 481       set.InsertTile(tile, NOW_AND_READY_TO_DRAW_BIN);
 482       set.InsertTile(tile, NOW_BIN);
 483       set.InsertTile(tile, SOON_BIN);
 484       set.InsertTile(tile, EVENTUALLY_AND_ACTIVE_BIN);
 485       set.InsertTile(tile, EVENTUALLY_BIN);
 486       set.InsertTile(tile, AT_LAST_BIN);
 487       set.InsertTile(tile, AT_LAST_AND_ACTIVE_BIN);
 488     }
 489   }
 490
 491   PrioritizedTileSet::Iterator it(&set, true);
 492   std::vector<scoped_refptr<Tile> >::iterator vector_it;
 493
 494   // Now and ready are not sorted.
 495   for (vector_it = now_and_ready_to_draw_bins.begin();
 496        vector_it != now_and_ready_to_draw_bins.end();
 497        ++vector_it) {
 498     EXPECT_TRUE(*vector_it == *it);
 499     ++it;
 500   }
 501
 502   // Now bins are sorted.
 503   std::sort(now_bins.begin(), now_bins.end(), BinComparator());
 504   for (vector_it = now_bins.begin(); vector_it != now_bins.end(); ++vector_it) {
 505     EXPECT_TRUE(*vector_it == *it);
 506     ++it;
 507   }
 508
 509   // Soon bins are sorted.
 510   std::sort(soon_bins.begin(), soon_bins.end(), BinComparator());
 511   for (vector_it = soon_bins.begin(); vector_it != soon_bins.end();
 512        ++vector_it) {
 513     EXPECT_TRUE(*vector_it == *it);
 514     ++it;
 515   }
 516
 517   // Eventually and active bins are sorted.
 518   std::sort(eventually_and_active_bins.begin(),
 519             eventually_and_active_bins.end(),
 520             BinComparator());
 521   for (vector_it = eventually_and_active_bins.begin();
 522        vector_it != eventually_and_active_bins.end();
 523        ++vector_it) {
 524     EXPECT_TRUE(*vector_it == *it);
 525     ++it;
 526   }
 527
 528   // Eventually bins are sorted.
 529   std::sort(eventually_bins.begin(), eventually_bins.end(), BinComparator());
 530   for (vector_it = eventually_bins.begin(); vector_it != eventually_bins.end();
 531        ++vector_it) {
 532     EXPECT_TRUE(*vector_it == *it);
 533     ++it;
 534   }
 535
 536   // At last and active bins are sorted.
 537   std::sort(at_last_and_active_bins.begin(),
 538             at_last_and_active_bins.end(),
 539             BinComparator());
 540   for (vector_it = at_last_and_active_bins.begin();
 541        vector_it != at_last_and_active_bins.end();
 542        ++vector_it) {
 543     EXPECT_TRUE(*vector_it == *it);
 544     ++it;
 545   }
 546
 547   // At last bins are sorted.
 548   std::sort(at_last_bins.begin(), at_last_bins.end(), BinComparator());
 549   for (vector_it = at_last_bins.begin(); vector_it != at_last_bins.end();
 550        ++vector_it) {
 551     EXPECT_TRUE(*vector_it == *it);
 552     ++it;
 553   }
 554
 555   EXPECT_FALSE(it);
 556
 557   ReleaseTiles(&now_and_ready_to_draw_bins);
 558   ReleaseTiles(&now_bins);
 559   ReleaseTiles(&soon_bins);
 560   ReleaseTiles(&eventually_and_active_bins);
 561   ReleaseTiles(&eventually_bins);
 562   ReleaseTiles(&at_last_bins);
 563   ReleaseTiles(&at_last_and_active_bins);
 564 }
 565
 566 TEST_F(PrioritizedTileSetTest, ManyTilesForEachBinDisablePriority) {
 567   // Aggregate test with many tiles for each of the bins. Tiles should
 568   // appear in order, until DisablePriorityOrdering is called. After that
 569   // tiles should appear in the order they were inserted.
 570
 571   std::vector<scoped_refptr<Tile> > now_and_ready_to_draw_bins;
 572   std::vector<scoped_refptr<Tile> > now_bins;
 573   std::vector<scoped_refptr<Tile> > soon_bins;
 574   std::vector<scoped_refptr<Tile> > eventually_and_active_bins;
 575   std::vector<scoped_refptr<Tile> > eventually_bins;
 576   std::vector<scoped_refptr<Tile> > at_last_bins;
 577   std::vector<scoped_refptr<Tile> > at_last_and_active_bins;
 578
 579   TilePriority priorities[4] = {
 580       TilePriorityForEventualBin(),
 581       TilePriorityForNowBin(),
 582       TilePriority(),
 583       TilePriorityForSoonBin()};
 584
 585   PrioritizedTileSet set;
 586   for (int priority = 0; priority < 4; ++priority) {
 587     for (int i = 0; i < 5; ++i) {
 588       scoped_refptr<Tile> tile = CreateTile();
 589       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
 590       tile->SetPriority(PENDING_TREE, priorities[priority]);
 591
 592       now_and_ready_to_draw_bins.push_back(tile);
 593       now_bins.push_back(tile);
 594       soon_bins.push_back(tile);
 595       eventually_and_active_bins.push_back(tile);
 596       eventually_bins.push_back(tile);
 597       at_last_bins.push_back(tile);
 598       at_last_and_active_bins.push_back(tile);
 599
 600       set.InsertTile(tile, NOW_AND_READY_TO_DRAW_BIN);
 601       set.InsertTile(tile, NOW_BIN);
 602       set.InsertTile(tile, SOON_BIN);
 603       set.InsertTile(tile, EVENTUALLY_AND_ACTIVE_BIN);
 604       set.InsertTile(tile, EVENTUALLY_BIN);
 605       set.InsertTile(tile, AT_LAST_BIN);
 606       set.InsertTile(tile, AT_LAST_AND_ACTIVE_BIN);
 607     }
 608   }
 609
 610   PrioritizedTileSet::Iterator it(&set, true);
 611   std::vector<scoped_refptr<Tile> >::iterator vector_it;
 612
 613   // Now and ready are not sorted.
 614   for (vector_it = now_and_ready_to_draw_bins.begin();
 615        vector_it != now_and_ready_to_draw_bins.end();
 616        ++vector_it) {
 617     EXPECT_TRUE(*vector_it == *it);
 618     ++it;
 619   }
 620
 621   // Now bins are sorted.
 622   std::sort(now_bins.begin(), now_bins.end(), BinComparator());
 623   for (vector_it = now_bins.begin(); vector_it != now_bins.end(); ++vector_it) {
 624     EXPECT_TRUE(*vector_it == *it);
 625     ++it;
 626   }
 627
 628   // Soon bins are sorted.
 629   std::sort(soon_bins.begin(), soon_bins.end(), BinComparator());
 630   for (vector_it = soon_bins.begin(); vector_it != soon_bins.end();
 631        ++vector_it) {
 632     EXPECT_TRUE(*vector_it == *it);
 633     ++it;
 634   }
 635
 636   // After we disable priority ordering, we already have sorted the next vector.
 637   it.DisablePriorityOrdering();
 638
 639   // Eventually and active bins are sorted.
 640   std::sort(eventually_and_active_bins.begin(),
 641             eventually_and_active_bins.end(),
 642             BinComparator());
 643   for (vector_it = eventually_and_active_bins.begin();
 644        vector_it != eventually_and_active_bins.end();
 645        ++vector_it) {
 646     EXPECT_TRUE(*vector_it == *it);
 647     ++it;
 648   }
 649
 650   // Eventually bins are not sorted.
 651   for (vector_it = eventually_bins.begin(); vector_it != eventually_bins.end();
 652        ++vector_it) {
 653     EXPECT_TRUE(*vector_it == *it);
 654     ++it;
 655   }
 656
 657   // At last and active bins are not sorted.
 658   for (vector_it = at_last_and_active_bins.begin();
 659        vector_it != at_last_and_active_bins.end();
 660        ++vector_it) {
 661     EXPECT_TRUE(*vector_it == *it);
 662     ++it;
 663   }
 664
 665   // At last bins are not sorted.
 666   for (vector_it = at_last_bins.begin(); vector_it != at_last_bins.end();
 667        ++vector_it) {
 668     EXPECT_TRUE(*vector_it == *it);
 669     ++it;
 670   }
 671
 672   EXPECT_FALSE(it);
 673
 674   ReleaseTiles(&now_and_ready_to_draw_bins);
 675   ReleaseTiles(&now_bins);
 676   ReleaseTiles(&soon_bins);
 677   ReleaseTiles(&eventually_and_active_bins);
 678   ReleaseTiles(&eventually_bins);
 679   ReleaseTiles(&at_last_bins);
 680   ReleaseTiles(&at_last_and_active_bins);
 681 }
 682
 683 TEST_F(PrioritizedTileSetTest, TilesForFirstAndLastBins) {
 684   // Make sure that if we have empty lists between two non-empty lists,
 685   // we just get two tiles from the iterator.
 686
 687   scoped_refptr<Tile> now_and_ready_to_draw_bin = CreateTile();
 688   scoped_refptr<Tile> at_last_bin = CreateTile();
 689
 690   PrioritizedTileSet set;
 691   set.InsertTile(at_last_bin, AT_LAST_BIN);
 692   set.InsertTile(now_and_ready_to_draw_bin, NOW_AND_READY_TO_DRAW_BIN);
 693
 694   // Only two tiles should appear and they should appear in order.
 695   PrioritizedTileSet::Iterator it(&set, true);
 696   EXPECT_TRUE(*it == now_and_ready_to_draw_bin.get());
 697   ++it;
 698   EXPECT_TRUE(*it == at_last_bin.get());
 699   ++it;
 700   EXPECT_FALSE(it);
 701 }
 702
 703 TEST_F(PrioritizedTileSetTest, MultipleIterators) {
 704   // Ensure that multiple iterators don't interfere with each other.
 705
 706   scoped_refptr<Tile> now_and_ready_to_draw_bin = CreateTile();
 707   scoped_refptr<Tile> now_bin = CreateTile();
 708   scoped_refptr<Tile> soon_bin = CreateTile();
 709   scoped_refptr<Tile> eventually_bin = CreateTile();
 710   scoped_refptr<Tile> at_last_bin = CreateTile();
 711
 712   PrioritizedTileSet set;
 713   set.InsertTile(soon_bin, SOON_BIN);
 714   set.InsertTile(eventually_bin, EVENTUALLY_BIN);
 715   set.InsertTile(now_bin, NOW_BIN);
 716   set.InsertTile(at_last_bin, AT_LAST_BIN);
 717   set.InsertTile(now_and_ready_to_draw_bin, NOW_AND_READY_TO_DRAW_BIN);
 718
 719   // Tiles should appear in order.
 720   PrioritizedTileSet::Iterator it(&set, true);
 721   EXPECT_TRUE(*it == now_and_ready_to_draw_bin.get());
 722   ++it;
 723   EXPECT_TRUE(*it == now_bin.get());
 724   ++it;
 725   EXPECT_TRUE(*it == soon_bin.get());
 726   ++it;
 727   EXPECT_TRUE(*it == eventually_bin.get());
 728   ++it;
 729   EXPECT_TRUE(*it == at_last_bin.get());
 730   ++it;
 731   EXPECT_FALSE(it);
 732
 733   // Creating multiple iterators shouldn't affect old iterators.
 734   PrioritizedTileSet::Iterator second_it(&set, true);
 735   EXPECT_TRUE(second_it);
 736   EXPECT_FALSE(it);
 737
 738   ++second_it;
 739   EXPECT_TRUE(second_it);
 740   ++second_it;
 741   EXPECT_TRUE(second_it);
 742   EXPECT_FALSE(it);
 743
 744   PrioritizedTileSet::Iterator third_it(&set, true);
 745   EXPECT_TRUE(third_it);
 746   ++second_it;
 747   ++second_it;
 748   EXPECT_TRUE(second_it);
 749   EXPECT_TRUE(third_it);
 750   EXPECT_FALSE(it);
 751
 752   ++third_it;
 753   ++third_it;
 754   EXPECT_TRUE(third_it);
 755   EXPECT_TRUE(*third_it == soon_bin.get());
 756   EXPECT_TRUE(second_it);
 757   EXPECT_TRUE(*second_it == at_last_bin.get());
 758   EXPECT_FALSE(it);
 759
 760   ++second_it;
 761   EXPECT_TRUE(third_it);
 762   EXPECT_FALSE(second_it);
 763   EXPECT_FALSE(it);
 764
 765   set.Clear();
 766
 767   PrioritizedTileSet::Iterator empty_it(&set, true);
 768   EXPECT_FALSE(empty_it);
 769 }
 770
 771 }  // namespace
 772 }  // namespace cc
 773