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

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: update 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/layers/picture_layer_impl_unittest.cc ('K') | « cc/resources/picture_layer_tiling_set.cc ('k') | cc/resources/prioritized_tile_set.cc » ('j') | no next file with comments »
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..120c5511dbaf940ad566eaf903a3f4a62d28acba 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);
}
@@ -155,6 +154,10 @@ class PictureLayerTilingIteratorTest : public testing::Test {
VerifyTilesExactlyCoverRect(rect_scale, dest_rect, clamped_rect);
}
+ void set_max_tiles_for_interest_area(size_t area) {
+ client_.set_max_tiles_for_interest_area(area);
+ }
+
protected:
FakePictureLayerTilingClient client_;
scoped_ptr<TestablePictureLayerTiling> tiling_;
@@ -493,35 +496,19 @@ TEST_F(PictureLayerTilingIteratorTest, TilesExist) {
VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
+ set_max_tiles_for_interest_area(1000);
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
+ 1.f, // current contents scale
+ 1.0); // current frame time
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,
- 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
+ tiling_->UpdateTilePriorities(ACTIVE_TREE,
+ gfx::Rect(), // visible content rect
+ 1.f, // current contents scale
+ 2.0); // current frame time
VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
}
@@ -533,35 +520,19 @@ TEST_F(PictureLayerTilingIteratorTest, TilesExistGiantViewport) {
gfx::Rect giant_rect(-10000000, -10000000, 1000000000, 1000000000);
+ set_max_tiles_for_interest_area(1000);
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
+ 1.f, // current contents scale
+ 1.0); // current frame time
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,
- 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
+ tiling_->UpdateTilePriorities(ACTIVE_TREE,
+ giant_rect, // visible content rect
+ 1.f, // current contents scale
+ 2.0); // current frame time
VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
}
@@ -576,19 +547,11 @@ TEST_F(PictureLayerTilingIteratorTest, TilesExistOutsideViewport) {
gfx::Rect viewport_rect(1100, 0, 1000, 1000);
EXPECT_FALSE(viewport_rect.Intersects(gfx::Rect(layer_bounds)));
- 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
+ set_max_tiles_for_interest_area(1000);
+ tiling_->UpdateTilePriorities(ACTIVE_TREE,
+ viewport_rect, // visible content rect
+ 1.f, // current contents scale
+ 1.0); // current frame time
VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
}
@@ -612,19 +575,12 @@ TEST_F(PictureLayerTilingIteratorTest,
gfx::Rect visible_rect(8000, 8000, 50, 50);
+ set_max_tiles_for_interest_area(1);
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
+ 1.0); // current frame time
VerifyTiles(1.f,
gfx::Rect(layer_bounds),
base::Bind(&TilesIntersectingRectExist, visible_rect, true));
@@ -644,19 +600,12 @@ TEST_F(PictureLayerTilingIteratorTest,
VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
+ set_max_tiles_for_interest_area(1);
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
+ 1.f, // current contents scale
+ 1.0); // current frame time
int num_tiles = 0;
VerifyTiles(1.f,
@@ -683,19 +632,12 @@ TEST_F(PictureLayerTilingIteratorTest, AddTilingsToMatchScale) {
gfx::Rect(layer_bounds),
base::Bind(&TileExists, false));
+ set_max_tiles_for_interest_area(10000);
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
+ 1.f, // current contents scale
+ 1.0); // current frame time
// The active tiling has tiles now.
VerifyTiles(active_set.tiling_at(0),
@@ -718,17 +660,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
+ 1.f, // current contents scale
+ 1.0); // current frame time
VerifyTiles(pending_set.tiling_at(0),
1.f,
@@ -744,12 +678,9 @@ TEST(UpdateTilePrioritiesTest, VisibleTiles) {
scoped_ptr<TestablePictureLayerTiling> tiling;
gfx::Size device_viewport(800, 600);
- 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;
double current_frame_time_in_seconds = 1.0;
size_t max_tiles_for_interest_area = 10000;
@@ -762,19 +693,12 @@ TEST(UpdateTilePrioritiesTest, VisibleTiles) {
current_layer_bounds,
&client);
+ client.set_max_tiles_for_interest_area(max_tiles_for_interest_area);
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);
+ current_frame_time_in_seconds);
ASSERT_TRUE(tiling->TileAt(0, 0));
ASSERT_TRUE(tiling->TileAt(0, 1));
@@ -782,20 +706,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) {
@@ -806,10 +730,8 @@ TEST(UpdateTilePrioritiesTest, OffscreenTiles) {
scoped_ptr<TestablePictureLayerTiling> tiling;
gfx::Size device_viewport(800, 600);
- 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;
@@ -827,19 +749,11 @@ TEST(UpdateTilePrioritiesTest, OffscreenTiles) {
current_layer_bounds,
&client);
- 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);
+ client.set_max_tiles_for_interest_area(max_tiles_for_interest_area);
+ tiling->UpdateTilePriorities(ACTIVE_TREE,
+ viewport_in_layer_space,
+ current_layer_contents_scale,
+ current_frame_time_in_seconds);
ASSERT_TRUE(tiling->TileAt(0, 0));
ASSERT_TRUE(tiling->TileAt(0, 1));
@@ -847,36 +761,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 +797,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;
@@ -908,19 +816,11 @@ TEST(UpdateTilePrioritiesTest, PartiallyOffscreenLayer) {
current_layer_bounds,
&client);
- 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);
+ client.set_max_tiles_for_interest_area(max_tiles_for_interest_area);
+ tiling->UpdateTilePriorities(ACTIVE_TREE,
+ viewport_in_layer_space,
+ current_layer_contents_scale,
+ current_frame_time_in_seconds);
ASSERT_TRUE(tiling->TileAt(0, 0));
ASSERT_TRUE(tiling->TileAt(0, 1));
@@ -928,23 +828,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 +853,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,7 +863,7 @@ 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;
@@ -980,19 +875,11 @@ TEST(UpdateTilePrioritiesTest, PartiallyOffscreenRotatedLayer) {
current_layer_bounds,
&client);
- 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);
+ client.set_max_tiles_for_interest_area(max_tiles_for_interest_area);
+ tiling->UpdateTilePriorities(ACTIVE_TREE,
+ viewport_in_layer_space,
+ current_layer_contents_scale,
+ current_frame_time_in_seconds);
ASSERT_TRUE(tiling->TileAt(0, 0));
ASSERT_TRUE(tiling->TileAt(0, 1));
@@ -1000,39 +887,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 +924,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;
@@ -1082,19 +959,11 @@ TEST(UpdateTilePrioritiesTest, PerspectiveLayer) {
current_layer_bounds,
&client);
- 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);
+ client.set_max_tiles_for_interest_area(max_tiles_for_interest_area);
+ tiling->UpdateTilePriorities(ACTIVE_TREE,
+ viewport_in_layer_space,
+ current_layer_contents_scale,
+ current_frame_time_in_seconds);
ASSERT_TRUE(tiling->TileAt(0, 0));
ASSERT_TRUE(tiling->TileAt(0, 1));
@@ -1104,24 +973,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 +995,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 +1011,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;
@@ -1193,19 +1054,11 @@ TEST(UpdateTilePrioritiesTest, PerspectiveLayerClippedByW) {
current_layer_bounds,
&client);
- 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);
+ client.set_max_tiles_for_interest_area(max_tiles_for_interest_area);
+ tiling->UpdateTilePriorities(ACTIVE_TREE,
+ viewport_in_layer_space,
+ current_layer_contents_scale,
+ current_frame_time_in_seconds);
ASSERT_TRUE(tiling->TileAt(0, 0));
ASSERT_TRUE(tiling->TileAt(0, 1));
@@ -1215,24 +1068,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) {
@@ -1266,35 +1117,18 @@ TEST(UpdateTilePrioritiesTest, BasicMotion) {
current_layer_bounds,
&client);
+ client.set_max_tiles_for_interest_area(max_tiles_for_interest_area);
// 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);
+ tiling->UpdateTilePriorities(ACTIVE_TREE,
+ viewport_in_layer_space,
+ last_layer_contents_scale,
+ last_frame_time_in_seconds);
// 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);
+ tiling->UpdateTilePriorities(ACTIVE_TREE,
+ viewport_in_layer_space,
+ current_layer_contents_scale,
+ current_frame_time_in_seconds);
ASSERT_TRUE(tiling->TileAt(0, 0));
ASSERT_TRUE(tiling->TileAt(0, 1));
@@ -1302,26 +1136,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) {
@@ -1364,35 +1194,19 @@ TEST(UpdateTilePrioritiesTest, RotationMotion) {
current_layer_bounds,
&client);
+ client.set_max_tiles_for_interest_area(max_tiles_for_interest_area);
+
// 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);
+ tiling->UpdateTilePriorities(ACTIVE_TREE,
+ viewport_in_layer_space,
+ last_layer_contents_scale,
+ last_frame_time_in_seconds);
// 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);
+ tiling->UpdateTilePriorities(ACTIVE_TREE,
+ viewport_in_layer_space,
+ current_layer_contents_scale,
+ current_frame_time_in_seconds);
ASSERT_TRUE(tiling->TileAt(0, 0));
ASSERT_TRUE(tiling->TileAt(0, 1));
@@ -1400,17 +1214,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/layers/picture_layer_impl_unittest.cc ('K') | « cc/resources/picture_layer_tiling_set.cc ('k') | cc/resources/prioritized_tile_set.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698