Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(3841)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: cc/resources/tile_manager_unittest.cc

Issue 885443002: Roll Chrome into Mojo. (Closed) Base URL: https://github.com/domokit/mojo.git@master
Patch Set: Rebase to ToT mojo Created 5 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « cc/resources/tile_manager_perftest.cc ('k') | cc/resources/tile_priority.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: cc/resources/tile_manager_unittest.cc
diff --git a/cc/resources/tile_manager_unittest.cc b/cc/resources/tile_manager_unittest.cc
index aae4e3f9d5b706f9e6a1a0600456058ae83bfe2a..8b5ab3f41b7ba8d4911748e0123ff5b483f6a07f 100644
--- a/cc/resources/tile_manager_unittest.cc
+++ b/cc/resources/tile_manager_unittest.cc
@@ -151,18 +151,17 @@ TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueue) {
host_impl_.SetViewportSize(layer_bounds);
SetupDefaultTrees(layer_bounds);
- RasterTilePriorityQueue queue;
- host_impl_.BuildRasterQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::ALL);
- EXPECT_FALSE(queue.IsEmpty());
+ scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
+ SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
+ EXPECT_FALSE(queue->IsEmpty());
size_t tile_count = 0;
std::set<Tile*> all_tiles;
- while (!queue.IsEmpty()) {
- EXPECT_TRUE(queue.Top());
- all_tiles.insert(queue.Top());
+ while (!queue->IsEmpty()) {
+ EXPECT_TRUE(queue->Top());
+ all_tiles.insert(queue->Top());
++tile_count;
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(tile_count, all_tiles.size());
@@ -170,12 +169,11 @@ TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueue) {
// Sanity check, all tiles should be visible.
std::set<Tile*> smoothness_tiles;
- queue.Reset();
- host_impl_.BuildRasterQueue(&queue, SMOOTHNESS_TAKES_PRIORITY,
- RasterTilePriorityQueue::Type::ALL);
+ queue = host_impl_.BuildRasterQueue(SMOOTHNESS_TAKES_PRIORITY,
+ RasterTilePriorityQueue::Type::ALL);
bool had_low_res = false;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile);
EXPECT_EQ(TilePriority::NOW, tile->priority(ACTIVE_TREE).priority_bin);
EXPECT_EQ(TilePriority::NOW, tile->priority(PENDING_TREE).priority_bin);
@@ -183,35 +181,34 @@ TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueue) {
had_low_res = true;
else
smoothness_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(all_tiles, smoothness_tiles);
EXPECT_TRUE(had_low_res);
// Check that everything is required for activation.
- queue.Reset();
- host_impl_.BuildRasterQueue(
- &queue, SMOOTHNESS_TAKES_PRIORITY,
+ queue = host_impl_.BuildRasterQueue(
+ SMOOTHNESS_TAKES_PRIORITY,
RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
std::set<Tile*> required_for_activation_tiles;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile->required_for_activation());
required_for_activation_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(all_tiles, required_for_activation_tiles);
// Check that everything is required for draw.
- queue.Reset();
- host_impl_.BuildRasterQueue(&queue, SMOOTHNESS_TAKES_PRIORITY,
- RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
+ queue = host_impl_.BuildRasterQueue(
+ SMOOTHNESS_TAKES_PRIORITY,
+ RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
std::set<Tile*> required_for_draw_tiles;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile->required_for_draw());
required_for_draw_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(all_tiles, required_for_draw_tiles);
@@ -268,13 +265,12 @@ TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueue) {
tile_count = 0;
size_t correct_order_tiles = 0u;
// Here we expect to get increasing ACTIVE_TREE priority_bin.
- queue.Reset();
- host_impl_.BuildRasterQueue(&queue, SMOOTHNESS_TAKES_PRIORITY,
- RasterTilePriorityQueue::Type::ALL);
+ queue = host_impl_.BuildRasterQueue(SMOOTHNESS_TAKES_PRIORITY,
+ RasterTilePriorityQueue::Type::ALL);
std::set<Tile*> expected_required_for_draw_tiles;
std::set<Tile*> expected_required_for_activation_tiles;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile);
if (!last_tile)
@@ -312,7 +308,7 @@ TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueue) {
expected_required_for_draw_tiles.insert(tile);
if (tile->required_for_activation())
expected_required_for_activation_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(tile_count, smoothness_tiles.size());
@@ -322,31 +318,30 @@ TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueue) {
EXPECT_GT(correct_order_tiles, 3 * tile_count / 4);
// Check that we have consistent required_for_activation tiles.
- queue.Reset();
- host_impl_.BuildRasterQueue(
- &queue, SMOOTHNESS_TAKES_PRIORITY,
+ queue = host_impl_.BuildRasterQueue(
+ SMOOTHNESS_TAKES_PRIORITY,
RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
required_for_activation_tiles.clear();
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile->required_for_activation());
required_for_activation_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(expected_required_for_activation_tiles,
required_for_activation_tiles);
EXPECT_NE(all_tiles, required_for_activation_tiles);
// Check that we have consistent required_for_draw tiles.
- queue.Reset();
- host_impl_.BuildRasterQueue(&queue, SMOOTHNESS_TAKES_PRIORITY,
- RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
+ queue = host_impl_.BuildRasterQueue(
+ SMOOTHNESS_TAKES_PRIORITY,
+ RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
required_for_draw_tiles.clear();
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile->required_for_draw());
required_for_draw_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(expected_required_for_draw_tiles, required_for_draw_tiles);
EXPECT_NE(all_tiles, required_for_draw_tiles);
@@ -355,12 +350,11 @@ TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueue) {
last_tile = NULL;
size_t increasing_distance_tiles = 0u;
// Here we expect to get increasing PENDING_TREE priority_bin.
- queue.Reset();
- host_impl_.BuildRasterQueue(&queue, NEW_CONTENT_TAKES_PRIORITY,
- RasterTilePriorityQueue::Type::ALL);
+ queue = host_impl_.BuildRasterQueue(NEW_CONTENT_TAKES_PRIORITY,
+ RasterTilePriorityQueue::Type::ALL);
tile_count = 0;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile);
if (!last_tile)
@@ -385,7 +379,7 @@ TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueue) {
last_tile = tile;
new_content_tiles.insert(tile);
++tile_count;
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(tile_count, new_content_tiles.size());
@@ -395,31 +389,30 @@ TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueue) {
EXPECT_GE(increasing_distance_tiles, 3 * tile_count / 4);
// Check that we have consistent required_for_activation tiles.
- queue.Reset();
- host_impl_.BuildRasterQueue(
- &queue, NEW_CONTENT_TAKES_PRIORITY,
+ queue = host_impl_.BuildRasterQueue(
+ NEW_CONTENT_TAKES_PRIORITY,
RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
required_for_activation_tiles.clear();
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile->required_for_activation());
required_for_activation_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(expected_required_for_activation_tiles,
required_for_activation_tiles);
EXPECT_NE(new_content_tiles, required_for_activation_tiles);
// Check that we have consistent required_for_draw tiles.
- queue.Reset();
- host_impl_.BuildRasterQueue(&queue, NEW_CONTENT_TAKES_PRIORITY,
- RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
+ queue = host_impl_.BuildRasterQueue(
+ NEW_CONTENT_TAKES_PRIORITY,
+ RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
required_for_draw_tiles.clear();
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile->required_for_draw());
required_for_draw_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(expected_required_for_draw_tiles, required_for_draw_tiles);
EXPECT_NE(new_content_tiles, required_for_draw_tiles);
@@ -485,14 +478,13 @@ TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueueInvalidation) {
// The actual test will now build different queues and verify that the queues
// return the same information as computed manually above.
- RasterTilePriorityQueue queue;
- host_impl_.BuildRasterQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::ALL);
+ scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
+ SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
std::set<Tile*> actual_now_tiles;
std::set<Tile*> actual_all_tiles;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
- queue.Pop();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
+ queue->Pop();
if (tile->combined_priority().priority_bin == TilePriority::NOW)
actual_now_tiles.insert(tile);
actual_all_tiles.insert(tile);
@@ -500,25 +492,24 @@ TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueueInvalidation) {
EXPECT_EQ(expected_now_tiles, actual_now_tiles);
EXPECT_EQ(expected_all_tiles, actual_all_tiles);
- queue.Reset();
- host_impl_.BuildRasterQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
+ queue = host_impl_.BuildRasterQueue(
+ SAME_PRIORITY_FOR_BOTH_TREES,
+ RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
std::set<Tile*> actual_required_for_draw_tiles;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
- queue.Pop();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
+ queue->Pop();
actual_required_for_draw_tiles.insert(tile);
}
EXPECT_EQ(expected_required_for_draw_tiles, actual_required_for_draw_tiles);
- queue.Reset();
- host_impl_.BuildRasterQueue(
- &queue, SAME_PRIORITY_FOR_BOTH_TREES,
+ queue = host_impl_.BuildRasterQueue(
+ SAME_PRIORITY_FOR_BOTH_TREES,
RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
std::set<Tile*> actual_required_for_activation_tiles;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
- queue.Pop();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
+ queue->Pop();
actual_required_for_activation_tiles.insert(tile);
}
EXPECT_EQ(expected_required_for_activation_tiles,
@@ -552,22 +543,21 @@ TEST_F(TileManagerTilePriorityQueueTest, ActivationComesBeforeEventually) {
CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
host_impl_.pending_tree()->UpdateDrawProperties();
- RasterTilePriorityQueue queue;
host_impl_.SetRequiresHighResToDraw();
- host_impl_.BuildRasterQueue(&queue, SMOOTHNESS_TAKES_PRIORITY,
- RasterTilePriorityQueue::Type::ALL);
- EXPECT_FALSE(queue.IsEmpty());
+ scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
+ SMOOTHNESS_TAKES_PRIORITY, RasterTilePriorityQueue::Type::ALL));
+ EXPECT_FALSE(queue->IsEmpty());
// Get all the tiles that are NOW or SOON and make sure they are ready to
// draw.
std::vector<Tile*> all_tiles;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
if (tile->combined_priority().priority_bin >= TilePriority::EVENTUALLY)
break;
all_tiles.push_back(tile);
- queue.Pop();
+ queue->Pop();
}
tile_manager()->InitializeTilesWithResourcesForTesting(
@@ -583,20 +573,19 @@ TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueue) {
host_impl_.SetViewportSize(layer_bounds);
SetupDefaultTrees(layer_bounds);
- EvictionTilePriorityQueue empty_queue;
- host_impl_.BuildEvictionQueue(&empty_queue, SAME_PRIORITY_FOR_BOTH_TREES);
- EXPECT_TRUE(empty_queue.IsEmpty());
+ scoped_ptr<EvictionTilePriorityQueue> empty_queue(
+ host_impl_.BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
+ EXPECT_TRUE(empty_queue->IsEmpty());
std::set<Tile*> all_tiles;
size_t tile_count = 0;
- RasterTilePriorityQueue raster_queue;
- host_impl_.BuildRasterQueue(&raster_queue, SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::ALL);
- while (!raster_queue.IsEmpty()) {
+ scoped_ptr<RasterTilePriorityQueue> raster_queue(host_impl_.BuildRasterQueue(
+ SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
+ while (!raster_queue->IsEmpty()) {
++tile_count;
- EXPECT_TRUE(raster_queue.Top());
- all_tiles.insert(raster_queue.Top());
- raster_queue.Pop();
+ EXPECT_TRUE(raster_queue->Top());
+ all_tiles.insert(raster_queue->Top());
+ raster_queue->Pop();
}
EXPECT_EQ(tile_count, all_tiles.size());
@@ -605,20 +594,20 @@ TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueue) {
tile_manager()->InitializeTilesWithResourcesForTesting(
std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
- EvictionTilePriorityQueue queue;
- host_impl_.BuildEvictionQueue(&queue, SMOOTHNESS_TAKES_PRIORITY);
- EXPECT_FALSE(queue.IsEmpty());
+ scoped_ptr<EvictionTilePriorityQueue> queue(
+ host_impl_.BuildEvictionQueue(SMOOTHNESS_TAKES_PRIORITY));
+ EXPECT_FALSE(queue->IsEmpty());
// Sanity check, all tiles should be visible.
std::set<Tile*> smoothness_tiles;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile);
EXPECT_EQ(TilePriority::NOW, tile->priority(ACTIVE_TREE).priority_bin);
EXPECT_EQ(TilePriority::NOW, tile->priority(PENDING_TREE).priority_bin);
EXPECT_TRUE(tile->HasResource());
smoothness_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(all_tiles, smoothness_tiles);
@@ -675,12 +664,11 @@ TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueue) {
smoothness_tiles.clear();
tile_count = 0;
// Here we expect to get increasing ACTIVE_TREE priority_bin.
- queue.Reset();
- host_impl_.BuildEvictionQueue(&queue, SMOOTHNESS_TAKES_PRIORITY);
+ queue = host_impl_.BuildEvictionQueue(SMOOTHNESS_TAKES_PRIORITY);
int distance_increasing = 0;
int distance_decreasing = 0;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile);
EXPECT_TRUE(tile->HasResource());
@@ -706,7 +694,7 @@ TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueue) {
last_tile = tile;
++tile_count;
smoothness_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(3, distance_increasing);
@@ -717,12 +705,11 @@ TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueue) {
std::set<Tile*> new_content_tiles;
last_tile = NULL;
// Here we expect to get increasing PENDING_TREE priority_bin.
- queue.Reset();
- host_impl_.BuildEvictionQueue(&queue, NEW_CONTENT_TAKES_PRIORITY);
+ queue = host_impl_.BuildEvictionQueue(NEW_CONTENT_TAKES_PRIORITY);
distance_decreasing = 0;
distance_increasing = 0;
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
EXPECT_TRUE(tile);
if (!last_tile)
@@ -746,7 +733,7 @@ TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueue) {
last_tile = tile;
new_content_tiles.insert(tile);
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(3, distance_increasing);
@@ -787,14 +774,13 @@ TEST_F(TileManagerTilePriorityQueueTest,
std::set<Tile*> all_tiles;
size_t tile_count = 0;
- RasterTilePriorityQueue raster_queue;
- host_impl_.BuildRasterQueue(&raster_queue, SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::ALL);
- while (!raster_queue.IsEmpty()) {
+ scoped_ptr<RasterTilePriorityQueue> raster_queue(host_impl_.BuildRasterQueue(
+ SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
+ while (!raster_queue->IsEmpty()) {
++tile_count;
- EXPECT_TRUE(raster_queue.Top());
- all_tiles.insert(raster_queue.Top());
- raster_queue.Pop();
+ EXPECT_TRUE(raster_queue->Top());
+ all_tiles.insert(raster_queue->Top());
+ raster_queue->Pop();
}
EXPECT_EQ(tile_count, all_tiles.size());
EXPECT_EQ(32u, tile_count);
@@ -843,10 +829,10 @@ TEST_F(TileManagerTilePriorityQueueTest,
TreePriority tree_priority = NEW_CONTENT_TAKES_PRIORITY;
size_t occluded_count = 0u;
Tile* last_tile = NULL;
- EvictionTilePriorityQueue queue;
- host_impl_.BuildEvictionQueue(&queue, tree_priority);
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ scoped_ptr<EvictionTilePriorityQueue> queue(
+ host_impl_.BuildEvictionQueue(tree_priority));
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
if (!last_tile)
last_tile = tile;
@@ -872,7 +858,7 @@ TEST_F(TileManagerTilePriorityQueueTest,
}
}
last_tile = tile;
- queue.Pop();
+ queue->Pop();
}
size_t expected_occluded_count =
pending_child_high_res_tiles.size() + pending_child_low_res_tiles.size();
@@ -969,10 +955,10 @@ TEST_F(TileManagerTilePriorityQueueTest,
TreePriority tree_priority = NEW_CONTENT_TAKES_PRIORITY;
std::set<Tile*> new_content_tiles;
size_t tile_count = 0;
- EvictionTilePriorityQueue queue;
- host_impl_.BuildEvictionQueue(&queue, tree_priority);
- while (!queue.IsEmpty()) {
- Tile* tile = queue.Top();
+ scoped_ptr<EvictionTilePriorityQueue> queue(
+ host_impl_.BuildEvictionQueue(tree_priority));
+ while (!queue->IsEmpty()) {
+ Tile* tile = queue->Top();
const TilePriority& pending_priority = tile->priority(PENDING_TREE);
EXPECT_NE(std::numeric_limits<float>::infinity(),
pending_priority.distance_to_visible);
@@ -982,7 +968,7 @@ TEST_F(TileManagerTilePriorityQueueTest,
EXPECT_EQ(TilePriority::NOW, pending_priority.priority_bin);
new_content_tiles.insert(tile);
++tile_count;
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(tile_count, new_content_tiles.size());
EXPECT_EQ(all_tiles, new_content_tiles);
@@ -993,24 +979,22 @@ TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueueEmptyLayers) {
host_impl_.SetViewportSize(layer_bounds);
SetupDefaultTrees(layer_bounds);
- RasterTilePriorityQueue queue;
- host_impl_.BuildRasterQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::ALL);
- EXPECT_FALSE(queue.IsEmpty());
+ scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
+ SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
+ EXPECT_FALSE(queue->IsEmpty());
size_t tile_count = 0;
std::set<Tile*> all_tiles;
- while (!queue.IsEmpty()) {
- EXPECT_TRUE(queue.Top());
- all_tiles.insert(queue.Top());
+ while (!queue->IsEmpty()) {
+ EXPECT_TRUE(queue->Top());
+ all_tiles.insert(queue->Top());
++tile_count;
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(tile_count, all_tiles.size());
EXPECT_EQ(16u, tile_count);
- queue.Reset();
for (int i = 1; i < 10; ++i) {
scoped_ptr<FakePictureLayerImpl> pending_layer =
FakePictureLayerImpl::Create(host_impl_.pending_tree(), id_ + i);
@@ -1019,17 +1003,17 @@ TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueueEmptyLayers) {
pending_layer_->AddChild(pending_layer.Pass());
}
- host_impl_.BuildRasterQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::ALL);
- EXPECT_FALSE(queue.IsEmpty());
+ queue = host_impl_.BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
+ RasterTilePriorityQueue::Type::ALL);
+ EXPECT_FALSE(queue->IsEmpty());
tile_count = 0;
all_tiles.clear();
- while (!queue.IsEmpty()) {
- EXPECT_TRUE(queue.Top());
- all_tiles.insert(queue.Top());
+ while (!queue->IsEmpty()) {
+ EXPECT_TRUE(queue->Top());
+ all_tiles.insert(queue->Top());
++tile_count;
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(tile_count, all_tiles.size());
EXPECT_EQ(16u, tile_count);
@@ -1040,18 +1024,17 @@ TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueueEmptyLayers) {
host_impl_.SetViewportSize(layer_bounds);
SetupDefaultTrees(layer_bounds);
- RasterTilePriorityQueue raster_queue;
- host_impl_.BuildRasterQueue(&raster_queue, SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::ALL);
- EXPECT_FALSE(raster_queue.IsEmpty());
+ scoped_ptr<RasterTilePriorityQueue> raster_queue(host_impl_.BuildRasterQueue(
+ SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
+ EXPECT_FALSE(raster_queue->IsEmpty());
size_t tile_count = 0;
std::set<Tile*> all_tiles;
- while (!raster_queue.IsEmpty()) {
- EXPECT_TRUE(raster_queue.Top());
- all_tiles.insert(raster_queue.Top());
+ while (!raster_queue->IsEmpty()) {
+ EXPECT_TRUE(raster_queue->Top());
+ all_tiles.insert(raster_queue->Top());
++tile_count;
- raster_queue.Pop();
+ raster_queue->Pop();
}
EXPECT_EQ(tile_count, all_tiles.size());
EXPECT_EQ(16u, tile_count);
@@ -1059,7 +1042,6 @@ TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueueEmptyLayers) {
std::vector<Tile*> tiles(all_tiles.begin(), all_tiles.end());
host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
- EvictionTilePriorityQueue queue;
for (int i = 1; i < 10; ++i) {
scoped_ptr<FakePictureLayerImpl> pending_layer =
FakePictureLayerImpl::Create(host_impl_.pending_tree(), id_ + i);
@@ -1068,16 +1050,17 @@ TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueueEmptyLayers) {
pending_layer_->AddChild(pending_layer.Pass());
}
- host_impl_.BuildEvictionQueue(&queue, SAME_PRIORITY_FOR_BOTH_TREES);
- EXPECT_FALSE(queue.IsEmpty());
+ scoped_ptr<EvictionTilePriorityQueue> queue(
+ host_impl_.BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
+ EXPECT_FALSE(queue->IsEmpty());
tile_count = 0;
all_tiles.clear();
- while (!queue.IsEmpty()) {
- EXPECT_TRUE(queue.Top());
- all_tiles.insert(queue.Top());
+ while (!queue->IsEmpty()) {
+ EXPECT_TRUE(queue->Top());
+ all_tiles.insert(queue->Top());
++tile_count;
- queue.Pop();
+ queue->Pop();
}
EXPECT_EQ(tile_count, all_tiles.size());
EXPECT_EQ(16u, tile_count);
@@ -1121,7 +1104,7 @@ TEST_F(TileManagerTilePriorityQueueTest,
// 3. Third iteration ensures that no tiles are returned, since they were all
// marked as ready to draw.
for (int i = 0; i < 3; ++i) {
- scoped_ptr<TilingSetRasterQueue> queue(
+ scoped_ptr<TilingSetRasterQueueAll> queue(
new TilingSetRasterQueueAll(tiling_set.get(), false));
// There are 3 bins in TilePriority.
@@ -1231,7 +1214,7 @@ TEST_F(TileManagerTilePriorityQueueTest,
Tile* last_tile = NULL;
int eventually_bin_order_correct_count = 0;
int eventually_bin_order_incorrect_count = 0;
- scoped_ptr<TilingSetRasterQueue> queue(
+ scoped_ptr<TilingSetRasterQueueAll> queue(
new TilingSetRasterQueueAll(tiling_set.get(), false));
for (; !queue->IsEmpty(); queue->Pop()) {
if (!last_tile)
« no previous file with comments | « cc/resources/tile_manager_perftest.cc ('k') | cc/resources/tile_priority.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698