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