summaryrefslogtreecommitdiffstats
path: root/cc/resources
diff options
context:
space:
mode:
Diffstat (limited to 'cc/resources')
-rw-r--r--cc/resources/picture_layer_tiling.cc78
-rw-r--r--cc/resources/picture_layer_tiling.h16
-rw-r--r--cc/resources/picture_layer_tiling_perftest.cc10
-rw-r--r--cc/resources/picture_layer_tiling_set.h4
-rw-r--r--cc/resources/picture_layer_tiling_unittest.cc50
5 files changed, 120 insertions, 38 deletions
diff --git a/cc/resources/picture_layer_tiling.cc b/cc/resources/picture_layer_tiling.cc
index 79af4e9..1bbe513 100644
--- a/cc/resources/picture_layer_tiling.cc
+++ b/cc/resources/picture_layer_tiling.cc
@@ -845,17 +845,48 @@ void PictureLayerTiling::UpdateEvictionCacheIfNeeded(
eviction_cache_tree_priority_ == tree_priority)
return;
- eviction_tiles_cache_.clear();
- eviction_tiles_cache_.reserve(tiles_.size());
+ eventually_eviction_tiles_.clear();
+ soon_eviction_tiles_.clear();
+ now_required_for_activation_eviction_tiles_.clear();
+ now_not_required_for_activation_eviction_tiles_.clear();
+
for (TileMap::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
// TODO(vmpstr): This should update the priority if UpdateTilePriorities
// changes not to do this.
- eviction_tiles_cache_.push_back(it->second);
+ Tile* tile = it->second;
+ const TilePriority& priority =
+ tile->priority_for_tree_priority(tree_priority);
+ switch (priority.priority_bin) {
+ case TilePriority::EVENTUALLY:
+ eventually_eviction_tiles_.push_back(tile);
+ break;
+ case TilePriority::SOON:
+ soon_eviction_tiles_.push_back(tile);
+ break;
+ case TilePriority::NOW:
+ if (tile->required_for_activation())
+ now_required_for_activation_eviction_tiles_.push_back(tile);
+ else
+ now_not_required_for_activation_eviction_tiles_.push_back(tile);
+ break;
+ }
}
- std::sort(eviction_tiles_cache_.begin(),
- eviction_tiles_cache_.end(),
- TileEvictionOrder(tree_priority));
+ // TODO(vmpstr): Do this lazily. One option is to have a "sorted" flag that
+ // can be updated for each of the queues.
+ TileEvictionOrder sort_order(tree_priority);
+ std::sort(eventually_eviction_tiles_.begin(),
+ eventually_eviction_tiles_.end(),
+ sort_order);
+ std::sort(
+ soon_eviction_tiles_.begin(), soon_eviction_tiles_.end(), sort_order);
+ std::sort(now_required_for_activation_eviction_tiles_.begin(),
+ now_required_for_activation_eviction_tiles_.end(),
+ sort_order);
+ std::sort(now_not_required_for_activation_eviction_tiles_.begin(),
+ now_not_required_for_activation_eviction_tiles_.end(),
+ sort_order);
+
eviction_tiles_cache_valid_ = true;
eviction_cache_tree_priority_ = tree_priority;
}
@@ -985,16 +1016,37 @@ operator++() {
}
PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator()
- : tiling_(NULL) {
+ : tiling_(NULL), eviction_tiles_(NULL) {
}
PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator(
PictureLayerTiling* tiling,
- TreePriority tree_priority)
- : tiling_(tiling), tree_priority_(tree_priority) {
+ TreePriority tree_priority,
+ TilePriority::PriorityBin type,
+ bool required_for_activation)
+ : tiling_(tiling), tree_priority_(tree_priority), eviction_tiles_(NULL) {
+ if (required_for_activation && type != TilePriority::NOW)
+ return;
+
tiling_->UpdateEvictionCacheIfNeeded(tree_priority_);
- tile_iterator_ = tiling_->eviction_tiles_cache_.begin();
- if (tile_iterator_ != tiling_->eviction_tiles_cache_.end() &&
+ switch (type) {
+ case TilePriority::EVENTUALLY:
+ eviction_tiles_ = &tiling_->eventually_eviction_tiles_;
+ break;
+ case TilePriority::SOON:
+ eviction_tiles_ = &tiling_->soon_eviction_tiles_;
+ break;
+ case TilePriority::NOW:
+ if (required_for_activation)
+ eviction_tiles_ = &tiling_->now_required_for_activation_eviction_tiles_;
+ else
+ eviction_tiles_ =
+ &tiling_->now_not_required_for_activation_eviction_tiles_;
+ break;
+ }
+ DCHECK(eviction_tiles_);
+ tile_iterator_ = eviction_tiles_->begin();
+ if (tile_iterator_ != eviction_tiles_->end() &&
!(*tile_iterator_)->HasResources()) {
++(*this);
}
@@ -1003,7 +1055,7 @@ PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator(
PictureLayerTiling::TilingEvictionTileIterator::~TilingEvictionTileIterator() {}
PictureLayerTiling::TilingEvictionTileIterator::operator bool() const {
- return tiling_ && tile_iterator_ != tiling_->eviction_tiles_cache_.end();
+ return eviction_tiles_ && tile_iterator_ != eviction_tiles_->end();
}
Tile* PictureLayerTiling::TilingEvictionTileIterator::operator*() {
@@ -1022,7 +1074,7 @@ operator++() {
DCHECK(*this);
do {
++tile_iterator_;
- } while (tile_iterator_ != tiling_->eviction_tiles_cache_.end() &&
+ } while (tile_iterator_ != eviction_tiles_->end() &&
(!(*tile_iterator_)->HasResources()));
return *this;
diff --git a/cc/resources/picture_layer_tiling.h b/cc/resources/picture_layer_tiling.h
index 5aaadf1..7444d1e 100644
--- a/cc/resources/picture_layer_tiling.h
+++ b/cc/resources/picture_layer_tiling.h
@@ -108,24 +108,21 @@ class CC_EXPORT PictureLayerTiling {
public:
TilingEvictionTileIterator();
TilingEvictionTileIterator(PictureLayerTiling* tiling,
- TreePriority tree_priority);
+ TreePriority tree_priority,
+ TilePriority::PriorityBin type,
+ bool required_for_activation);
~TilingEvictionTileIterator();
operator bool() const;
const Tile* operator*() const;
Tile* operator*();
TilingEvictionTileIterator& operator++();
- TilePriority::PriorityBin get_type() {
- DCHECK(*this);
- const TilePriority& priority =
- (*tile_iterator_)->priority_for_tree_priority(tree_priority_);
- return priority.priority_bin;
- }
private:
PictureLayerTiling* tiling_;
TreePriority tree_priority_;
std::vector<Tile*>::iterator tile_iterator_;
+ std::vector<Tile*>* eviction_tiles_;
};
~PictureLayerTiling();
@@ -326,7 +323,10 @@ class CC_EXPORT PictureLayerTiling {
bool has_soon_border_rect_tiles_;
bool has_eventually_rect_tiles_;
- std::vector<Tile*> eviction_tiles_cache_;
+ std::vector<Tile*> eventually_eviction_tiles_;
+ std::vector<Tile*> soon_eviction_tiles_;
+ std::vector<Tile*> now_required_for_activation_eviction_tiles_;
+ std::vector<Tile*> now_not_required_for_activation_eviction_tiles_;
bool eviction_tiles_cache_valid_;
TreePriority eviction_cache_tree_priority_;
diff --git a/cc/resources/picture_layer_tiling_perftest.cc b/cc/resources/picture_layer_tiling_perftest.cc
index f0be5bf..d051897 100644
--- a/cc/resources/picture_layer_tiling_perftest.cc
+++ b/cc/resources/picture_layer_tiling_perftest.cc
@@ -202,7 +202,10 @@ class PictureLayerTilingPerfTest : public testing::Test {
int priority_count = 0;
do {
PictureLayerTiling::TilingEvictionTileIterator it(
- picture_layer_tiling_.get(), priorities[priority_count]);
+ picture_layer_tiling_.get(),
+ priorities[priority_count],
+ TilePriority::NOW,
+ false);
priority_count = (priority_count + 1) % arraysize(priorities);
timer_.NextLap();
} while (!timer_.HasTimeLimitExpired());
@@ -246,7 +249,10 @@ class PictureLayerTilingPerfTest : public testing::Test {
do {
int count = num_tiles;
PictureLayerTiling::TilingEvictionTileIterator it(
- picture_layer_tiling_.get(), priorities[priority_count]);
+ picture_layer_tiling_.get(),
+ priorities[priority_count],
+ TilePriority::EVENTUALLY,
+ false);
while (count--) {
ASSERT_TRUE(it) << "count: " << count;
ASSERT_TRUE(*it != NULL) << "count: " << count;
diff --git a/cc/resources/picture_layer_tiling_set.h b/cc/resources/picture_layer_tiling_set.h
index f19c1b8..5bdf0fb 100644
--- a/cc/resources/picture_layer_tiling_set.h
+++ b/cc/resources/picture_layer_tiling_set.h
@@ -30,6 +30,10 @@ class CC_EXPORT PictureLayerTilingSet {
struct TilingRange {
TilingRange(size_t start, size_t end) : start(start), end(end) {}
+ bool IsIndexWithinRange(size_t index) const {
+ return index >= start && index < end;
+ }
+
size_t start;
size_t end;
};
diff --git a/cc/resources/picture_layer_tiling_unittest.cc b/cc/resources/picture_layer_tiling_unittest.cc
index 9566489..5cd4b73 100644
--- a/cc/resources/picture_layer_tiling_unittest.cc
+++ b/cc/resources/picture_layer_tiling_unittest.cc
@@ -1042,7 +1042,7 @@ TEST(PictureLayerTilingTest, TilingEvictionTileIteratorStaticViewport) {
scoped_ptr<TestablePictureLayerTiling> tiling;
gfx::Rect viewport(50, 50, 100, 100);
- gfx::Size layer_bounds(200, 200);
+ gfx::Size layer_bounds(2000, 2000);
client.SetTileSize(gfx::Size(30, 30));
client.set_tree(ACTIVE_TREE);
@@ -1056,39 +1056,59 @@ TEST(PictureLayerTilingTest, TilingEvictionTileIteratorStaticViewport) {
std::vector<Tile*> all_tiles = tiling->AllTilesForTesting();
- PictureLayerTiling::TilingEvictionTileIterator it(tiling.get(),
- SMOOTHNESS_TAKES_PRIORITY);
+ PictureLayerTiling::TilingEvictionTileIterator it(
+ tiling.get(), SMOOTHNESS_TAKES_PRIORITY, TilePriority::NOW, false);
// Tiles don't have resources to evict.
EXPECT_FALSE(it);
// Sanity check.
- EXPECT_EQ(64u, all_tiles.size());
+ EXPECT_EQ(5184u, all_tiles.size());
client.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles);
std::set<Tile*> all_tiles_set(all_tiles.begin(), all_tiles.end());
+ std::set<Tile*> eviction_tiles;
+
it = PictureLayerTiling::TilingEvictionTileIterator(
- tiling.get(), SMOOTHNESS_TAKES_PRIORITY);
+ tiling.get(), SMOOTHNESS_TAKES_PRIORITY, TilePriority::EVENTUALLY, false);
EXPECT_TRUE(it);
+ for (; it; ++it) {
+ Tile* tile = *it;
+ EXPECT_TRUE(tile);
+ EXPECT_EQ(TilePriority::EVENTUALLY,
+ tile->priority(ACTIVE_TREE).priority_bin);
+ EXPECT_FALSE(tile->required_for_activation());
+ eviction_tiles.insert(tile);
+ }
- std::set<Tile*> eviction_tiles;
- Tile* last_tile = *it;
+ it = PictureLayerTiling::TilingEvictionTileIterator(
+ tiling.get(), SMOOTHNESS_TAKES_PRIORITY, TilePriority::SOON, false);
+ EXPECT_TRUE(it);
for (; it; ++it) {
Tile* tile = *it;
EXPECT_TRUE(tile);
- EXPECT_LE(tile->priority(ACTIVE_TREE).priority_bin,
- last_tile->priority(ACTIVE_TREE).priority_bin);
- if (tile->priority(ACTIVE_TREE).priority_bin ==
- last_tile->priority(ACTIVE_TREE).priority_bin) {
- EXPECT_LE(tile->priority(ACTIVE_TREE).distance_to_visible,
- last_tile->priority(ACTIVE_TREE).distance_to_visible);
- }
- last_tile = tile;
+ EXPECT_EQ(TilePriority::SOON, tile->priority(ACTIVE_TREE).priority_bin);
+ EXPECT_FALSE(tile->required_for_activation());
eviction_tiles.insert(tile);
}
+ it = PictureLayerTiling::TilingEvictionTileIterator(
+ tiling.get(), SMOOTHNESS_TAKES_PRIORITY, TilePriority::NOW, false);
+ EXPECT_TRUE(it);
+ for (; it; ++it) {
+ Tile* tile = *it;
+ EXPECT_TRUE(tile);
+ EXPECT_EQ(TilePriority::NOW, tile->priority(ACTIVE_TREE).priority_bin);
+ EXPECT_FALSE(tile->required_for_activation());
+ eviction_tiles.insert(tile);
+ }
+
+ it = PictureLayerTiling::TilingEvictionTileIterator(
+ tiling.get(), SMOOTHNESS_TAKES_PRIORITY, TilePriority::NOW, true);
+ EXPECT_FALSE(it);
+
EXPECT_GT(all_tiles_set.size(), 0u);
EXPECT_EQ(all_tiles_set, eviction_tiles);
}
generated by cgit v1.1 at 2025-03-24 22:24:05 +0000