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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: cc/resources/picture_layer_tiling_unittest.cc

Issue 107413008: Merge 241994 "Revert "cc: Added tile bundles"" (Closed) Base URL: svn://svn.chromium.org/chrome/branches/1750/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
« no previous file with comments | « cc/resources/picture_layer_tiling_set_unittest.cc ('k') | cc/resources/prioritized_tile_set_unittest.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
===================================================================
--- cc/resources/picture_layer_tiling_unittest.cc (revision 243316)
+++ cc/resources/picture_layer_tiling_unittest.cc (working copy)
@@ -5,13 +5,10 @@
#include "cc/resources/picture_layer_tiling.h"
#include <limits>
-#include <set>
#include "cc/base/math_util.h"
#include "cc/resources/picture_layer_tiling_set.h"
#include "cc/test/fake_picture_layer_tiling_client.h"
-#include "cc/test/fake_tile_manager.h"
-#include "cc/test/fake_tile_manager_client.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/gfx/rect_conversions.h"
#include "ui/gfx/size_conversions.h"
@@ -19,12 +16,6 @@
namespace cc {
namespace {
-const int kTileBundleWidth = 2;
-const int kTileBundleHeight = 2;
-std::pair<int, int> ComputeTileBundleIndex(int i, int j) {
- return std::make_pair(i / kTileBundleWidth, j / kTileBundleHeight);
-}
-
static gfx::Rect ViewportInLayerSpace(
const gfx::Transform& transform,
gfx::Size device_viewport) {
@@ -43,7 +34,6 @@
public:
using PictureLayerTiling::SetLiveTilesRect;
using PictureLayerTiling::TileAt;
- using PictureLayerTiling::TileBundleAt;
static scoped_ptr<TestablePictureLayerTiling> Create(
float contents_scale,
@@ -55,9 +45,6 @@
client));
}
- TilingData tiling_data() const { return tiling_data_; }
- TilingData bundle_tiling_data() const { return bundle_tiling_data_; }
-
protected:
TestablePictureLayerTiling(float contents_scale,
gfx::Size layer_bounds,
@@ -67,9 +54,7 @@
class PictureLayerTilingIteratorTest : public testing::Test {
public:
- PictureLayerTilingIteratorTest()
- : tile_manager_(&tile_manager_client_), client_(&tile_manager_) {}
-
+ PictureLayerTilingIteratorTest() {}
virtual ~PictureLayerTilingIteratorTest() {}
void Initialize(gfx::Size tile_size,
@@ -82,7 +67,6 @@
}
void SetLiveRectAndVerifyTiles(gfx::Rect live_tiles_rect) {
- tiling_->SetTreeForTesting(ACTIVE_TREE);
tiling_->SetLiveTilesRect(live_tiles_rect);
std::vector<Tile*> tiles = tiling_->AllTilesForTesting();
@@ -169,8 +153,6 @@
}
protected:
- FakeTileManagerClient tile_manager_client_;
- FakeTileManager tile_manager_;
FakePictureLayerTilingClient client_;
scoped_ptr<TestablePictureLayerTiling> tiling_;
@@ -279,107 +261,6 @@
VerifyTilesCoverNonContainedRect(0.5f, gfx::Rect(-1000, 100, 2000, 100));
}
-TEST(PictureLayerTilingTest, BundleAtContainsTileAt) {
- FakeTileManagerClient tile_manager_client;
- FakeTileManager tile_manager(&tile_manager_client);
- FakePictureLayerTilingClient client(&tile_manager);
-
- gfx::Size current_layer_bounds(400, 400);
- client.SetTileSize(gfx::Size(100, 100));
- scoped_ptr<TestablePictureLayerTiling> tiling =
- TestablePictureLayerTiling::Create(1.0f, current_layer_bounds, &client);
-
- tiling->CreateTilesForTesting(ACTIVE_TREE);
- for (int bundle_y = 0;
- bundle_y < (current_layer_bounds.height() / (kTileBundleHeight * 100));
- ++bundle_y) {
- for (int bundle_x = 0;
- bundle_x < (current_layer_bounds.width() / (kTileBundleWidth * 100));
- ++bundle_x) {
- EXPECT_TRUE(tiling->TileBundleAt(bundle_x, bundle_y))
- << "bundle_x " << bundle_x << " bundle_y " << bundle_y;
-
- TileBundle* bundle = tiling->TileBundleAt(bundle_x, bundle_y);
- for (int tile_y = 0; tile_y < kTileBundleWidth; ++tile_y) {
- for (int tile_x = 0; tile_x < kTileBundleHeight; ++tile_x) {
- int global_tile_x = bundle_x * kTileBundleWidth + tile_x;
- int global_tile_y = bundle_y * kTileBundleHeight + tile_y;
-
- EXPECT_TRUE(tiling->TileAt(ACTIVE_TREE, global_tile_x, global_tile_y))
- << "x " << global_tile_x << " y " << global_tile_y;
- EXPECT_EQ(tiling->TileAt(ACTIVE_TREE, global_tile_x, global_tile_y),
- bundle->TileAt(ACTIVE_TREE, global_tile_x, global_tile_y))
- << "x " << global_tile_x << " y " << global_tile_y;
- }
- }
- }
- }
-}
-
-TEST(PictureLayerTilingTest, TilesCleanedUp) {
- FakeTileManagerClient tile_manager_client;
- FakeTileManager tile_manager(&tile_manager_client);
- FakePictureLayerTilingClient client(&tile_manager);
- FakePictureLayerTilingClient twin_client(&tile_manager);
-
- gfx::Size current_layer_bounds(400, 400);
- client.SetTileSize(gfx::Size(100, 100));
- twin_client.SetTileSize(gfx::Size(100, 100));
- scoped_ptr<TestablePictureLayerTiling> tiling =
- TestablePictureLayerTiling::Create(1.0f, current_layer_bounds, &client);
- scoped_ptr<TestablePictureLayerTiling> twin_tiling =
- TestablePictureLayerTiling::Create(
- 1.0f, current_layer_bounds, &twin_client);
-
- client.set_twin_tiling(twin_tiling.get());
- twin_client.set_twin_tiling(tiling.get());
-
- tiling->CreateTilesForTesting(ACTIVE_TREE);
- twin_tiling->CreateTilesForTesting(PENDING_TREE);
- for (int tile_y = 0; tile_y < 4; ++tile_y) {
- for (int tile_x = 0; tile_x < 4; ++tile_x) {
- EXPECT_TRUE(tiling->TileAt(ACTIVE_TREE, tile_x, tile_y) ==
- twin_tiling->TileAt(ACTIVE_TREE, tile_x, tile_y));
- EXPECT_TRUE(tiling->TileAt(PENDING_TREE, tile_x, tile_y) ==
- twin_tiling->TileAt(PENDING_TREE, tile_x, tile_y));
- }
- }
-
- client.set_twin_tiling(NULL);
- twin_tiling.reset();
-
- for (int tile_y = 0; tile_y < 4; ++tile_y) {
- for (int tile_x = 0; tile_x < 4; ++tile_x) {
- EXPECT_TRUE(tiling->TileAt(ACTIVE_TREE, tile_x, tile_y) != NULL);
- EXPECT_TRUE(tiling->TileAt(PENDING_TREE, tile_x, tile_y) == NULL);
- }
- }
-}
-
-TEST(PictureLayerTilingTest, DidBecomeActiveSwapsTiles) {
- FakeTileManagerClient tile_manager_client;
- FakeTileManager tile_manager(&tile_manager_client);
- FakePictureLayerTilingClient client(&tile_manager);
-
- gfx::Size current_layer_bounds(400, 400);
- client.SetTileSize(gfx::Size(100, 100));
- scoped_ptr<TestablePictureLayerTiling> tiling =
- TestablePictureLayerTiling::Create(1.0f, current_layer_bounds, &client);
-
- tiling->CreateTilesForTesting(ACTIVE_TREE);
- std::vector<Tile*> old_active_tiles = tiling->TilesForTesting(ACTIVE_TREE);
- tiling->DidBecomeActive();
- std::vector<Tile*> pending_tiles = tiling->TilesForTesting(PENDING_TREE);
- EXPECT_EQ(old_active_tiles.size(), pending_tiles.size());
- std::vector<Tile*>::const_iterator old_it = old_active_tiles.begin();
- for (std::vector<Tile*>::const_iterator it = pending_tiles.begin();
- it != pending_tiles.end();
- ++it) {
- EXPECT_EQ(*it, *old_it);
- ++old_it;
- }
-}
-
TEST(PictureLayerTilingTest, ExpandRectEqual) {
gfx::Rect in(40, 50, 100, 200);
gfx::Rect bounds(-1000, -1000, 10000, 10000);
@@ -851,64 +732,11 @@
base::Bind(&TileExists, true));
}
-TEST_F(PictureLayerTilingIteratorTest, BundlesAndTilesAlign) {
- Initialize(gfx::Size(100, 100), 1, gfx::Size(850, 850));
- for (int y = -20; y <= 102; ++y) {
- for (int x = 0; x <= 103; ++x) {
- for (int size = 1; size <= 201; size += 50) {
- gfx::Rect rect(x, y, size, size);
-
- TilingData tiling_data = tiling_->tiling_data();
-
- std::set<std::pair<int, int> > tile_positions;
- std::set<std::pair<int, int> > predicted_bundle_positions;
- size_t iteration_count = 0;
- for (TilingData::Iterator iter(&tiling_data, rect); iter; ++iter) {
- ++iteration_count;
- tile_positions.insert(std::make_pair(iter.index_x(), iter.index_y()));
- predicted_bundle_positions.insert(
- ComputeTileBundleIndex(iter.index_x(), iter.index_y()));
- }
-
- ASSERT_EQ(tile_positions.size(), iteration_count) << rect.ToString();
-
- TilingData bundle_tiling_data = tiling_->bundle_tiling_data();
- std::set<std::pair<int, int> > bundle_positions;
- iteration_count = 0;
- for (TilingData::Iterator iter(&bundle_tiling_data, rect);
- iter;
- ++iter) {
- ++iteration_count;
- bundle_positions.insert(
- std::make_pair(iter.index_x(), iter.index_y()));
- }
-
- ASSERT_EQ(bundle_positions.size(), iteration_count) << rect.ToString();
- ASSERT_EQ(predicted_bundle_positions.size(), iteration_count)
- << rect.ToString();
-
- std::set<std::pair<int, int> >::const_iterator predicted_iterator =
- predicted_bundle_positions.begin();
- for (std::set<std::pair<int, int> >::const_iterator actual_iterator =
- bundle_positions.begin();
- actual_iterator != bundle_positions.end();
- ++actual_iterator) {
- ASSERT_EQ(*actual_iterator, *predicted_iterator) << rect.ToString();
- ++predicted_iterator;
- }
- }
- }
- }
-}
-
-
TEST(UpdateTilePrioritiesTest, VisibleTiles) {
// The TilePriority of visible tiles should have zero distance_to_visible
// and time_to_visible.
- FakeTileManagerClient tile_manager_client;
- FakeTileManager tile_manager(&tile_manager_client);
- FakePictureLayerTilingClient client(&tile_manager);
+ FakePictureLayerTilingClient client;
scoped_ptr<TestablePictureLayerTiling> tiling;
gfx::Size device_viewport(800, 600);
@@ -944,30 +772,39 @@
current_frame_time_in_seconds,
max_tiles_for_interest_area);
- ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 0, 0));
- ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 0, 1));
- ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 1, 0));
- ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 1, 1));
- ASSERT_TRUE(tiling->TileBundleAt(0, 0));
+ ASSERT_TRUE(tiling->TileAt(0, 0));
+ ASSERT_TRUE(tiling->TileAt(0, 1));
+ ASSERT_TRUE(tiling->TileAt(1, 0));
+ ASSERT_TRUE(tiling->TileAt(1, 1));
- TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
+ 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);
+
+ 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);
+
+ 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);
+
+ 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);
}
TEST(UpdateTilePrioritiesTest, OffscreenTiles) {
// The TilePriority of offscreen tiles (without movement) should have nonzero
// distance_to_visible and infinite time_to_visible.
- FakeTileManagerClient tile_manager_client;
- FakeTileManager tile_manager(&tile_manager_client);
- FakePictureLayerTilingClient client(&tile_manager);
+ FakePictureLayerTilingClient client;
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(400, 400);
- gfx::Size current_layer_bounds(400, 400);
+ 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;
@@ -1000,34 +837,40 @@
current_frame_time_in_seconds,
max_tiles_for_interest_area);
- ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 0, 0));
- ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 0, 1));
- ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 1, 0));
- ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 1, 1));
- ASSERT_TRUE(tiling->TileBundleAt(0, 0));
+ ASSERT_TRUE(tiling->TileAt(0, 0));
+ ASSERT_TRUE(tiling->TileAt(0, 1));
+ ASSERT_TRUE(tiling->TileAt(1, 0));
+ ASSERT_TRUE(tiling->TileAt(1, 1));
- TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
+ 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);
- ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 2, 2));
- ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 2, 3));
- ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 3, 2));
- ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 3, 3));
- ASSERT_TRUE(tiling->TileBundleAt(0, 1));
- ASSERT_TRUE(tiling->TileBundleAt(1, 0));
- ASSERT_TRUE(tiling->TileBundleAt(1, 1));
+ 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);
- // Furthermore, in this scenario bundles on the right hand side should have a
+ 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);
+
+ 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);
+
+ // Furthermore, in this scenario tiles on the right hand side should have a
// larger distance to visible.
- TilePriority left = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
- TilePriority right = tiling->TileBundleAt(1, 0)->GetPriority(ACTIVE_TREE);
+ 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);
- left = tiling->TileBundleAt(0, 1)->GetPriority(ACTIVE_TREE);
- right = tiling->TileBundleAt(1, 1)->GetPriority(ACTIVE_TREE);
+ 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);
}
@@ -1036,15 +879,13 @@
// Sanity check that a layer with some tiles visible and others offscreen has
// correct TilePriorities for each tile.
- FakeTileManagerClient tile_manager_client;
- FakeTileManager tile_manager(&tile_manager_client);
- FakePictureLayerTilingClient client(&tile_manager);
+ FakePictureLayerTilingClient client;
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(400, 400);
- gfx::Size current_layer_bounds(400, 400);
+ 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;
@@ -1077,30 +918,26 @@
current_frame_time_in_seconds,
max_tiles_for_interest_area);
- ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 0, 0));
- ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 0, 1));
- ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 1, 0));
- ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 1, 1));
- ASSERT_TRUE(tiling->TileBundleAt(0, 0));
- ASSERT_TRUE(tiling->TileBundleAt(0, 1));
- ASSERT_TRUE(tiling->TileBundleAt(1, 0));
- ASSERT_TRUE(tiling->TileBundleAt(1, 1));
+ ASSERT_TRUE(tiling->TileAt(0, 0));
+ ASSERT_TRUE(tiling->TileAt(0, 1));
+ ASSERT_TRUE(tiling->TileAt(1, 0));
+ ASSERT_TRUE(tiling->TileAt(1, 1));
- TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
+ 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);
- priority = tiling->TileBundleAt(0, 1)->GetPriority(ACTIVE_TREE);
+ 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);
- priority = tiling->TileBundleAt(1, 0)->GetPriority(ACTIVE_TREE);
+ 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);
- priority = tiling->TileBundleAt(1, 1)->GetPriority(ACTIVE_TREE);
+ 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);
@@ -1111,15 +948,13 @@
// that UpdateTilePriorities correctly accounts for the transform between
// layer space and screen space.
- FakeTileManagerClient tile_manager_client;
- FakeTileManager tile_manager(&tile_manager_client);
- FakePictureLayerTilingClient client(&tile_manager);
+ FakePictureLayerTilingClient client;
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(400, 400);
- gfx::Size current_layer_bounds(400, 400);
+ 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;
@@ -1155,38 +990,36 @@
current_frame_time_in_seconds,
max_tiles_for_interest_area);
- ASSERT_TRUE(tiling->TileBundleAt(0, 0));
- ASSERT_TRUE(tiling->TileBundleAt(0, 1));
- ASSERT_TRUE(tiling->TileBundleAt(1, 0));
- ASSERT_TRUE(tiling->TileBundleAt(1, 1));
+ ASSERT_TRUE(tiling->TileAt(0, 0));
+ ASSERT_TRUE(tiling->TileAt(0, 1));
+ ASSERT_TRUE(tiling->TileAt(1, 0));
+ ASSERT_TRUE(tiling->TileAt(1, 1));
- TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
+ 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);
- priority = tiling->TileBundleAt(0, 1)->GetPriority(ACTIVE_TREE);
+ 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);
- priority = tiling->TileBundleAt(1, 0)->GetPriority(ACTIVE_TREE);
+ 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);
- priority = tiling->TileBundleAt(1, 1)->GetPriority(ACTIVE_TREE);
+ 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);
// Furthermore, in this scenario the bottom-right tile should have the larger
// distance to visible.
- TilePriority top_left = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
- TilePriority top_right = tiling->TileBundleAt(1, 0)->GetPriority(ACTIVE_TREE);
- TilePriority bottom_left =
- tiling->TileBundleAt(0, 1)->GetPriority(ACTIVE_TREE);
- TilePriority bottom_right =
- tiling->TileBundleAt(1, 1)->GetPriority(ACTIVE_TREE);
+ 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,
@@ -1202,15 +1035,13 @@
// Perspective transforms need to take a different code path.
// This test checks tile priorities of a perspective layer.
- FakeTileManagerClient tile_manager_client;
- FakeTileManager tile_manager(&tile_manager_client);
- FakePictureLayerTilingClient client(&tile_manager);
+ FakePictureLayerTilingClient client;
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(400, 400);
- gfx::Size current_layer_bounds(400, 400);
+ 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;
@@ -1261,29 +1092,29 @@
current_frame_time_in_seconds,
max_tiles_for_interest_area);
- ASSERT_TRUE(tiling->TileBundleAt(0, 0));
- ASSERT_TRUE(tiling->TileBundleAt(0, 1));
- ASSERT_TRUE(tiling->TileBundleAt(1, 0));
- ASSERT_TRUE(tiling->TileBundleAt(1, 1));
+ ASSERT_TRUE(tiling->TileAt(0, 0));
+ ASSERT_TRUE(tiling->TileAt(0, 1));
+ ASSERT_TRUE(tiling->TileAt(1, 0));
+ ASSERT_TRUE(tiling->TileAt(1, 1));
// All tiles will have a positive distance_to_visible
// and an infinite time_to_visible.
- TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
+ 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);
- priority = tiling->TileBundleAt(0, 1)->GetPriority(ACTIVE_TREE);
+ 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);
- priority = tiling->TileBundleAt(1, 0)->GetPriority(ACTIVE_TREE);
+ 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);
- priority = tiling->TileBundleAt(1, 1)->GetPriority(ACTIVE_TREE);
+ 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);
@@ -1291,12 +1122,10 @@
// Furthermore, in this scenario the top-left distance_to_visible
// will be smallest, followed by top-right. The bottom layers
// will of course be further than the top layers.
- TilePriority top_left = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
- TilePriority top_right = tiling->TileBundleAt(1, 0)->GetPriority(ACTIVE_TREE);
- TilePriority bottom_left =
- tiling->TileBundleAt(0, 1)->GetPriority(ACTIVE_TREE);
- TilePriority bottom_right =
- tiling->TileBundleAt(1, 1)->GetPriority(ACTIVE_TREE);
+ 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);
@@ -1311,15 +1140,13 @@
// Perspective transforms need to take a different code path.
// This test checks tile priorities of a perspective layer.
- FakeTileManagerClient tile_manager_client;
- FakeTileManager tile_manager(&tile_manager_client);
- FakePictureLayerTilingClient client(&tile_manager);
+ FakePictureLayerTilingClient client;
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(400, 400);
- gfx::Size current_layer_bounds(400, 400);
+ 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;
@@ -1335,22 +1162,22 @@
// Translate layer to offscreen
current_screen_transform.Translate(400.0, 970.0);
// Apply perspective and rotation about the center of the layer
- current_screen_transform.Translate(200.0, 200.0);
+ current_screen_transform.Translate(100.0, 100.0);
current_screen_transform.ApplyPerspectiveDepth(10.0);
current_screen_transform.RotateAboutYAxis(10.0);
- current_screen_transform.Translate(-200.0, -200.0);
+ current_screen_transform.Translate(-100.0, -100.0);
last_screen_transform = current_screen_transform;
// Sanity check that this transform does cause w<0 clipping for the left side
// of the layer, but not the right side.
bool clipped;
MathUtil::MapQuad(current_screen_transform,
- gfx::QuadF(gfx::RectF(0, 0, 200, 400)),
+ gfx::QuadF(gfx::RectF(0, 0, 100, 200)),
&clipped);
ASSERT_TRUE(clipped);
MathUtil::MapQuad(current_screen_transform,
- gfx::QuadF(gfx::RectF(200, 0, 200, 400)),
+ gfx::QuadF(gfx::RectF(100, 0, 100, 200)),
&clipped);
ASSERT_FALSE(clipped);
@@ -1376,29 +1203,29 @@
current_frame_time_in_seconds,
max_tiles_for_interest_area);
- ASSERT_TRUE(tiling->TileBundleAt(0, 0));
- ASSERT_TRUE(tiling->TileBundleAt(0, 1));
- ASSERT_TRUE(tiling->TileBundleAt(1, 0));
- ASSERT_TRUE(tiling->TileBundleAt(1, 1));
+ ASSERT_TRUE(tiling->TileAt(0, 0));
+ ASSERT_TRUE(tiling->TileAt(0, 1));
+ ASSERT_TRUE(tiling->TileAt(1, 0));
+ ASSERT_TRUE(tiling->TileAt(1, 1));
// Left-side tiles will be clipped by the transform, so we have to assume
// they are visible just in case.
- TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
+ 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);
- priority = tiling->TileBundleAt(0, 1)->GetPriority(ACTIVE_TREE);
+ 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);
// Right-side tiles will have a positive distance_to_visible
// and an infinite time_to_visible.
- priority = tiling->TileBundleAt(1, 0)->GetPriority(ACTIVE_TREE);
+ 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);
- priority = tiling->TileBundleAt(1, 1)->GetPriority(ACTIVE_TREE);
+ 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);
@@ -1408,9 +1235,7 @@
// Test that time_to_visible is computed correctly when
// there is some motion.
- FakeTileManagerClient tile_manager_client;
- FakeTileManager tile_manager(&tile_manager_client);
- FakePictureLayerTilingClient client(&tile_manager);
+ FakePictureLayerTilingClient client;
scoped_ptr<TestablePictureLayerTiling> tiling;
gfx::Size device_viewport(800, 600);
@@ -1432,7 +1257,7 @@
gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
current_screen_transform, device_viewport);
- client.SetTileSize(gfx::Size(50, 50));
+ client.SetTileSize(gfx::Size(100, 100));
tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale
current_layer_bounds,
&client);
@@ -1467,32 +1292,31 @@
current_frame_time_in_seconds,
max_tiles_for_interest_area);
- ASSERT_TRUE(tiling->TileBundleAt(0, 0));
- ASSERT_TRUE(tiling->TileBundleAt(0, 1));
- ASSERT_TRUE(tiling->TileBundleAt(1, 0));
- ASSERT_TRUE(tiling->TileBundleAt(1, 1));
+ ASSERT_TRUE(tiling->TileAt(0, 0));
+ ASSERT_TRUE(tiling->TileAt(0, 1));
+ ASSERT_TRUE(tiling->TileAt(1, 0));
+ ASSERT_TRUE(tiling->TileAt(1, 1));
- TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
+ 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);
- priority = tiling->TileBundleAt(0, 1)->GetPriority(ACTIVE_TREE);
+ 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);
- // time_to_visible for the right hand side layers needs an extra 0.097
- // seconds because this bundle is
- // |(50 - 2 * border_texels) * 2 + border_texels| = 97 pixels further away.
- priority = tiling->TileBundleAt(1, 0)->GetPriority(ACTIVE_TREE);
+ // 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.097f,
+ EXPECT_FLOAT_EQ(1.099f,
priority.time_to_visible_in_seconds);
- priority = tiling->TileBundleAt(1, 1)->GetPriority(ACTIVE_TREE);
+ priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
- EXPECT_FLOAT_EQ(1.097f,
+ EXPECT_FLOAT_EQ(1.099f,
priority.time_to_visible_in_seconds);
}
@@ -1501,9 +1325,7 @@
// that UpdateTilePriorities correctly accounts for the transform between
// layer space and screen space.
- FakeTileManagerClient tile_manager_client;
- FakeTileManager tile_manager(&tile_manager_client);
- FakePictureLayerTilingClient client(&tile_manager);
+ FakePictureLayerTilingClient client;
scoped_ptr<TestablePictureLayerTiling> tiling;
gfx::Size device_viewport(800, 600);
@@ -1533,7 +1355,7 @@
gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
current_screen_transform, device_viewport);
- client.SetTileSize(gfx::Size(50, 50));
+ client.SetTileSize(gfx::Size(100, 100));
tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale
current_layer_bounds,
&client);
@@ -1568,20 +1390,20 @@
current_frame_time_in_seconds,
max_tiles_for_interest_area);
- ASSERT_TRUE(tiling->TileBundleAt(0, 0));
- ASSERT_TRUE(tiling->TileBundleAt(0, 1));
- ASSERT_TRUE(tiling->TileBundleAt(1, 0));
- ASSERT_TRUE(tiling->TileBundleAt(1, 1));
+ ASSERT_TRUE(tiling->TileAt(0, 0));
+ ASSERT_TRUE(tiling->TileAt(0, 1));
+ ASSERT_TRUE(tiling->TileAt(1, 0));
+ ASSERT_TRUE(tiling->TileAt(1, 1));
- TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
+ 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);
- priority = tiling->TileBundleAt(0, 1)->GetPriority(ACTIVE_TREE);
+ 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);
- priority = tiling->TileBundleAt(1, 0)->GetPriority(ACTIVE_TREE);
+ 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);
« no previous file with comments | « cc/resources/picture_layer_tiling_set_unittest.cc ('k') | cc/resources/prioritized_tile_set_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698