return ToEnclosingRect(viewport_in_layer_space);
}
+static void UpdateAllTilePriorities(PictureLayerTilingSet* set,
+ WhichTree tree,
+ const gfx::Rect& visible_layer_rect,
+ float layer_contents_scale,
+ double current_frame_time_in_seconds) {
+ for (size_t i = 0; i < set->num_tilings(); ++i) {
+ set->tiling_at(i)->UpdateTilePriorities(tree,
+ visible_layer_rect,
+ layer_contents_scale,
+ current_frame_time_in_seconds,
+ NULL,
+ NULL,
+ gfx::Transform());
+ }
+}
+
class TestablePictureLayerTiling : public PictureLayerTiling {
public:
using PictureLayerTiling::SetLiveTilesRect;
float contents_scale,
const gfx::Size& layer_bounds) {
client_.SetTileSize(tile_size);
+ client_.set_tree(PENDING_TREE);
tiling_ = TestablePictureLayerTiling::Create(contents_scale,
layer_bounds,
&client_);
const gfx::Rect& dest_rect) {
float dest_to_contents_scale = tiling_->contents_scale() / rect_scale;
gfx::Rect clamped_rect = gfx::ScaleToEnclosingRect(
- tiling_->TilingRect(), 1.f / dest_to_contents_scale);
+ gfx::Rect(tiling_->tiling_size()), 1.f / dest_to_contents_scale);
clamped_rect.Intersect(dest_rect);
VerifyTilesExactlyCoverRect(rect_scale, dest_rect, clamped_rect);
}
};
TEST_F(PictureLayerTilingIteratorTest, ResizeDeletesTiles) {
- // Verifies that a resize deletes tiles that used to be on the edge.
+ // Verifies that a resize with invalidation for newly exposed pixels will
+ // deletes tiles that intersect that invalidation.
gfx::Size tile_size(100, 100);
gfx::Size original_layer_size(10, 10);
Initialize(tile_size, 1.f, original_layer_size);
// Stop creating tiles so that any invalidations are left as holes.
client_.set_allow_create_tile(false);
- tiling_->SetLayerBounds(gfx::Size(200, 200));
+ Region invalidation =
+ SubtractRegions(gfx::Rect(tile_size), gfx::Rect(original_layer_size));
+ tiling_->UpdateTilesToCurrentPile(invalidation, gfx::Size(200, 200));
EXPECT_FALSE(tiling_->TileAt(0, 0));
}
+TEST_F(PictureLayerTilingIteratorTest, ResizeOverBorderPixelsDeletesTiles) {
+ // Verifies that a resize with invalidation for newly exposed pixels will
+ // deletes tiles that intersect that invalidation.
+ gfx::Size tile_size(100, 100);
+ gfx::Size original_layer_size(99, 99);
+ Initialize(tile_size, 1.f, original_layer_size);
+ SetLiveRectAndVerifyTiles(gfx::Rect(original_layer_size));
+
+ // Tiling only has one tile, since its total size is less than one.
+ EXPECT_TRUE(tiling_->TileAt(0, 0));
+
+ // Stop creating tiles so that any invalidations are left as holes.
+ client_.set_allow_create_tile(false);
+
+ Region invalidation =
+ SubtractRegions(gfx::Rect(tile_size), gfx::Rect(original_layer_size));
+ tiling_->UpdateTilesToCurrentPile(invalidation, gfx::Size(200, 200));
+ EXPECT_FALSE(tiling_->TileAt(0, 0));
+
+ // The original tile was the same size after resize, but it would include new
+ // border pixels.
+ EXPECT_EQ(gfx::Rect(original_layer_size),
+ tiling_->TilingDataForTesting().TileBounds(0, 0));
+}
+
TEST_F(PictureLayerTilingIteratorTest, LiveTilesExactlyCoverLiveTileRect) {
Initialize(gfx::Size(100, 100), 1, gfx::Size(1099, 801));
SetLiveRectAndVerifyTiles(gfx::Rect(100, 100));
TEST(PictureLayerTilingTest, SkewportLimits) {
FakePictureLayerTilingClient client;
client.set_skewport_extrapolation_limit_in_content_pixels(75);
+ client.set_tree(ACTIVE_TREE);
scoped_ptr<TestablePictureLayerTiling> tiling;
gfx::Rect viewport(0, 0, 100, 100);
client.SetTileSize(gfx::Size(100, 100));
tiling = TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client);
- tiling->UpdateTilePriorities(ACTIVE_TREE, viewport, 1.f, 1.0);
+ tiling->UpdateTilePriorities(
+ ACTIVE_TREE, viewport, 1.f, 1.0, NULL, NULL, gfx::Transform());
// Move viewport down 50 pixels in 0.5 seconds.
gfx::Rect down_skewport =
gfx::Size layer_bounds(200, 200);
client.SetTileSize(gfx::Size(100, 100));
+ client.set_tree(ACTIVE_TREE);
tiling = TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client);
- tiling->UpdateTilePriorities(ACTIVE_TREE, viewport, 1.f, 1.0);
+ tiling->UpdateTilePriorities(
+ ACTIVE_TREE, viewport, 1.f, 1.0, NULL, NULL, gfx::Transform());
// Move viewport down 50 pixels in 0.5 seconds.
gfx::Rect down_skewport =
gfx::Size layer_bounds(1500, 1500);
client.SetTileSize(gfx::Size(10, 10));
+ client.set_tree(ACTIVE_TREE);
// Tiling at 0.25 scale: this should create 47x47 tiles of size 10x10.
// The reason is that each tile has a one pixel border, so tile at (1, 2)
gfx::Rect viewport_in_content_space =
gfx::ToEnclosedRect(gfx::ScaleRect(viewport, 0.25f));
- tiling->UpdateTilePriorities(ACTIVE_TREE, viewport, 1.f, 1.0);
+ tiling->UpdateTilePriorities(
+ ACTIVE_TREE, viewport, 1.f, 1.0, NULL, NULL, gfx::Transform());
gfx::Rect soon_rect = viewport;
soon_rect.Inset(-312.f, -312.f, -312.f, -312.f);
EXPECT_EQ(25, skewport.width());
EXPECT_EQ(35, skewport.height());
- tiling->UpdateTilePriorities(ACTIVE_TREE, viewport, 1.f, 2.0);
+ tiling->UpdateTilePriorities(
+ ACTIVE_TREE, viewport, 1.f, 2.0, NULL, NULL, gfx::Transform());
have_now = false;
have_eventually = false;
EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
// Change the underlying layer scale.
- tiling->UpdateTilePriorities(ACTIVE_TREE, viewport, 2.0f, 3.0);
+ tiling->UpdateTilePriorities(
+ ACTIVE_TREE, viewport, 2.0f, 3.0, NULL, NULL, gfx::Transform());
priority = tiling->TileAt(5, 1)->priority(ACTIVE_TREE);
EXPECT_FLOAT_EQ(34.f, priority.distance_to_visible);
soon_rect.Inset(-312.f, -312.f, -312.f, -312.f);
client.SetTileSize(gfx::Size(30, 30));
+ client.set_tree(ACTIVE_TREE);
tiling = TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client);
- tiling->UpdateTilePriorities(ACTIVE_TREE, viewport, 1.0f, 1.0);
+ tiling->UpdateTilePriorities(
+ ACTIVE_TREE, viewport, 1.0f, 1.0, NULL, NULL, gfx::Transform());
PictureLayerTiling::TilingRasterTileIterator empty_iterator;
EXPECT_FALSE(empty_iterator);
gfx::Size layer_bounds(1000, 1000);
client.SetTileSize(gfx::Size(30, 30));
+ client.set_tree(ACTIVE_TREE);
tiling = TestablePictureLayerTiling::Create(1.f, layer_bounds, &client);
- tiling->UpdateTilePriorities(ACTIVE_TREE, viewport, 1.0f, 1.0);
- tiling->UpdateTilePriorities(ACTIVE_TREE, moved_viewport, 1.0f, 2.0);
+ tiling->UpdateTilePriorities(
+ ACTIVE_TREE, viewport, 1.0f, 1.0, NULL, NULL, gfx::Transform());
+ tiling->UpdateTilePriorities(
+ ACTIVE_TREE, moved_viewport, 1.0f, 2.0, NULL, NULL, gfx::Transform());
gfx::Rect soon_rect = moved_viewport;
soon_rect.Inset(-312.f, -312.f, -312.f, -312.f);
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);
tiling = TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client);
- tiling->UpdateTilePriorities(ACTIVE_TREE, viewport, 1.0f, 1.0);
+ tiling->UpdateTilePriorities(
+ ACTIVE_TREE, viewport, 1.0f, 1.0, NULL, NULL, gfx::Transform());
PictureLayerTiling::TilingRasterTileIterator empty_iterator;
EXPECT_FALSE(empty_iterator);
std::vector<Tile*> all_tiles = tiling->AllTilesForTesting();
- PictureLayerTiling::TilingEvictionTileIterator it(tiling.get(),
- SMOOTHNESS_TAKES_PRIORITY);
+ PictureLayerTiling::TilingEvictionTileIterator it(
+ tiling.get(), SMOOTHNESS_TAKES_PRIORITY, PictureLayerTiling::NOW);
// 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, PictureLayerTiling::EVENTUALLY);
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, PictureLayerTiling::SOON);
+ 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, PictureLayerTiling::NOW);
+ 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,
+ PictureLayerTiling::NOW_AND_REQUIRED_FOR_ACTIVATION);
+ EXPECT_FALSE(it);
+
EXPECT_GT(all_tiles_set.size(), 0u);
EXPECT_EQ(all_tiles_set, eviction_tiles);
}
VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
+ client_.set_tree(ACTIVE_TREE);
tiling_->UpdateTilePriorities(
ACTIVE_TREE,
gfx::Rect(layer_bounds), // visible content rect
1.f, // current contents scale
- 1.0); // current frame time
+ 1.0, // current frame time
+ NULL, // occlusion tracker
+ NULL, // render target
+ gfx::Transform()); // draw transform
VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
// Make the viewport rect empty. All tiles are killed and become zombies.
tiling_->UpdateTilePriorities(ACTIVE_TREE,
- gfx::Rect(), // visible content rect
- 1.f, // current contents scale
- 2.0); // current frame time
+ gfx::Rect(), // visible content rect
+ 1.f, // current contents scale
+ 2.0, // current frame time
+ NULL, // occlusion tracker
+ NULL, // render target
+ gfx::Transform()); // draw transform
VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
}
gfx::Rect giant_rect(-10000000, -10000000, 1000000000, 1000000000);
+ client_.set_tree(ACTIVE_TREE);
tiling_->UpdateTilePriorities(
ACTIVE_TREE,
gfx::Rect(layer_bounds), // visible content rect
1.f, // current contents scale
- 1.0); // current frame time
+ 1.0, // current frame time
+ NULL, // occlusion tracker
+ NULL, // render target
+ gfx::Transform()); // draw transform
VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
// If the visible content rect is empty, it should still have live tiles.
tiling_->UpdateTilePriorities(ACTIVE_TREE,
- giant_rect, // visible content rect
- 1.f, // current contents scale
- 2.0); // current frame time
+ giant_rect, // visible content rect
+ 1.f, // current contents scale
+ 2.0, // current frame time
+ NULL, // occlusion tracker
+ NULL, // render target
+ gfx::Transform()); // draw transform
VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
}
gfx::Rect viewport_rect(1100, 0, 1000, 1000);
EXPECT_FALSE(viewport_rect.Intersects(gfx::Rect(layer_bounds)));
+ client_.set_tree(ACTIVE_TREE);
tiling_->UpdateTilePriorities(ACTIVE_TREE,
- viewport_rect, // visible content rect
- 1.f, // current contents scale
- 1.0); // current frame time
+ viewport_rect, // visible content rect
+ 1.f, // current contents scale
+ 1.0, // current frame time
+ NULL, // occlusion tracker
+ NULL, // render target
+ gfx::Transform()); // draw transform
VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
}
gfx::Rect visible_rect(8000, 8000, 50, 50);
+ client_.set_tree(ACTIVE_TREE);
set_max_tiles_for_interest_area(1);
tiling_->UpdateTilePriorities(ACTIVE_TREE,
- visible_rect, // visible content rect
- 1.f, // current contents scale
- 1.0); // current frame time
+ visible_rect, // visible content rect
+ 1.f, // current contents scale
+ 1.0, // current frame time
+ NULL, // occlusion tracker
+ NULL, // render target
+ gfx::Transform()); // draw transform
VerifyTiles(1.f,
gfx::Rect(layer_bounds),
base::Bind(&TilesIntersectingRectExist, visible_rect, true));
VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
+ client_.set_tree(ACTIVE_TREE);
set_max_tiles_for_interest_area(1);
tiling_->UpdateTilePriorities(
ACTIVE_TREE,
gfx::Rect(layer_bounds), // visible content rect
1.f, // current contents scale
- 1.0); // current frame time
+ 1.0, // current frame time
+ NULL, // occlusion tracker
+ NULL, // render target
+ gfx::Transform()); // draw transform
int num_tiles = 0;
VerifyTiles(1.f,
gfx::Size tile_size(100, 100);
client_.SetTileSize(tile_size);
+ client_.set_tree(PENDING_TREE);
PictureLayerTilingSet active_set(&client_, layer_bounds);
gfx::Rect(layer_bounds),
base::Bind(&TileExists, false));
- active_set.UpdateTilePriorities(
- PENDING_TREE,
- gfx::Rect(layer_bounds), // visible content rect
- 1.f, // current contents scale
- 1.0); // current frame time
+ UpdateAllTilePriorities(&active_set,
+ PENDING_TREE,
+ gfx::Rect(layer_bounds), // visible content rect
+ 1.f, // current contents scale
+ 1.0); // current frame time
// The active tiling has tiles now.
VerifyTiles(active_set.tiling_at(0),
// UpdateTilePriorities on the pending tiling at the same frame time. The
// pending tiling should get tiles.
- pending_set.UpdateTilePriorities(
- PENDING_TREE,
- gfx::Rect(layer_bounds), // visible content rect
- 1.f, // current contents scale
- 1.0); // current frame time
+ UpdateAllTilePriorities(&pending_set,
+ PENDING_TREE,
+ gfx::Rect(layer_bounds), // visible content rect
+ 1.f, // current contents scale
+ 1.0); // current frame time
VerifyTiles(pending_set.tiling_at(0),
1.f,
current_screen_transform, device_viewport);
client.SetTileSize(gfx::Size(100, 100));
+ client.set_tree(ACTIVE_TREE);
tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale
current_layer_bounds,
&client);
tiling->UpdateTilePriorities(ACTIVE_TREE,
viewport_in_layer_space,
current_layer_contents_scale,
- current_frame_time_in_seconds);
+ current_frame_time_in_seconds,
+ NULL, // occlusion tracker
+ NULL, // render target
+ gfx::Transform()); // draw transform
ASSERT_TRUE(tiling->TileAt(0, 0));
ASSERT_TRUE(tiling->TileAt(0, 1));
current_screen_transform, device_viewport);
client.SetTileSize(gfx::Size(100, 100));
+ client.set_tree(ACTIVE_TREE);
tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale
current_layer_bounds,
&client);
tiling->UpdateTilePriorities(ACTIVE_TREE,
viewport_in_layer_space,
current_layer_contents_scale,
- current_frame_time_in_seconds);
+ current_frame_time_in_seconds,
+ NULL, // occlusion tracker
+ NULL, // render target
+ gfx::Transform()); // draw transform
ASSERT_TRUE(tiling->TileAt(0, 0));
ASSERT_TRUE(tiling->TileAt(0, 1));
current_screen_transform, device_viewport);
client.SetTileSize(gfx::Size(100, 100));
+ client.set_tree(ACTIVE_TREE);
tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale
current_layer_bounds,
&client);
tiling->UpdateTilePriorities(ACTIVE_TREE,
viewport_in_layer_space,
current_layer_contents_scale,
- current_frame_time_in_seconds);
+ current_frame_time_in_seconds,
+ NULL, // occlusion tracker
+ NULL, // render target
+ gfx::Transform()); // draw transform
ASSERT_TRUE(tiling->TileAt(0, 0));
ASSERT_TRUE(tiling->TileAt(0, 1));
current_screen_transform, device_viewport);
client.SetTileSize(gfx::Size(100, 100));
+ client.set_tree(ACTIVE_TREE);
tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale
current_layer_bounds,
&client);
tiling->UpdateTilePriorities(ACTIVE_TREE,
viewport_in_layer_space,
current_layer_contents_scale,
- current_frame_time_in_seconds);
+ current_frame_time_in_seconds,
+ NULL, // occlusion tracker
+ NULL, // render target
+ gfx::Transform()); // draw transform
ASSERT_TRUE(tiling->TileAt(0, 0));
ASSERT_TRUE(tiling->TileAt(0, 1));
current_screen_transform, device_viewport);
client.SetTileSize(gfx::Size(100, 100));
+ client.set_tree(ACTIVE_TREE);
tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale
current_layer_bounds,
&client);
tiling->UpdateTilePriorities(ACTIVE_TREE,
viewport_in_layer_space,
current_layer_contents_scale,
- current_frame_time_in_seconds);
+ current_frame_time_in_seconds,
+ NULL, // occlusion tracker
+ NULL, // render target
+ gfx::Transform()); // draw transform
ASSERT_TRUE(tiling->TileAt(0, 0));
ASSERT_TRUE(tiling->TileAt(0, 1));
current_screen_transform, device_viewport);
client.SetTileSize(gfx::Size(100, 100));
+ client.set_tree(ACTIVE_TREE);
tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale
current_layer_bounds,
&client);
tiling->UpdateTilePriorities(ACTIVE_TREE,
viewport_in_layer_space,
current_layer_contents_scale,
- current_frame_time_in_seconds);
+ current_frame_time_in_seconds,
+ NULL, // occlusion tracker
+ NULL, // render target
+ gfx::Transform()); // draw transform
ASSERT_TRUE(tiling->TileAt(0, 0));
ASSERT_TRUE(tiling->TileAt(0, 1));
current_screen_transform, device_viewport);
client.SetTileSize(gfx::Size(100, 100));
+ client.set_tree(ACTIVE_TREE);
tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale
current_layer_bounds,
&client);
tiling->UpdateTilePriorities(ACTIVE_TREE,
viewport_in_layer_space,
last_layer_contents_scale,
- last_frame_time_in_seconds);
+ last_frame_time_in_seconds,
+ NULL, // occlusion tracker
+ NULL, // render target
+ gfx::Transform()); // draw transform
// current frame
tiling->UpdateTilePriorities(ACTIVE_TREE,
viewport_in_layer_space,
current_layer_contents_scale,
- current_frame_time_in_seconds);
+ current_frame_time_in_seconds,
+ NULL, // occlusion tracker
+ NULL, // render target
+ gfx::Transform()); // draw transform
ASSERT_TRUE(tiling->TileAt(0, 0));
ASSERT_TRUE(tiling->TileAt(0, 1));
current_screen_transform, device_viewport);
client.SetTileSize(gfx::Size(100, 100));
+ client.set_tree(ACTIVE_TREE);
tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale
current_layer_bounds,
&client);
tiling->UpdateTilePriorities(ACTIVE_TREE,
viewport_in_layer_space,
last_layer_contents_scale,
- last_frame_time_in_seconds);
+ last_frame_time_in_seconds,
+ NULL, // occlusion tracker
+ NULL, // render target
+ gfx::Transform()); // draw transform
// current frame
tiling->UpdateTilePriorities(ACTIVE_TREE,
viewport_in_layer_space,
current_layer_contents_scale,
- current_frame_time_in_seconds);
+ current_frame_time_in_seconds,
+ NULL, // occlusion tracker
+ NULL, // render target
+ gfx::Transform()); // draw transform
ASSERT_TRUE(tiling->TileAt(0, 0));
ASSERT_TRUE(tiling->TileAt(0, 1));
EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
}
+TEST(PictureLayerTilingTest, ResetClearsPriorities) {
+ FakePictureLayerTilingClient client;
+ scoped_ptr<TestablePictureLayerTiling> tiling;
+
+ client.SetTileSize(gfx::Size(100, 100));
+ client.set_tree(ACTIVE_TREE);
+ tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale
+ gfx::Size(100, 100),
+ &client);
+ tiling->UpdateTilePriorities(ACTIVE_TREE,
+ gfx::Rect(0, 0, 100, 100),
+ 1.0f,
+ 1.0f,
+ NULL, // occlusion tracker
+ NULL, // render target
+ gfx::Transform()); // draw transform
+
+ std::vector<scoped_refptr<Tile> > tiles = tiling->AllRefTilesForTesting();
+ ASSERT_GT(tiles.size(), 0u);
+ for (std::vector<scoped_refptr<Tile> >::const_iterator it = tiles.begin();
+ it != tiles.end();
+ ++it) {
+ EXPECT_NE(TilePriority(), (*it)->priority(ACTIVE_TREE));
+ }
+
+ tiling->Reset();
+ for (std::vector<scoped_refptr<Tile> >::const_iterator it = tiles.begin();
+ it != tiles.end();
+ ++it) {
+ EXPECT_EQ(TilePriority(), (*it)->priority(ACTIVE_TREE));
+ }
+ tiles.clear();
+}
+
} // namespace
} // namespace cc
projects / platform / framework / web / crosswalk.git / blobdiff