Move occlusion info to TilePriority.

cc/resources/prioritized_tile_set_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <vector>
 
 #include "cc/resources/managed_tile_state.h"
 #include "cc/resources/prioritized_tile_set.h"
 #include "cc/resources/tile.h"
@@ skipping 98 matching lines @@
   EXPECT_TRUE(it);
   EXPECT_TRUE(*it == tile.get());
   ++it;
   EXPECT_FALSE(it);
 }
 
 TEST_F(PrioritizedTileSetTest, NowAndReadyToDrawBin) {
   // Ensure that tiles in NOW_AND_READY_TO_DRAW_BIN aren't sorted.
 
   PrioritizedTileSet set;
-  TilePriority priorities[4] = {
-      TilePriorityForEventualBin(),
-      TilePriorityForNowBin(),
-      TilePriority(),
-      TilePriorityForSoonBin()};
+  TilePriority priorities[4] = {TilePriorityForEventualBin(),
+                                TilePriorityForUnoccludedNowBin(),
+                                TilePriority(), TilePriorityForSoonBin()};
 
   std::vector<scoped_refptr<Tile> > tiles;
   for (int priority = 0; priority < 4; ++priority) {
     for (int i = 0; i < 5; ++i) {
       scoped_refptr<Tile> tile = CreateTile();
       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
       tile->SetPriority(PENDING_TREE, priorities[priority]);
       tiles.push_back(tile);
       set.InsertTile(tile, NOW_AND_READY_TO_DRAW_BIN);
     }
   }
 
   // Tiles should appear in the same order as inserted.
   int i = 0;
   for (PrioritizedTileSet::Iterator it(&set, true);
        it;
        ++it) {
     EXPECT_TRUE(*it == tiles[i].get());
     ++i;
   }
   EXPECT_EQ(20, i);
 }
 
 TEST_F(PrioritizedTileSetTest, NowBin) {
   // Ensure that tiles in NOW_BIN are sorted according to BinComparator.
 
   PrioritizedTileSet set;
-  TilePriority priorities[4] = {
-      TilePriorityForEventualBin(),
-      TilePriorityForNowBin(),
-      TilePriority(),
-      TilePriorityForSoonBin()};
+  TilePriority priorities[4] = {TilePriorityForEventualBin(),
+                                TilePriorityForUnoccludedNowBin(),
+                                TilePriority(), TilePriorityForSoonBin()};
 
   std::vector<scoped_refptr<Tile> > tiles;
   for (int priority = 0; priority < 4; ++priority) {
     for (int i = 0; i < 5; ++i) {
       scoped_refptr<Tile> tile = CreateTile();
       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
       tile->SetPriority(PENDING_TREE, priorities[priority]);
       tiles.push_back(tile);
       set.InsertTile(tile, NOW_BIN);
     }
   }
 
   // Tiles should appear in BinComparator order.
   std::sort(tiles.begin(), tiles.end(), BinComparator());
 
   int i = 0;
   for (PrioritizedTileSet::Iterator it(&set, true);
        it;
        ++it) {
     EXPECT_TRUE(*it == tiles[i].get());
     ++i;
   }
   EXPECT_EQ(20, i);
 }
 
 TEST_F(PrioritizedTileSetTest, SoonBin) {
   // Ensure that tiles in SOON_BIN are sorted according to BinComparator.
 
   PrioritizedTileSet set;
-  TilePriority priorities[4] = {
-      TilePriorityForEventualBin(),
-      TilePriorityForNowBin(),
-      TilePriority(),
-      TilePriorityForSoonBin()};
+  TilePriority priorities[4] = {TilePriorityForEventualBin(),
+                                TilePriorityForUnoccludedNowBin(),
+                                TilePriority(), TilePriorityForSoonBin()};
 
   std::vector<scoped_refptr<Tile> > tiles;
   for (int priority = 0; priority < 4; ++priority) {
     for (int i = 0; i < 5; ++i) {
       scoped_refptr<Tile> tile = CreateTile();
       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
       tile->SetPriority(PENDING_TREE, priorities[priority]);
       tiles.push_back(tile);
       set.InsertTile(tile, SOON_BIN);
     }
@@ skipping 10 matching lines @@
     ++i;
   }
   EXPECT_EQ(20, i);
 }
 
 TEST_F(PrioritizedTileSetTest, SoonBinNoPriority) {
   // Ensure that when not using priority iterator, SOON_BIN tiles
   // are not sorted.
 
   PrioritizedTileSet set;
-  TilePriority priorities[4] = {
-      TilePriorityForEventualBin(),
-      TilePriorityForNowBin(),
-      TilePriority(),
-      TilePriorityForSoonBin()};
+  TilePriority priorities[4] = {TilePriorityForEventualBin(),
+                                TilePriorityForUnoccludedNowBin(),
+                                TilePriority(), TilePriorityForSoonBin()};
 
   std::vector<scoped_refptr<Tile> > tiles;
   for (int priority = 0; priority < 4; ++priority) {
     for (int i = 0; i < 5; ++i) {
       scoped_refptr<Tile> tile = CreateTile();
       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
       tile->SetPriority(PENDING_TREE, priorities[priority]);
       tiles.push_back(tile);
       set.InsertTile(tile, SOON_BIN);
     }
   }
 
   int i = 0;
   for (PrioritizedTileSet::Iterator it(&set, false);
        it;
        ++it) {
     EXPECT_TRUE(*it == tiles[i].get());
     ++i;
   }
   EXPECT_EQ(20, i);
 }
 
 TEST_F(PrioritizedTileSetTest, EventuallyAndActiveBin) {
   // Ensure that EVENTUALLY_AND_ACTIVE_BIN tiles are sorted.
 
   PrioritizedTileSet set;
-  TilePriority priorities[4] = {
-      TilePriorityForEventualBin(),
-      TilePriorityForNowBin(),
-      TilePriority(),
-      TilePriorityForSoonBin()};
+  TilePriority priorities[4] = {TilePriorityForEventualBin(),
+                                TilePriorityForUnoccludedNowBin(),
+                                TilePriority(), TilePriorityForSoonBin()};
 
   std::vector<scoped_refptr<Tile> > tiles;
   for (int priority = 0; priority < 4; ++priority) {
     for (int i = 0; i < 5; ++i) {
       scoped_refptr<Tile> tile = CreateTile();
       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
       tile->SetPriority(PENDING_TREE, priorities[priority]);
       tiles.push_back(tile);
       set.InsertTile(tile, EVENTUALLY_AND_ACTIVE_BIN);
     }
   }
 
   // Tiles should appear in BinComparator order.
   std::sort(tiles.begin(), tiles.end(), BinComparator());
 
   int i = 0;
   for (PrioritizedTileSet::Iterator it(&set, true);
        it;
        ++it) {
     EXPECT_TRUE(*it == tiles[i].get());
     ++i;
   }
   EXPECT_EQ(20, i);
 }
 
 TEST_F(PrioritizedTileSetTest, EventuallyBin) {
   // Ensure that EVENTUALLY_BIN tiles are sorted.
 
   PrioritizedTileSet set;
-  TilePriority priorities[4] = {
-      TilePriorityForEventualBin(),
-      TilePriorityForNowBin(),
-      TilePriority(),
-      TilePriorityForSoonBin()};
+  TilePriority priorities[4] = {TilePriorityForEventualBin(),
+                                TilePriorityForUnoccludedNowBin(),
+                                TilePriority(), TilePriorityForSoonBin()};
 
   std::vector<scoped_refptr<Tile> > tiles;
   for (int priority = 0; priority < 4; ++priority) {
     for (int i = 0; i < 5; ++i) {
       scoped_refptr<Tile> tile = CreateTile();
       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
       tile->SetPriority(PENDING_TREE, priorities[priority]);
       tiles.push_back(tile);
       set.InsertTile(tile, EVENTUALLY_BIN);
     }
   }
 
   // Tiles should appear in BinComparator order.
   std::sort(tiles.begin(), tiles.end(), BinComparator());
 
   int i = 0;
   for (PrioritizedTileSet::Iterator it(&set, true);
        it;
        ++it) {
     EXPECT_TRUE(*it == tiles[i].get());
     ++i;
   }
   EXPECT_EQ(20, i);
 }
 
 TEST_F(PrioritizedTileSetTest, AtLastAndActiveBin) {
   // Ensure that AT_LAST_AND_ACTIVE_BIN tiles are sorted.
 
   PrioritizedTileSet set;
-  TilePriority priorities[4] = {
-      TilePriorityForEventualBin(),
-      TilePriorityForNowBin(),
-      TilePriority(),
-      TilePriorityForSoonBin()};
+  TilePriority priorities[4] = {TilePriorityForEventualBin(),
+                                TilePriorityForUnoccludedNowBin(),
+                                TilePriority(), TilePriorityForSoonBin()};
 
   std::vector<scoped_refptr<Tile> > tiles;
   for (int priority = 0; priority < 4; ++priority) {
     for (int i = 0; i < 5; ++i) {
       scoped_refptr<Tile> tile = CreateTile();
       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
       tile->SetPriority(PENDING_TREE, priorities[priority]);
       tiles.push_back(tile);
       set.InsertTile(tile, AT_LAST_AND_ACTIVE_BIN);
     }
   }
 
   // Tiles should appear in BinComparator order.
   std::sort(tiles.begin(), tiles.end(), BinComparator());
 
   int i = 0;
   for (PrioritizedTileSet::Iterator it(&set, true);
        it;
        ++it) {
     EXPECT_TRUE(*it == tiles[i].get());
     ++i;
   }
   EXPECT_EQ(20, i);
 }
 
 TEST_F(PrioritizedTileSetTest, AtLastBin) {
   // Ensure that AT_LAST_BIN tiles are sorted.
 
   PrioritizedTileSet set;
-  TilePriority priorities[4] = {
-      TilePriorityForEventualBin(),
-      TilePriorityForNowBin(),
-      TilePriority(),
-      TilePriorityForSoonBin()};
+  TilePriority priorities[4] = {TilePriorityForEventualBin(),
+                                TilePriorityForUnoccludedNowBin(),
+                                TilePriority(), TilePriorityForSoonBin()};
 
   std::vector<scoped_refptr<Tile> > tiles;
   for (int priority = 0; priority < 4; ++priority) {
     for (int i = 0; i < 5; ++i) {
       scoped_refptr<Tile> tile = CreateTile();
       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
       tile->SetPriority(PENDING_TREE, priorities[priority]);
       tiles.push_back(tile);
       set.InsertTile(tile, AT_LAST_BIN);
     }
@@ skipping 57 matching lines @@
   // priorities. Ensure that they are all returned in a sorted order.
 
   std::vector<scoped_refptr<Tile> > now_and_ready_to_draw_bins;
   std::vector<scoped_refptr<Tile> > now_bins;
   std::vector<scoped_refptr<Tile> > soon_bins;
   std::vector<scoped_refptr<Tile> > eventually_and_active_bins;
   std::vector<scoped_refptr<Tile> > eventually_bins;
   std::vector<scoped_refptr<Tile> > at_last_bins;
   std::vector<scoped_refptr<Tile> > at_last_and_active_bins;
 
-  TilePriority priorities[4] = {
-      TilePriorityForEventualBin(),
-      TilePriorityForNowBin(),
-      TilePriority(),
-      TilePriorityForSoonBin()};
+  TilePriority priorities[4] = {TilePriorityForEventualBin(),
+                                TilePriorityForUnoccludedNowBin(),
+                                TilePriority(), TilePriorityForSoonBin()};
 
   PrioritizedTileSet set;
   for (int priority = 0; priority < 4; ++priority) {
     for (int i = 0; i < 5; ++i) {
       scoped_refptr<Tile> tile = CreateTile();
       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
       tile->SetPriority(PENDING_TREE, priorities[priority]);
 
       now_and_ready_to_draw_bins.push_back(tile);
       now_bins.push_back(tile);
@@ skipping 86 matching lines @@
   // tiles should appear in the order they were inserted.
 
   std::vector<scoped_refptr<Tile> > now_and_ready_to_draw_bins;
   std::vector<scoped_refptr<Tile> > now_bins;
   std::vector<scoped_refptr<Tile> > soon_bins;
   std::vector<scoped_refptr<Tile> > eventually_and_active_bins;
   std::vector<scoped_refptr<Tile> > eventually_bins;
   std::vector<scoped_refptr<Tile> > at_last_bins;
   std::vector<scoped_refptr<Tile> > at_last_and_active_bins;
 
-  TilePriority priorities[4] = {
-      TilePriorityForEventualBin(),
-      TilePriorityForNowBin(),
-      TilePriority(),
-      TilePriorityForSoonBin()};
+  TilePriority priorities[4] = {TilePriorityForEventualBin(),
+                                TilePriorityForUnoccludedNowBin(),
+                                TilePriority(), TilePriorityForSoonBin()};
 
   PrioritizedTileSet set;
   for (int priority = 0; priority < 4; ++priority) {
     for (int i = 0; i < 5; ++i) {
       scoped_refptr<Tile> tile = CreateTile();
       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
       tile->SetPriority(PENDING_TREE, priorities[priority]);
 
       now_and_ready_to_draw_bins.push_back(tile);
       now_bins.push_back(tile);
@@ skipping 162 matching lines @@
 
   set.Clear();
 
   PrioritizedTileSet::Iterator empty_it(&set, true);
   EXPECT_FALSE(empty_it);
 }
 
 }  // namespace
 }  // namespace cc