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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: cc/resources/picture_layer_tiling_unittest.cc

Issue 140513006: cc: Simplify picture layer tiling update tile priorities. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 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
« cc/resources/picture_layer_tiling.cc ('K') | « cc/resources/picture_layer_tiling_set.cc ('k') | cc/resources/prioritized_tile_set.cc » ('j') | cc/resources/prioritized_tile_set.cc » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: cc/resources/picture_layer_tiling_unittest.cc
diff --git a/cc/resources/picture_layer_tiling_unittest.cc b/cc/resources/picture_layer_tiling_unittest.cc
index 83dc4aa09bd61ae7f3f218d2832d93c80e69a26a..7c6eb8b4b023c98d417896e8dc0ba0228c3c7bc1 100644
--- a/cc/resources/picture_layer_tiling_unittest.cc
+++ b/cc/resources/picture_layer_tiling_unittest.cc
@@ -26,7 +26,6 @@ static gfx::Rect ViewportInLayerSpace(
gfx::RectF viewport_in_layer_space = MathUtil::ProjectClippedRect(
inverse, gfx::RectF(gfx::Point(0, 0), device_viewport));
-
return ToEnclosingRect(viewport_in_layer_space);
}
@@ -495,15 +494,9 @@ TEST_F(PictureLayerTilingIteratorTest, TilesExist) {
tiling_->UpdateTilePriorities(
ACTIVE_TREE,
- layer_bounds, // device viewport
gfx::Rect(layer_bounds), // viewport in layer space
gfx::Rect(layer_bounds), // visible content rect
- layer_bounds, // last layer bounds
- layer_bounds, // current layer bounds
- 1.f, // last contents scale
1.f, // current contents scale
- gfx::Transform(), // last screen transform
- gfx::Transform(), // current screen transform
1.0, // current frame time
10000); // max tiles in tile manager
VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
@@ -511,15 +504,9 @@ TEST_F(PictureLayerTilingIteratorTest, TilesExist) {
// Make the viewport rect empty. All tiles are killed and become zombies.
tiling_->UpdateTilePriorities(
ACTIVE_TREE,
- layer_bounds, // device viewport
gfx::Rect(), // viewport in layer space
gfx::Rect(), // visible content rect
- layer_bounds, // last layer bounds
- layer_bounds, // current layer bounds
- 1.f, // last contents scale
1.f, // current contents scale
- gfx::Transform(), // last screen transform
- gfx::Transform(), // current screen transform
2.0, // current frame time
10000); // max tiles in tile manager
VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
@@ -535,15 +522,9 @@ TEST_F(PictureLayerTilingIteratorTest, TilesExistGiantViewport) {
tiling_->UpdateTilePriorities(
ACTIVE_TREE,
- layer_bounds, // device viewport
giant_rect, // viewport in layer space
gfx::Rect(layer_bounds), // visible content rect
- layer_bounds, // last layer bounds
- layer_bounds, // current layer bounds
- 1.f, // last contents scale
1.f, // current contents scale
- gfx::Transform(), // last screen transform
- gfx::Transform(), // current screen transform
1.0, // current frame time
10000); // max tiles in tile manager
VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
@@ -551,15 +532,9 @@ TEST_F(PictureLayerTilingIteratorTest, TilesExistGiantViewport) {
// If the visible content rect is empty, it should still have live tiles.
tiling_->UpdateTilePriorities(
ACTIVE_TREE,
- layer_bounds, // device viewport
giant_rect, // viewport in layer space
gfx::Rect(), // visible content rect
- layer_bounds, // last layer bounds
- layer_bounds, // current layer bounds
- 1.f, // last contents scale
1.f, // current contents scale
- gfx::Transform(), // last screen transform
- gfx::Transform(), // current screen transform
2.0, // current frame time
10000); // max tiles in tile manager
VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
@@ -578,15 +553,9 @@ TEST_F(PictureLayerTilingIteratorTest, TilesExistOutsideViewport) {
tiling_->UpdateTilePriorities(
ACTIVE_TREE,
- layer_bounds, // device viewport
viewport_rect, // viewport in layer space
gfx::Rect(), // visible content rect
- layer_bounds, // last layer bounds
- layer_bounds, // current layer bounds
- 1.f, // last contents scale
1.f, // current contents scale
- gfx::Transform(), // last screen transform
- gfx::Transform(), // current screen transform
1.0, // current frame time
10000); // max tiles in tile manager
VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
@@ -614,15 +583,9 @@ TEST_F(PictureLayerTilingIteratorTest,
tiling_->UpdateTilePriorities(
ACTIVE_TREE,
- layer_bounds, // device viewport
gfx::Rect(layer_bounds), // viewport in layer space
visible_rect, // visible content rect
- layer_bounds, // last layer bounds
- layer_bounds, // current layer bounds
- 1.f, // last contents scale
1.f, // current contents scale
- gfx::Transform(), // last screen transform
- gfx::Transform(), // current screen transform
1.0, // current frame time
1); // max tiles in tile manager
VerifyTiles(1.f,
@@ -646,15 +609,9 @@ TEST_F(PictureLayerTilingIteratorTest,
tiling_->UpdateTilePriorities(
ACTIVE_TREE,
- layer_bounds, // device viewport
gfx::Rect(layer_bounds), // viewport in layer space
gfx::Rect(layer_bounds), // visible content rect
- layer_bounds, // last layer bounds
- layer_bounds, // current layer bounds
- 1.f, // last contents scale
1.f, // current contents scale
- gfx::Transform(), // last screen transform
- gfx::Transform(), // current screen transform
1.0, // current frame time
1); // max tiles in tile manager
@@ -685,15 +642,9 @@ TEST_F(PictureLayerTilingIteratorTest, AddTilingsToMatchScale) {
active_set.UpdateTilePriorities(
PENDING_TREE,
- layer_bounds, // device viewport
gfx::Rect(layer_bounds), // viewport in layer space
gfx::Rect(layer_bounds), // visible content rect
- layer_bounds, // last layer bounds
- layer_bounds, // current layer bounds
- 1.f, // last contents scale
1.f, // current contents scale
- gfx::Transform(), // last screen transform
- gfx::Transform(), // current screen transform
1.0, // current frame time
10000); // max tiles in tile manager
@@ -718,15 +669,9 @@ TEST_F(PictureLayerTilingIteratorTest, AddTilingsToMatchScale) {
// pending tiling should get tiles.
pending_set.UpdateTilePriorities(
PENDING_TREE,
- layer_bounds, // device viewport
gfx::Rect(layer_bounds), // viewport in layer space
gfx::Rect(layer_bounds), // visible content rect
- layer_bounds, // last layer bounds
- layer_bounds, // current layer bounds
- 1.f, // last contents scale
1.f, // current contents scale
- gfx::Transform(), // last screen transform
- gfx::Transform(), // current screen transform
1.0, // current frame time
10000); // max tiles in tile manager
@@ -747,7 +692,6 @@ TEST(UpdateTilePrioritiesTest, VisibleTiles) {
gfx::Rect visible_layer_rect(0, 0, 200, 200);
gfx::Size last_layer_bounds(200, 200);
gfx::Size current_layer_bounds(200, 200);
- float last_layer_contents_scale = 1.f;
float current_layer_contents_scale = 1.f;
gfx::Transform last_screen_transform;
gfx::Transform current_screen_transform;
@@ -764,15 +708,9 @@ TEST(UpdateTilePrioritiesTest, VisibleTiles) {
tiling->UpdateTilePriorities(
ACTIVE_TREE,
- device_viewport,
viewport_in_layer_space,
visible_layer_rect,
- last_layer_bounds,
- current_layer_bounds,
- last_layer_contents_scale,
current_layer_contents_scale,
- last_screen_transform,
- current_screen_transform,
current_frame_time_in_seconds,
max_tiles_for_interest_area);
@@ -782,20 +720,20 @@ TEST(UpdateTilePrioritiesTest, VisibleTiles) {
ASSERT_TRUE(tiling->TileAt(1, 1));
TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
- EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
- EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
+ EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+ EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
- EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
- EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
+ EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+ EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
- EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
- EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
+ EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+ EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
- EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
- EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
+ EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+ EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
}
TEST(UpdateTilePrioritiesTest, OffscreenTiles) {
@@ -809,7 +747,6 @@ TEST(UpdateTilePrioritiesTest, OffscreenTiles) {
gfx::Rect visible_layer_rect(0, 0, 0, 0); // offscreen; nothing is visible.
gfx::Size last_layer_bounds(200, 200);
gfx::Size current_layer_bounds(200, 200);
- float last_layer_contents_scale = 1.f;
float current_layer_contents_scale = 1.f;
gfx::Transform last_screen_transform;
gfx::Transform current_screen_transform;
@@ -829,15 +766,9 @@ TEST(UpdateTilePrioritiesTest, OffscreenTiles) {
tiling->UpdateTilePriorities(
ACTIVE_TREE,
- device_viewport,
viewport_in_layer_space,
visible_layer_rect,
- last_layer_bounds,
- current_layer_bounds,
- last_layer_contents_scale,
current_layer_contents_scale,
- last_screen_transform,
- current_screen_transform,
current_frame_time_in_seconds,
max_tiles_for_interest_area);
@@ -847,36 +778,32 @@ TEST(UpdateTilePrioritiesTest, OffscreenTiles) {
ASSERT_TRUE(tiling->TileAt(1, 1));
TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
- priority.time_to_visible_in_seconds);
+ EXPECT_GT(priority.distance_to_visible, 0.f);
+ EXPECT_NE(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
- priority.time_to_visible_in_seconds);
+ EXPECT_GT(priority.distance_to_visible, 0.f);
+ EXPECT_NE(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
- priority.time_to_visible_in_seconds);
+ EXPECT_GT(priority.distance_to_visible, 0.f);
+ EXPECT_NE(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
- priority.time_to_visible_in_seconds);
+ EXPECT_GT(priority.distance_to_visible, 0.f);
+ EXPECT_NE(TilePriority::NOW, priority.priority_bin);
// Furthermore, in this scenario tiles on the right hand side should have a
// larger distance to visible.
TilePriority left = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
TilePriority right = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
- EXPECT_GT(right.distance_to_visible_in_pixels,
- left.distance_to_visible_in_pixels);
+ EXPECT_GT(right.distance_to_visible,
+ left.distance_to_visible);
left = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
right = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
- EXPECT_GT(right.distance_to_visible_in_pixels,
- left.distance_to_visible_in_pixels);
+ EXPECT_GT(right.distance_to_visible,
+ left.distance_to_visible);
}
TEST(UpdateTilePrioritiesTest, PartiallyOffscreenLayer) {
@@ -887,10 +814,8 @@ TEST(UpdateTilePrioritiesTest, PartiallyOffscreenLayer) {
scoped_ptr<TestablePictureLayerTiling> tiling;
gfx::Size device_viewport(800, 600);
- gfx::Rect visible_layer_rect(0, 0, 100, 100); // only top quarter.
gfx::Size last_layer_bounds(200, 200);
gfx::Size current_layer_bounds(200, 200);
- float last_layer_contents_scale = 1.f;
float current_layer_contents_scale = 1.f;
gfx::Transform last_screen_transform;
gfx::Transform current_screen_transform;
@@ -902,6 +827,9 @@ TEST(UpdateTilePrioritiesTest, PartiallyOffscreenLayer) {
gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
current_screen_transform, device_viewport);
+ gfx::Rect visible_layer_rect = viewport_in_layer_space;
+ visible_layer_rect.Intersect(
+ gfx::Rect(gfx::Point(0, 0), current_layer_bounds));
client.SetTileSize(gfx::Size(100, 100));
tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale
@@ -910,15 +838,9 @@ TEST(UpdateTilePrioritiesTest, PartiallyOffscreenLayer) {
tiling->UpdateTilePriorities(
ACTIVE_TREE,
- device_viewport,
viewport_in_layer_space,
visible_layer_rect,
- last_layer_bounds,
- current_layer_bounds,
- last_layer_contents_scale,
current_layer_contents_scale,
- last_screen_transform,
- current_screen_transform,
current_frame_time_in_seconds,
max_tiles_for_interest_area);
@@ -928,23 +850,20 @@ TEST(UpdateTilePrioritiesTest, PartiallyOffscreenLayer) {
ASSERT_TRUE(tiling->TileAt(1, 1));
TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
- EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
- EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
+ EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+ EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
- priority.time_to_visible_in_seconds);
+ EXPECT_GT(priority.distance_to_visible, 0.f);
+ EXPECT_NE(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
- priority.time_to_visible_in_seconds);
+ EXPECT_GT(priority.distance_to_visible, 0.f);
+ EXPECT_NE(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
- priority.time_to_visible_in_seconds);
+ EXPECT_GT(priority.distance_to_visible, 0.f);
+ EXPECT_NE(TilePriority::NOW, priority.priority_bin);
}
TEST(UpdateTilePrioritiesTest, PartiallyOffscreenRotatedLayer) {
@@ -956,10 +875,8 @@ TEST(UpdateTilePrioritiesTest, PartiallyOffscreenRotatedLayer) {
scoped_ptr<TestablePictureLayerTiling> tiling;
gfx::Size device_viewport(800, 600);
- gfx::Rect visible_layer_rect(0, 0, 100, 100); // only top-left quarter.
gfx::Size last_layer_bounds(200, 200);
gfx::Size current_layer_bounds(200, 200);
- float last_layer_contents_scale = 1.f;
float current_layer_contents_scale = 1.f;
gfx::Transform last_screen_transform;
gfx::Transform current_screen_transform;
@@ -968,12 +885,15 @@ TEST(UpdateTilePrioritiesTest, PartiallyOffscreenRotatedLayer) {
// A diagonally rotated layer that is partially off the bottom of the screen.
// In this configuration, only the top-left tile would be visible.
- current_screen_transform.Translate(400, 550);
+ current_screen_transform.Translate(600, 750);
current_screen_transform.RotateAboutZAxis(45);
last_screen_transform = current_screen_transform;
gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
current_screen_transform, device_viewport);
+ gfx::Rect visible_layer_rect = viewport_in_layer_space;
+ visible_layer_rect.Intersect(
+ gfx::Rect(gfx::Point(0, 0), current_layer_bounds));
client.SetTileSize(gfx::Size(100, 100));
tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale
@@ -982,15 +902,9 @@ TEST(UpdateTilePrioritiesTest, PartiallyOffscreenRotatedLayer) {
tiling->UpdateTilePriorities(
ACTIVE_TREE,
- device_viewport,
viewport_in_layer_space,
visible_layer_rect,
- last_layer_bounds,
- current_layer_bounds,
- last_layer_contents_scale,
current_layer_contents_scale,
- last_screen_transform,
- current_screen_transform,
current_frame_time_in_seconds,
max_tiles_for_interest_area);
@@ -1000,39 +914,30 @@ TEST(UpdateTilePrioritiesTest, PartiallyOffscreenRotatedLayer) {
ASSERT_TRUE(tiling->TileAt(1, 1));
TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
- EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
- EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
+ EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+ EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
- priority.time_to_visible_in_seconds);
+ EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+ EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
- priority.time_to_visible_in_seconds);
+ EXPECT_GT(priority.distance_to_visible, 0.f);
+ EXPECT_NE(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
- priority.time_to_visible_in_seconds);
+ EXPECT_GT(priority.distance_to_visible, 0.f);
+ EXPECT_NE(TilePriority::NOW, priority.priority_bin);
// Furthermore, in this scenario the bottom-right tile should have the larger
// distance to visible.
TilePriority top_left = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
TilePriority top_right = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
- TilePriority bottom_left = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
TilePriority bottom_right = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
- EXPECT_GT(top_right.distance_to_visible_in_pixels,
- top_left.distance_to_visible_in_pixels);
- EXPECT_GT(bottom_left.distance_to_visible_in_pixels,
- top_left.distance_to_visible_in_pixels);
-
- EXPECT_GT(bottom_right.distance_to_visible_in_pixels,
- bottom_left.distance_to_visible_in_pixels);
- EXPECT_GT(bottom_right.distance_to_visible_in_pixels,
- top_right.distance_to_visible_in_pixels);
+ EXPECT_GT(top_right.distance_to_visible,
+ top_left.distance_to_visible);
+
+ EXPECT_EQ(bottom_right.distance_to_visible, top_right.distance_to_visible);
}
TEST(UpdateTilePrioritiesTest, PerspectiveLayer) {
@@ -1046,7 +951,6 @@ TEST(UpdateTilePrioritiesTest, PerspectiveLayer) {
gfx::Rect visible_layer_rect(0, 0, 0, 0); // offscreen.
gfx::Size last_layer_bounds(200, 200);
gfx::Size current_layer_bounds(200, 200);
- float last_layer_contents_scale = 1.f;
float current_layer_contents_scale = 1.f;
gfx::Transform last_screen_transform;
gfx::Transform current_screen_transform;
@@ -1084,15 +988,9 @@ TEST(UpdateTilePrioritiesTest, PerspectiveLayer) {
tiling->UpdateTilePriorities(
ACTIVE_TREE,
- device_viewport,
viewport_in_layer_space,
visible_layer_rect,
- last_layer_bounds,
- current_layer_bounds,
- last_layer_contents_scale,
current_layer_contents_scale,
- last_screen_transform,
- current_screen_transform,
current_frame_time_in_seconds,
max_tiles_for_interest_area);
@@ -1104,24 +1002,20 @@ TEST(UpdateTilePrioritiesTest, PerspectiveLayer) {
// All tiles will have a positive distance_to_visible
// and an infinite time_to_visible.
TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
- priority.time_to_visible_in_seconds);
+ EXPECT_FLOAT_EQ(priority.distance_to_visible, 0.f);
+ EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
- priority.time_to_visible_in_seconds);
+ EXPECT_GT(priority.distance_to_visible, 0.f);
+ EXPECT_NE(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
- priority.time_to_visible_in_seconds);
+ EXPECT_FLOAT_EQ(priority.distance_to_visible, 0.f);
+ EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
- priority.time_to_visible_in_seconds);
+ EXPECT_GT(priority.distance_to_visible, 0.f);
+ EXPECT_NE(TilePriority::NOW, priority.priority_bin);
// Furthermore, in this scenario the top-left distance_to_visible
// will be smallest, followed by top-right. The bottom layers
@@ -1130,14 +1024,12 @@ TEST(UpdateTilePrioritiesTest, PerspectiveLayer) {
TilePriority top_right = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
TilePriority bottom_left = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
TilePriority bottom_right = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
- EXPECT_GT(top_right.distance_to_visible_in_pixels,
- top_left.distance_to_visible_in_pixels);
- EXPECT_GT(bottom_right.distance_to_visible_in_pixels,
- top_right.distance_to_visible_in_pixels);
+ EXPECT_GT(bottom_right.distance_to_visible,
+ top_right.distance_to_visible);
- EXPECT_GT(bottom_left.distance_to_visible_in_pixels,
- top_left.distance_to_visible_in_pixels);
+ EXPECT_GT(bottom_left.distance_to_visible,
+ top_left.distance_to_visible);
}
TEST(UpdateTilePrioritiesTest, PerspectiveLayerClippedByW) {
@@ -1148,10 +1040,8 @@ TEST(UpdateTilePrioritiesTest, PerspectiveLayerClippedByW) {
scoped_ptr<TestablePictureLayerTiling> tiling;
gfx::Size device_viewport(800, 600);
- gfx::Rect visible_layer_rect(0, 0, 0, 0); // offscreen.
gfx::Size last_layer_bounds(200, 200);
gfx::Size current_layer_bounds(200, 200);
- float last_layer_contents_scale = 1.f;
float current_layer_contents_scale = 1.f;
gfx::Transform last_screen_transform;
gfx::Transform current_screen_transform;
@@ -1187,6 +1077,9 @@ TEST(UpdateTilePrioritiesTest, PerspectiveLayerClippedByW) {
gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
current_screen_transform, device_viewport);
+ gfx::Rect visible_layer_rect = viewport_in_layer_space;
+ visible_layer_rect.Intersect(
+ gfx::Rect(gfx::Point(0, 0), current_layer_bounds));
client.SetTileSize(gfx::Size(100, 100));
tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale
@@ -1195,15 +1088,9 @@ TEST(UpdateTilePrioritiesTest, PerspectiveLayerClippedByW) {
tiling->UpdateTilePriorities(
ACTIVE_TREE,
- device_viewport,
viewport_in_layer_space,
visible_layer_rect,
- last_layer_bounds,
- current_layer_bounds,
- last_layer_contents_scale,
current_layer_contents_scale,
- last_screen_transform,
- current_screen_transform,
current_frame_time_in_seconds,
max_tiles_for_interest_area);
@@ -1215,24 +1102,22 @@ TEST(UpdateTilePrioritiesTest, PerspectiveLayerClippedByW) {
// Left-side tiles will be clipped by the transform, so we have to assume
// they are visible just in case.
TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
- EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
- EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
+ EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+ EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
- EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
- EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
+ EXPECT_GT(priority.distance_to_visible, 0.f);
+ EXPECT_NE(TilePriority::NOW, priority.priority_bin);
// Right-side tiles will have a positive distance_to_visible
// and an infinite time_to_visible.
priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
- priority.time_to_visible_in_seconds);
+ EXPECT_FLOAT_EQ(priority.distance_to_visible, 0.f);
+ EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
- priority.time_to_visible_in_seconds);
+ EXPECT_GT(priority.distance_to_visible, 0.f);
+ EXPECT_NE(TilePriority::NOW, priority.priority_bin);
}
TEST(UpdateTilePrioritiesTest, BasicMotion) {
@@ -1269,30 +1154,18 @@ TEST(UpdateTilePrioritiesTest, BasicMotion) {
// previous ("last") frame
tiling->UpdateTilePriorities(
ACTIVE_TREE,
- device_viewport,
viewport_in_layer_space,
visible_layer_rect,
- last_layer_bounds,
- last_layer_bounds,
- last_layer_contents_scale,
last_layer_contents_scale,
- last_screen_transform,
- last_screen_transform,
last_frame_time_in_seconds,
max_tiles_for_interest_area);
// current frame
tiling->UpdateTilePriorities(
ACTIVE_TREE,
- device_viewport,
viewport_in_layer_space,
visible_layer_rect,
- last_layer_bounds,
- current_layer_bounds,
- last_layer_contents_scale,
current_layer_contents_scale,
- last_screen_transform,
- current_screen_transform,
current_frame_time_in_seconds,
max_tiles_for_interest_area);
@@ -1302,26 +1175,22 @@ TEST(UpdateTilePrioritiesTest, BasicMotion) {
ASSERT_TRUE(tiling->TileAt(1, 1));
TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(1.f,
- priority.time_to_visible_in_seconds);
+ EXPECT_GT(priority.distance_to_visible, 0.f);
+ EXPECT_NE(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(1.f,
- priority.time_to_visible_in_seconds);
+ EXPECT_GT(priority.distance_to_visible, 0.f);
+ EXPECT_NE(TilePriority::NOW, priority.priority_bin);
// time_to_visible for the right hand side layers needs an extra 0.099
// seconds because this tile is 99 pixels further away.
priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(1.099f,
- priority.time_to_visible_in_seconds);
+ EXPECT_GT(priority.distance_to_visible, 0.f);
+ EXPECT_NE(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(1.099f,
- priority.time_to_visible_in_seconds);
+ EXPECT_GT(priority.distance_to_visible, 0.f);
+ EXPECT_NE(TilePriority::NOW, priority.priority_bin);
}
TEST(UpdateTilePrioritiesTest, RotationMotion) {
@@ -1367,30 +1236,18 @@ TEST(UpdateTilePrioritiesTest, RotationMotion) {
// previous ("last") frame
tiling->UpdateTilePriorities(
ACTIVE_TREE,
- device_viewport,
viewport_in_layer_space,
visible_layer_rect,
- last_layer_bounds,
- last_layer_bounds,
last_layer_contents_scale,
- last_layer_contents_scale,
- last_screen_transform,
- last_screen_transform,
last_frame_time_in_seconds,
max_tiles_for_interest_area);
// current frame
tiling->UpdateTilePriorities(
ACTIVE_TREE,
- device_viewport,
viewport_in_layer_space,
visible_layer_rect,
- last_layer_bounds,
- current_layer_bounds,
- last_layer_contents_scale,
current_layer_contents_scale,
- last_screen_transform,
- current_screen_transform,
current_frame_time_in_seconds,
max_tiles_for_interest_area);
@@ -1400,17 +1257,16 @@ TEST(UpdateTilePrioritiesTest, RotationMotion) {
ASSERT_TRUE(tiling->TileAt(1, 1));
TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
- EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
- EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
+ EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+ EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_GT(priority.time_to_visible_in_seconds, 0.f);
+ EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+ EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
- EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
- priority.time_to_visible_in_seconds);
+ EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+ EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
}
} // namespace
« cc/resources/picture_layer_tiling.cc ('K') | « cc/resources/picture_layer_tiling_set.cc ('k') | cc/resources/prioritized_tile_set.cc » ('j') | cc/resources/prioritized_tile_set.cc » ('J')

Powered by Google App Engine
This is Rietveld 408576698