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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: cc/resources/tile_manager_unittest.cc

Issue 1108773003: Revert of cc: Remove tile sharing from tilings. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 5 years, 8 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.cc ('k') | cc/resources/tiling_set_eviction_queue.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 2ac504a2d36d7e4141a8526e6b4e07b2a75e2201..310cdc67d6cd9857d68958a1280a689a9201006f 100644
--- a/cc/resources/tile_manager_unittest.cc
+++ b/cc/resources/tile_manager_unittest.cc
@@ -183,8 +183,9 @@
while (!queue->IsEmpty()) {
Tile* tile = queue->Top();
EXPECT_TRUE(tile);
- EXPECT_EQ(TilePriority::NOW, tile->priority().priority_bin);
- if (tile->priority().resolution == LOW_RESOLUTION)
+ EXPECT_EQ(TilePriority::NOW, tile->priority(ACTIVE_TREE).priority_bin);
+ EXPECT_EQ(TilePriority::NOW, tile->priority(PENDING_TREE).priority_bin);
+ if (tile->priority(ACTIVE_TREE).resolution == LOW_RESOLUTION)
had_low_res = true;
else
smoothness_tiles.insert(tile);
@@ -283,23 +284,28 @@
if (!last_tile)
last_tile = tile;
- EXPECT_LE(last_tile->priority().priority_bin,
- tile->priority().priority_bin);
+ EXPECT_LE(last_tile->priority(ACTIVE_TREE).priority_bin,
+ tile->priority(ACTIVE_TREE).priority_bin);
bool skip_updating_last_tile = false;
- if (last_tile->priority().priority_bin == tile->priority().priority_bin) {
- correct_order_tiles += last_tile->priority().distance_to_visible <=
- tile->priority().distance_to_visible;
- } else if (tile->priority().priority_bin == TilePriority::NOW) {
+ if (last_tile->priority(ACTIVE_TREE).priority_bin ==
+ tile->priority(ACTIVE_TREE).priority_bin) {
+ correct_order_tiles +=
+ last_tile->priority(ACTIVE_TREE).distance_to_visible <=
+ tile->priority(ACTIVE_TREE).distance_to_visible;
+ } else if (tile->priority(ACTIVE_TREE).priority_bin ==
+ TilePriority::EVENTUALLY &&
+ tile->priority(PENDING_TREE).priority_bin == TilePriority::NOW) {
// Since we'd return pending tree now tiles before the eventually tiles on
// the active tree, update the value.
++correct_order_tiles;
skip_updating_last_tile = true;
}
- if (tile->priority().priority_bin == TilePriority::NOW &&
- last_tile->priority().resolution != tile->priority().resolution) {
+ if (tile->priority(ACTIVE_TREE).priority_bin == TilePriority::NOW &&
+ last_tile->priority(ACTIVE_TREE).resolution !=
+ tile->priority(ACTIVE_TREE).resolution) {
// Low resolution should come first.
- EXPECT_EQ(LOW_RESOLUTION, last_tile->priority().resolution);
+ EXPECT_EQ(LOW_RESOLUTION, last_tile->priority(ACTIVE_TREE).resolution);
}
if (!skip_updating_last_tile)
@@ -362,17 +368,20 @@
if (!last_tile)
last_tile = tile;
- EXPECT_LE(last_tile->priority().priority_bin,
- tile->priority().priority_bin);
- if (last_tile->priority().priority_bin == tile->priority().priority_bin) {
- increasing_distance_tiles += last_tile->priority().distance_to_visible <=
- tile->priority().distance_to_visible;
- }
-
- if (tile->priority().priority_bin == TilePriority::NOW &&
- last_tile->priority().resolution != tile->priority().resolution) {
+ EXPECT_LE(last_tile->priority(PENDING_TREE).priority_bin,
+ tile->priority(PENDING_TREE).priority_bin);
+ if (last_tile->priority(PENDING_TREE).priority_bin ==
+ tile->priority(PENDING_TREE).priority_bin) {
+ increasing_distance_tiles +=
+ last_tile->priority(PENDING_TREE).distance_to_visible <=
+ tile->priority(PENDING_TREE).distance_to_visible;
+ }
+
+ if (tile->priority(PENDING_TREE).priority_bin == TilePriority::NOW &&
+ last_tile->priority(PENDING_TREE).resolution !=
+ tile->priority(PENDING_TREE).resolution) {
// High resolution should come first.
- EXPECT_EQ(HIGH_RESOLUTION, last_tile->priority().resolution);
+ EXPECT_EQ(HIGH_RESOLUTION, last_tile->priority(PENDING_TREE).resolution);
}
last_tile = tile;
@@ -426,8 +435,6 @@
pending_layer_->tilings()->AddTiling(1.5f, pending_layer_->raster_source());
active_layer_->tilings()->AddTiling(1.5f, active_layer_->raster_source());
- pending_layer_->tilings()->AddTiling(1.7f, pending_layer_->raster_source());
- active_layer_->tilings()->AddTiling(1.7f, active_layer_->raster_source());
pending_layer_->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
Occlusion(), true);
@@ -437,6 +444,7 @@
std::set<Tile*> all_expected_tiles;
for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
+ tiling->CreateAllTilesForTesting();
if (tiling->contents_scale() == 1.f) {
tiling->set_resolution(HIGH_RESOLUTION);
const auto& all_tiles = tiling->AllTilesForTesting();
@@ -448,21 +456,13 @@
for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
+ tiling->CreateAllTilesForTesting();
if (tiling->contents_scale() == 1.5f) {
tiling->set_resolution(HIGH_RESOLUTION);
const auto& all_tiles = tiling->AllTilesForTesting();
all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
} else {
tiling->set_resolution(NON_IDEAL_RESOLUTION);
- // Non ideal tilings with a high res pending twin have to be processed
- // because of possible activation tiles.
- if (tiling->contents_scale() == 1.f) {
- tiling->UpdateAllTilePrioritiesForTesting();
- const auto& all_tiles = tiling->AllTilesForTesting();
- for (auto* tile : all_tiles)
- EXPECT_TRUE(tile->required_for_activation());
- all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
- }
}
}
@@ -492,19 +492,19 @@
// Use a tile's content rect as an invalidation. We should inset it a bit to
// ensure that border math doesn't invalidate neighbouring tiles.
gfx::Rect invalidation =
- active_layer_->HighResTiling()->TileAt(1, 0)->content_rect();
+ pending_layer_->HighResTiling()->TileAt(1, 0)->content_rect();
invalidation.Inset(2, 2);
pending_layer_->set_invalidation(invalidation);
pending_layer_->HighResTiling()->Invalidate(invalidation);
- pending_layer_->HighResTiling()->CreateMissingTilesInLiveTilesRect();
pending_layer_->LowResTiling()->Invalidate(invalidation);
- pending_layer_->LowResTiling()->CreateMissingTilesInLiveTilesRect();
-
- // Sanity checks: Tile at 0, 0 not exist on the pending tree (it's not
- // invalidated). Tile 1, 0 should exist on both.
- EXPECT_FALSE(pending_layer_->HighResTiling()->TileAt(0, 0));
+
+ // Sanity checks: Tile at 0, 0 should be the same on both trees, tile at 1, 0
+ // should be different.
+ EXPECT_TRUE(pending_layer_->HighResTiling()->TileAt(0, 0));
EXPECT_TRUE(active_layer_->HighResTiling()->TileAt(0, 0));
+ EXPECT_EQ(pending_layer_->HighResTiling()->TileAt(0, 0),
+ active_layer_->HighResTiling()->TileAt(0, 0));
EXPECT_TRUE(pending_layer_->HighResTiling()->TileAt(1, 0));
EXPECT_TRUE(active_layer_->HighResTiling()->TileAt(1, 0));
EXPECT_NE(pending_layer_->HighResTiling()->TileAt(1, 0),
@@ -515,20 +515,13 @@
std::set<Tile*> expected_required_for_activation_tiles;
for (int i = 0; i <= 1; ++i) {
for (int j = 0; j <= 1; ++j) {
- bool have_pending_tile = false;
- if (pending_layer_->HighResTiling()->TileAt(i, j)) {
- expected_now_tiles.insert(
- pending_layer_->HighResTiling()->TileAt(i, j));
- expected_required_for_activation_tiles.insert(
- pending_layer_->HighResTiling()->TileAt(i, j));
- have_pending_tile = true;
- }
- Tile* active_tile = active_layer_->HighResTiling()->TileAt(i, j);
- EXPECT_TRUE(active_tile);
- expected_now_tiles.insert(active_tile);
- expected_required_for_draw_tiles.insert(active_tile);
- if (!have_pending_tile)
- expected_required_for_activation_tiles.insert(active_tile);
+ expected_now_tiles.insert(pending_layer_->HighResTiling()->TileAt(i, j));
+ expected_now_tiles.insert(active_layer_->HighResTiling()->TileAt(i, j));
+
+ expected_required_for_activation_tiles.insert(
+ pending_layer_->HighResTiling()->TileAt(i, j));
+ expected_required_for_draw_tiles.insert(
+ active_layer_->HighResTiling()->TileAt(i, j));
}
}
// Expect 3 shared tiles and 1 unshared tile in total.
@@ -542,10 +535,7 @@
std::set<Tile*> expected_all_tiles;
for (int i = 0; i <= 3; ++i) {
for (int j = 0; j <= 3; ++j) {
- if (pending_layer_->HighResTiling()->TileAt(i, j))
- expected_all_tiles.insert(
- pending_layer_->HighResTiling()->TileAt(i, j));
- EXPECT_TRUE(active_layer_->HighResTiling()->TileAt(i, j));
+ expected_all_tiles.insert(pending_layer_->HighResTiling()->TileAt(i, j));
expected_all_tiles.insert(active_layer_->HighResTiling()->TileAt(i, j));
}
}
@@ -561,7 +551,7 @@
while (!queue->IsEmpty()) {
Tile* tile = queue->Top();
queue->Pop();
- if (tile->priority().priority_bin == TilePriority::NOW)
+ if (tile->combined_priority().priority_bin == TilePriority::NOW)
actual_now_tiles.insert(tile);
actual_all_tiles.insert(tile);
}
@@ -630,7 +620,7 @@
std::vector<Tile*> all_tiles;
while (!queue->IsEmpty()) {
Tile* tile = queue->Top();
- if (tile->priority().priority_bin >= TilePriority::EVENTUALLY)
+ if (tile->combined_priority().priority_bin >= TilePriority::EVENTUALLY)
break;
all_tiles.push_back(tile);
@@ -679,7 +669,8 @@
while (!queue->IsEmpty()) {
Tile* tile = queue->Top();
EXPECT_TRUE(tile);
- EXPECT_EQ(TilePriority::NOW, tile->priority().priority_bin);
+ 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();
@@ -694,9 +685,7 @@
// Invalidate the pending tree.
pending_layer_->set_invalidation(invalidation);
pending_layer_->HighResTiling()->Invalidate(invalidation);
- pending_layer_->HighResTiling()->CreateMissingTilesInLiveTilesRect();
pending_layer_->LowResTiling()->Invalidate(invalidation);
- pending_layer_->LowResTiling()->CreateMissingTilesInLiveTilesRect();
active_layer_->ResetAllTilesPriorities();
pending_layer_->ResetAllTilesPriorities();
@@ -752,8 +741,8 @@
if (!last_tile)
last_tile = tile;
- const TilePriority& last_priority = last_tile->priority();
- const TilePriority& priority = tile->priority();
+ const TilePriority& last_priority = last_tile->combined_priority();
+ const TilePriority& priority = tile->combined_priority();
EXPECT_GE(last_priority.priority_bin, priority.priority_bin);
if (last_priority.priority_bin == priority.priority_bin) {
@@ -793,8 +782,8 @@
if (!last_tile)
last_tile = tile;
- const TilePriority& last_priority = last_tile->priority();
- const TilePriority& priority = tile->priority();
+ const TilePriority& last_priority = last_tile->combined_priority();
+ const TilePriority& priority = tile->combined_priority();
EXPECT_GE(last_priority.priority_bin, priority.priority_bin);
if (last_priority.priority_bin == priority.priority_bin) {
@@ -933,7 +922,7 @@
if (!last_tile)
last_tile = tile;
- bool tile_is_occluded = tile->is_occluded();
+ bool tile_is_occluded = tile->is_occluded_combined();
// The only way we will encounter an occluded tile after an unoccluded
// tile is if the priorty bin decreased, the tile is required for
@@ -941,12 +930,12 @@
if (tile_is_occluded) {
occluded_count++;
- bool last_tile_is_occluded = last_tile->is_occluded();
+ bool last_tile_is_occluded = last_tile->is_occluded_combined();
if (!last_tile_is_occluded) {
TilePriority::PriorityBin tile_priority_bin =
- tile->priority().priority_bin;
+ tile->priority_for_tree_priority(tree_priority).priority_bin;
TilePriority::PriorityBin last_tile_priority_bin =
- last_tile->priority().priority_bin;
+ last_tile->priority_for_tree_priority(tree_priority).priority_bin;
EXPECT_TRUE((tile_priority_bin < last_tile_priority_bin) ||
tile->required_for_activation() ||
@@ -1056,7 +1045,7 @@
host_impl_.BuildEvictionQueue(tree_priority));
while (!queue->IsEmpty()) {
Tile* tile = queue->Top();
- const TilePriority& pending_priority = tile->priority();
+ const TilePriority& pending_priority = tile->priority(PENDING_TREE);
EXPECT_NE(std::numeric_limits<float>::infinity(),
pending_priority.distance_to_visible);
if (all_pending_child_tiles.find(tile) != all_pending_child_tiles.end())
@@ -1219,7 +1208,7 @@
std::set<Tile*> unique_tiles;
unique_tiles.insert(queue->Top());
Tile* last_tile = queue->Top();
- have_tiles[last_tile->priority().priority_bin] = true;
+ have_tiles[last_tile->priority(ACTIVE_TREE).priority_bin] = true;
// On the second iteration, mark everything as ready to draw (solid color).
if (i == 1) {
@@ -1234,8 +1223,8 @@
queue->Pop();
unique_tiles.insert(new_tile);
- TilePriority last_priority = last_tile->priority();
- TilePriority new_priority = new_tile->priority();
+ TilePriority last_priority = last_tile->priority(ACTIVE_TREE);
+ TilePriority new_priority = new_tile->priority(ACTIVE_TREE);
EXPECT_LE(last_priority.priority_bin, new_priority.priority_bin);
if (last_priority.priority_bin == new_priority.priority_bin) {
if (last_priority.priority_bin == TilePriority::EVENTUALLY) {
@@ -1322,8 +1311,8 @@
Tile* new_tile = queue->Top();
- TilePriority last_priority = last_tile->priority();
- TilePriority new_priority = new_tile->priority();
+ TilePriority last_priority = last_tile->priority(ACTIVE_TREE);
+ TilePriority new_priority = new_tile->priority(ACTIVE_TREE);
have_tiles[new_priority.priority_bin] = true;
« no previous file with comments | « cc/resources/tile_manager.cc ('k') | cc/resources/tiling_set_eviction_queue.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698