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