| // Copyright 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #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" |
| |
| 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) { |
| |
| gfx::Transform inverse; |
| if (!transform.GetInverse(&inverse)) |
| return gfx::Rect(); |
| |
| gfx::RectF viewport_in_layer_space = MathUtil::ProjectClippedRect( |
| inverse, gfx::RectF(gfx::Point(0, 0), device_viewport)); |
| |
| return ToEnclosingRect(viewport_in_layer_space); |
| } |
| |
| class TestablePictureLayerTiling : public PictureLayerTiling { |
| public: |
| using PictureLayerTiling::SetLiveTilesRect; |
| using PictureLayerTiling::TileAt; |
| using PictureLayerTiling::TileBundleAt; |
| |
| static scoped_ptr<TestablePictureLayerTiling> Create( |
| float contents_scale, |
| gfx::Size layer_bounds, |
| PictureLayerTilingClient* client) { |
| return make_scoped_ptr(new TestablePictureLayerTiling( |
| contents_scale, |
| layer_bounds, |
| 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, |
| PictureLayerTilingClient* client) |
| : PictureLayerTiling(contents_scale, layer_bounds, client) { } |
| }; |
| |
| class PictureLayerTilingIteratorTest : public testing::Test { |
| public: |
| PictureLayerTilingIteratorTest() |
| : tile_manager_(&tile_manager_client_), client_(&tile_manager_) {} |
| |
| virtual ~PictureLayerTilingIteratorTest() {} |
| |
| void Initialize(gfx::Size tile_size, |
| float contents_scale, |
| gfx::Size layer_bounds) { |
| client_.SetTileSize(tile_size); |
| tiling_ = TestablePictureLayerTiling::Create(contents_scale, |
| layer_bounds, |
| &client_); |
| } |
| |
| void SetLiveRectAndVerifyTiles(gfx::Rect live_tiles_rect) { |
| tiling_->SetTreeForTesting(ACTIVE_TREE); |
| tiling_->SetLiveTilesRect(live_tiles_rect); |
| |
| std::vector<Tile*> tiles = tiling_->AllTilesForTesting(); |
| for (std::vector<Tile*>::iterator iter = tiles.begin(); |
| iter != tiles.end(); |
| ++iter) { |
| EXPECT_TRUE(live_tiles_rect.Intersects((*iter)->content_rect())); |
| } |
| } |
| |
| void VerifyTilesExactlyCoverRect( |
| float rect_scale, |
| gfx::Rect request_rect, |
| gfx::Rect expect_rect) { |
| EXPECT_TRUE(request_rect.Contains(expect_rect)); |
| |
| // Iterators are not valid if this ratio is too large (i.e. the |
| // tiling is too high-res for a low-res destination rect.) This is an |
| // artifact of snapping geometry to integer coordinates and then mapping |
| // back to floating point texture coordinates. |
| float dest_to_contents_scale = tiling_->contents_scale() / rect_scale; |
| ASSERT_LE(dest_to_contents_scale, 2.0); |
| |
| Region remaining = expect_rect; |
| for (PictureLayerTiling::CoverageIterator |
| iter(tiling_.get(), rect_scale, request_rect); |
| iter; |
| ++iter) { |
| // Geometry cannot overlap previous geometry at all |
| gfx::Rect geometry = iter.geometry_rect(); |
| EXPECT_TRUE(expect_rect.Contains(geometry)); |
| EXPECT_TRUE(remaining.Contains(geometry)); |
| remaining.Subtract(geometry); |
| |
| // Sanity check that texture coords are within the texture rect. |
| gfx::RectF texture_rect = iter.texture_rect(); |
| EXPECT_GE(texture_rect.x(), 0); |
| EXPECT_GE(texture_rect.y(), 0); |
| EXPECT_LE(texture_rect.right(), client_.TileSize().width()); |
| EXPECT_LE(texture_rect.bottom(), client_.TileSize().height()); |
| |
| EXPECT_EQ(iter.texture_size(), client_.TileSize()); |
| } |
| |
| // The entire rect must be filled by geometry from the tiling. |
| EXPECT_TRUE(remaining.IsEmpty()); |
| } |
| |
| void VerifyTilesExactlyCoverRect(float rect_scale, gfx::Rect rect) { |
| VerifyTilesExactlyCoverRect(rect_scale, rect, rect); |
| } |
| |
| void VerifyTiles( |
| float rect_scale, |
| gfx::Rect rect, |
| base::Callback<void(Tile* tile, gfx::Rect geometry_rect)> callback) { |
| VerifyTiles(tiling_.get(), |
| rect_scale, |
| rect, |
| callback); |
| } |
| |
| void VerifyTiles( |
| PictureLayerTiling* tiling, |
| float rect_scale, |
| gfx::Rect rect, |
| base::Callback<void(Tile* tile, gfx::Rect geometry_rect)> callback) { |
| Region remaining = rect; |
| for (PictureLayerTiling::CoverageIterator iter(tiling, rect_scale, rect); |
| iter; |
| ++iter) { |
| remaining.Subtract(iter.geometry_rect()); |
| callback.Run(*iter, iter.geometry_rect()); |
| } |
| EXPECT_TRUE(remaining.IsEmpty()); |
| } |
| |
| void VerifyTilesCoverNonContainedRect(float rect_scale, gfx::Rect dest_rect) { |
| float dest_to_contents_scale = tiling_->contents_scale() / rect_scale; |
| gfx::Rect clamped_rect = gfx::ScaleToEnclosingRect( |
| tiling_->ContentRect(), 1.f / dest_to_contents_scale); |
| clamped_rect.Intersect(dest_rect); |
| VerifyTilesExactlyCoverRect(rect_scale, dest_rect, clamped_rect); |
| } |
| |
| protected: |
| FakeTileManagerClient tile_manager_client_; |
| FakeTileManager tile_manager_; |
| FakePictureLayerTilingClient client_; |
| scoped_ptr<TestablePictureLayerTiling> tiling_; |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(PictureLayerTilingIteratorTest); |
| }; |
| |
| TEST_F(PictureLayerTilingIteratorTest, LiveTilesExactlyCoverLiveTileRect) { |
| Initialize(gfx::Size(100, 100), 1, gfx::Size(1099, 801)); |
| SetLiveRectAndVerifyTiles(gfx::Rect(100, 100)); |
| SetLiveRectAndVerifyTiles(gfx::Rect(101, 99)); |
| SetLiveRectAndVerifyTiles(gfx::Rect(1099, 1)); |
| SetLiveRectAndVerifyTiles(gfx::Rect(1, 801)); |
| SetLiveRectAndVerifyTiles(gfx::Rect(1099, 1)); |
| SetLiveRectAndVerifyTiles(gfx::Rect(201, 800)); |
| } |
| |
| TEST_F(PictureLayerTilingIteratorTest, IteratorCoversLayerBoundsNoScale) { |
| Initialize(gfx::Size(100, 100), 1, gfx::Size(1099, 801)); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect()); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1099, 801)); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect(52, 83, 789, 412)); |
| |
| // With borders, a size of 3x3 = 1 pixel of content. |
| Initialize(gfx::Size(3, 3), 1, gfx::Size(10, 10)); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1, 1)); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 2, 2)); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect(1, 1, 2, 2)); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect(3, 2, 5, 2)); |
| } |
| |
| TEST_F(PictureLayerTilingIteratorTest, IteratorCoversLayerBoundsTilingScale) { |
| Initialize(gfx::Size(200, 100), 2.0f, gfx::Size(1005, 2010)); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect()); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1005, 2010)); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect(50, 112, 512, 381)); |
| |
| Initialize(gfx::Size(3, 3), 2.0f, gfx::Size(10, 10)); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect()); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1, 1)); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 2, 2)); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect(1, 1, 2, 2)); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect(3, 2, 5, 2)); |
| |
| Initialize(gfx::Size(100, 200), 0.5f, gfx::Size(1005, 2010)); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1005, 2010)); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect(50, 112, 512, 381)); |
| |
| Initialize(gfx::Size(150, 250), 0.37f, gfx::Size(1005, 2010)); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1005, 2010)); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect(50, 112, 512, 381)); |
| |
| Initialize(gfx::Size(312, 123), 0.01f, gfx::Size(1005, 2010)); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1005, 2010)); |
| VerifyTilesExactlyCoverRect(1, gfx::Rect(50, 112, 512, 381)); |
| } |
| |
| TEST_F(PictureLayerTilingIteratorTest, IteratorCoversLayerBoundsBothScale) { |
| Initialize(gfx::Size(50, 50), 4.0f, gfx::Size(800, 600)); |
| VerifyTilesExactlyCoverRect(2.0f, gfx::Rect()); |
| VerifyTilesExactlyCoverRect(2.0f, gfx::Rect(0, 0, 1600, 1200)); |
| VerifyTilesExactlyCoverRect(2.0f, gfx::Rect(512, 365, 253, 182)); |
| |
| float scale = 6.7f; |
| gfx::Size bounds(800, 600); |
| gfx::Rect full_rect(gfx::ToCeiledSize(gfx::ScaleSize(bounds, scale))); |
| Initialize(gfx::Size(256, 512), 5.2f, bounds); |
| VerifyTilesExactlyCoverRect(scale, full_rect); |
| VerifyTilesExactlyCoverRect(scale, gfx::Rect(2014, 1579, 867, 1033)); |
| } |
| |
| TEST_F(PictureLayerTilingIteratorTest, IteratorEmptyRect) { |
| Initialize(gfx::Size(100, 100), 1.0f, gfx::Size(800, 600)); |
| |
| gfx::Rect empty; |
| PictureLayerTiling::CoverageIterator iter(tiling_.get(), 1.0f, empty); |
| EXPECT_FALSE(iter); |
| } |
| |
| TEST_F(PictureLayerTilingIteratorTest, NonIntersectingRect) { |
| Initialize(gfx::Size(100, 100), 1.0f, gfx::Size(800, 600)); |
| gfx::Rect non_intersecting(1000, 1000, 50, 50); |
| PictureLayerTiling::CoverageIterator iter(tiling_.get(), 1, non_intersecting); |
| EXPECT_FALSE(iter); |
| } |
| |
| TEST_F(PictureLayerTilingIteratorTest, LayerEdgeTextureCoordinates) { |
| Initialize(gfx::Size(300, 300), 1.0f, gfx::Size(256, 256)); |
| // All of these sizes are 256x256, scaled and ceiled. |
| VerifyTilesExactlyCoverRect(1.0f, gfx::Rect(0, 0, 256, 256)); |
| VerifyTilesExactlyCoverRect(0.8f, gfx::Rect(0, 0, 205, 205)); |
| VerifyTilesExactlyCoverRect(1.2f, gfx::Rect(0, 0, 308, 308)); |
| } |
| |
| TEST_F(PictureLayerTilingIteratorTest, NonContainedDestRect) { |
| Initialize(gfx::Size(100, 100), 1.0f, gfx::Size(400, 400)); |
| |
| // Too large in all dimensions |
| VerifyTilesCoverNonContainedRect(1.0f, gfx::Rect(-1000, -1000, 2000, 2000)); |
| VerifyTilesCoverNonContainedRect(1.5f, gfx::Rect(-1000, -1000, 2000, 2000)); |
| VerifyTilesCoverNonContainedRect(0.5f, gfx::Rect(-1000, -1000, 2000, 2000)); |
| |
| // Partially covering content, but too large |
| VerifyTilesCoverNonContainedRect(1.0f, gfx::Rect(-1000, 100, 2000, 100)); |
| VerifyTilesCoverNonContainedRect(1.5f, gfx::Rect(-1000, 100, 2000, 100)); |
| 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, 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); |
| int64 target_area = 100 * 200; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_EQ(in.ToString(), out.ToString()); |
| } |
| |
| TEST(PictureLayerTilingTest, ExpandRectSmaller) { |
| gfx::Rect in(40, 50, 100, 200); |
| gfx::Rect bounds(-1000, -1000, 10000, 10000); |
| int64 target_area = 100 * 100; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y()); |
| EXPECT_EQ(out.right() - in.right(), in.x() - out.x()); |
| EXPECT_EQ(out.width() - in.width(), out.height() - in.height()); |
| EXPECT_NEAR(100 * 100, out.width() * out.height(), 50); |
| EXPECT_TRUE(bounds.Contains(out)); |
| } |
| |
| TEST(PictureLayerTilingTest, ExpandRectUnbounded) { |
| gfx::Rect in(40, 50, 100, 200); |
| gfx::Rect bounds(-1000, -1000, 10000, 10000); |
| int64 target_area = 200 * 200; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y()); |
| EXPECT_EQ(out.right() - in.right(), in.x() - out.x()); |
| EXPECT_EQ(out.width() - in.width(), out.height() - in.height()); |
| EXPECT_NEAR(200 * 200, out.width() * out.height(), 100); |
| EXPECT_TRUE(bounds.Contains(out)); |
| } |
| |
| TEST(PictureLayerTilingTest, ExpandRectBoundedSmaller) { |
| gfx::Rect in(40, 50, 100, 200); |
| gfx::Rect bounds(50, 60, 40, 30); |
| int64 target_area = 200 * 200; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_EQ(bounds.ToString(), out.ToString()); |
| } |
| |
| TEST(PictureLayerTilingTest, ExpandRectBoundedEqual) { |
| gfx::Rect in(40, 50, 100, 200); |
| gfx::Rect bounds = in; |
| int64 target_area = 200 * 200; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_EQ(bounds.ToString(), out.ToString()); |
| } |
| |
| TEST(PictureLayerTilingTest, ExpandRectBoundedSmallerStretchVertical) { |
| gfx::Rect in(40, 50, 100, 200); |
| gfx::Rect bounds(45, 0, 90, 300); |
| int64 target_area = 200 * 200; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_EQ(bounds.ToString(), out.ToString()); |
| } |
| |
| TEST(PictureLayerTilingTest, ExpandRectBoundedEqualStretchVertical) { |
| gfx::Rect in(40, 50, 100, 200); |
| gfx::Rect bounds(40, 0, 100, 300); |
| int64 target_area = 200 * 200; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_EQ(bounds.ToString(), out.ToString()); |
| } |
| |
| TEST(PictureLayerTilingTest, ExpandRectBoundedSmallerStretchHorizontal) { |
| gfx::Rect in(40, 50, 100, 200); |
| gfx::Rect bounds(0, 55, 180, 190); |
| int64 target_area = 200 * 200; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_EQ(bounds.ToString(), out.ToString()); |
| } |
| |
| TEST(PictureLayerTilingTest, ExpandRectBoundedEqualStretchHorizontal) { |
| gfx::Rect in(40, 50, 100, 200); |
| gfx::Rect bounds(0, 50, 180, 200); |
| int64 target_area = 200 * 200; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_EQ(bounds.ToString(), out.ToString()); |
| } |
| |
| TEST(PictureLayerTilingTest, ExpandRectBoundedLeft) { |
| gfx::Rect in(40, 50, 100, 200); |
| gfx::Rect bounds(20, -1000, 10000, 10000); |
| int64 target_area = 200 * 200; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y()); |
| EXPECT_EQ(out.bottom() - in.bottom(), out.right() - in.right()); |
| EXPECT_LE(out.width() * out.height(), target_area); |
| EXPECT_GT(out.width() * out.height(), |
| target_area - out.width() - out.height() * 2); |
| EXPECT_TRUE(bounds.Contains(out)); |
| } |
| |
| TEST(PictureLayerTilingTest, ExpandRectBoundedRight) { |
| gfx::Rect in(40, 50, 100, 200); |
| gfx::Rect bounds(-1000, -1000, 1000+120, 10000); |
| int64 target_area = 200 * 200; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y()); |
| EXPECT_EQ(out.bottom() - in.bottom(), in.x() - out.x()); |
| EXPECT_LE(out.width() * out.height(), target_area); |
| EXPECT_GT(out.width() * out.height(), |
| target_area - out.width() - out.height() * 2); |
| EXPECT_TRUE(bounds.Contains(out)); |
| } |
| |
| TEST(PictureLayerTilingTest, ExpandRectBoundedTop) { |
| gfx::Rect in(40, 50, 100, 200); |
| gfx::Rect bounds(-1000, 30, 10000, 10000); |
| int64 target_area = 200 * 200; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_EQ(out.right() - in.right(), in.x() - out.x()); |
| EXPECT_EQ(out.right() - in.right(), out.bottom() - in.bottom()); |
| EXPECT_LE(out.width() * out.height(), target_area); |
| EXPECT_GT(out.width() * out.height(), |
| target_area - out.width() * 2 - out.height()); |
| EXPECT_TRUE(bounds.Contains(out)); |
| } |
| |
| TEST(PictureLayerTilingTest, ExpandRectBoundedBottom) { |
| gfx::Rect in(40, 50, 100, 200); |
| gfx::Rect bounds(-1000, -1000, 10000, 1000 + 220); |
| int64 target_area = 200 * 200; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_EQ(out.right() - in.right(), in.x() - out.x()); |
| EXPECT_EQ(out.right() - in.right(), in.y() - out.y()); |
| EXPECT_LE(out.width() * out.height(), target_area); |
| EXPECT_GT(out.width() * out.height(), |
| target_area - out.width() * 2 - out.height()); |
| EXPECT_TRUE(bounds.Contains(out)); |
| } |
| |
| TEST(PictureLayerTilingTest, ExpandRectSquishedHorizontally) { |
| gfx::Rect in(40, 50, 100, 200); |
| gfx::Rect bounds(0, -4000, 100+40+20, 100000); |
| int64 target_area = 400 * 400; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_EQ(20, out.right() - in.right()); |
| EXPECT_EQ(40, in.x() - out.x()); |
| EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y()); |
| EXPECT_LE(out.width() * out.height(), target_area); |
| EXPECT_GT(out.width() * out.height(), |
| target_area - out.width() * 2); |
| EXPECT_TRUE(bounds.Contains(out)); |
| } |
| |
| TEST(PictureLayerTilingTest, ExpandRectSquishedVertically) { |
| gfx::Rect in(40, 50, 100, 200); |
| gfx::Rect bounds(-4000, 0, 100000, 200+50+30); |
| int64 target_area = 400 * 400; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_EQ(30, out.bottom() - in.bottom()); |
| EXPECT_EQ(50, in.y() - out.y()); |
| EXPECT_EQ(out.right() - in.right(), in.x() - out.x()); |
| EXPECT_LE(out.width() * out.height(), target_area); |
| EXPECT_GT(out.width() * out.height(), |
| target_area - out.height() * 2); |
| EXPECT_TRUE(bounds.Contains(out)); |
| } |
| |
| TEST(PictureLayerTilingTest, ExpandRectOutOfBoundsFarAway) { |
| gfx::Rect in(400, 500, 100, 200); |
| gfx::Rect bounds(0, 0, 10, 10); |
| int64 target_area = 400 * 400; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_TRUE(out.IsEmpty()); |
| } |
| |
| TEST(PictureLayerTilingTest, ExpandRectOutOfBoundsExpandedFullyCover) { |
| gfx::Rect in(40, 50, 100, 100); |
| gfx::Rect bounds(0, 0, 10, 10); |
| int64 target_area = 400 * 400; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_EQ(bounds.ToString(), out.ToString()); |
| } |
| |
| TEST(PictureLayerTilingTest, ExpandRectOutOfBoundsExpandedPartlyCover) { |
| gfx::Rect in(600, 600, 100, 100); |
| gfx::Rect bounds(0, 0, 500, 500); |
| int64 target_area = 400 * 400; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_EQ(bounds.right(), out.right()); |
| EXPECT_EQ(bounds.bottom(), out.bottom()); |
| EXPECT_LE(out.width() * out.height(), target_area); |
| EXPECT_GT(out.width() * out.height(), |
| target_area - out.width() - out.height()); |
| EXPECT_TRUE(bounds.Contains(out)); |
| } |
| |
| TEST(PictureLayerTilingTest, EmptyStartingRect) { |
| // If a layer has a non-invertible transform, then the starting rect |
| // for the layer would be empty. |
| gfx::Rect in(40, 40, 0, 0); |
| gfx::Rect bounds(0, 0, 10, 10); |
| int64 target_area = 400 * 400; |
| gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( |
| in, target_area, bounds, NULL); |
| EXPECT_TRUE(out.IsEmpty()); |
| } |
| |
| static void TileExists(bool exists, Tile* tile, gfx::Rect geometry_rect) { |
| EXPECT_EQ(exists, tile != NULL) << geometry_rect.ToString(); |
| } |
| |
| TEST_F(PictureLayerTilingIteratorTest, TilesExist) { |
| gfx::Size layer_bounds(1099, 801); |
| Initialize(gfx::Size(100, 100), 1.f, layer_bounds); |
| VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds)); |
| VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false)); |
| |
| 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)); |
| |
| // 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)); |
| } |
| |
| TEST_F(PictureLayerTilingIteratorTest, TilesExistGiantViewport) { |
| gfx::Size layer_bounds(1099, 801); |
| Initialize(gfx::Size(100, 100), 1.f, layer_bounds); |
| VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds)); |
| VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false)); |
| |
| gfx::Rect giant_rect(-10000000, -10000000, 1000000000, 1000000000); |
| |
| 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)); |
| |
| // 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)); |
| } |
| |
| TEST_F(PictureLayerTilingIteratorTest, TilesExistOutsideViewport) { |
| gfx::Size layer_bounds(1099, 801); |
| Initialize(gfx::Size(100, 100), 1.f, layer_bounds); |
| VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds)); |
| VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false)); |
| |
| // This rect does not intersect with the layer, as the layer is outside the |
| // viewport. |
| 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 |
| VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true)); |
| } |
| |
| static void TilesIntersectingRectExist(gfx::Rect rect, |
| bool intersect_exists, |
| Tile* tile, |
| gfx::Rect geometry_rect) { |
| bool intersects = rect.Intersects(geometry_rect); |
| bool expected_exists = intersect_exists ? intersects : !intersects; |
| EXPECT_EQ(expected_exists, tile != NULL) |
| << "Rects intersecting " << rect.ToString() << " should exist. " |
| << "Current tile rect is " << geometry_rect.ToString(); |
| } |
| |
| TEST_F(PictureLayerTilingIteratorTest, |
| TilesExistLargeViewportAndLayerWithSmallVisibleArea) { |
| gfx::Size layer_bounds(10000, 10000); |
| Initialize(gfx::Size(100, 100), 1.f, layer_bounds); |
| VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds)); |
| VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false)); |
| |
| gfx::Rect visible_rect(8000, 8000, 50, 50); |
| |
| 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, |
| gfx::Rect(layer_bounds), |
| base::Bind(&TilesIntersectingRectExist, visible_rect, true)); |
| } |
| |
| static void CountExistingTiles(int *count, |
| Tile* tile, |
| gfx::Rect geometry_rect) { |
| if (tile != NULL) |
| ++(*count); |
| } |
| |
| TEST_F(PictureLayerTilingIteratorTest, |
| TilesExistLargeViewportAndLayerWithLargeVisibleArea) { |
| gfx::Size layer_bounds(10000, 10000); |
| Initialize(gfx::Size(100, 100), 1.f, layer_bounds); |
| VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds)); |
| VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false)); |
| |
| 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 |
| |
| int num_tiles = 0; |
| VerifyTiles(1.f, |
| gfx::Rect(layer_bounds), |
| base::Bind(&CountExistingTiles, &num_tiles)); |
| // If we're making a rect the size of one tile, it can only overlap up to 4 |
| // tiles depending on its position. |
| EXPECT_LE(num_tiles, 4); |
| VerifyTiles(1.f, gfx::Rect(), base::Bind(&TileExists, false)); |
| } |
| |
| TEST_F(PictureLayerTilingIteratorTest, AddTilingsToMatchScale) { |
| gfx::Size layer_bounds(1099, 801); |
| gfx::Size tile_size(100, 100); |
| |
| client_.SetTileSize(tile_size); |
| |
| PictureLayerTilingSet active_set(&client_, layer_bounds); |
| |
| active_set.AddTiling(1.f); |
| |
| VerifyTiles(active_set.tiling_at(0), |
| 1.f, |
| gfx::Rect(layer_bounds), |
| base::Bind(&TileExists, false)); |
| |
| 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 |
| |
| // The active tiling has tiles now. |
| VerifyTiles(active_set.tiling_at(0), |
| 1.f, |
| gfx::Rect(layer_bounds), |
| base::Bind(&TileExists, true)); |
| |
| // Add the same tilings to the pending set. |
| PictureLayerTilingSet pending_set(&client_, layer_bounds); |
| Region invalidation; |
| pending_set.SyncTilings(active_set, layer_bounds, invalidation, 0.f); |
| |
| // The pending tiling starts with no tiles. |
| VerifyTiles(pending_set.tiling_at(0), |
| 1.f, |
| gfx::Rect(layer_bounds), |
| base::Bind(&TileExists, false)); |
| |
| // UpdateTilePriorities on the pending tiling at the same frame time. The |
| // 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 |
| |
| VerifyTiles(pending_set.tiling_at(0), |
| 1.f, |
| gfx::Rect(layer_bounds), |
| 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); |
| 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; |
| |
| gfx::Rect viewport_in_layer_space = ViewportInLayerSpace( |
| current_screen_transform, device_viewport); |
| |
| client.SetTileSize(gfx::Size(100, 100)); |
| tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale |
| 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); |
| |
| 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)); |
| |
| TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(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); |
| 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); |
| 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; |
| |
| current_screen_transform.Translate(850, 0); |
| last_screen_transform = current_screen_transform; |
| |
| gfx::Rect viewport_in_layer_space = ViewportInLayerSpace( |
| current_screen_transform, device_viewport); |
| |
| client.SetTileSize(gfx::Size(100, 100)); |
| tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale |
| 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); |
| |
| 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)); |
| |
| TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(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)); |
| |
| // Furthermore, in this scenario bundles 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); |
| 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); |
| EXPECT_GT(right.distance_to_visible_in_pixels, |
| left.distance_to_visible_in_pixels); |
| } |
| |
| TEST(UpdateTilePrioritiesTest, PartiallyOffscreenLayer) { |
| // 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); |
| 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); |
| 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; |
| |
| current_screen_transform.Translate(705, 505); |
| last_screen_transform = current_screen_transform; |
| |
| gfx::Rect viewport_in_layer_space = ViewportInLayerSpace( |
| current_screen_transform, device_viewport); |
| |
| client.SetTileSize(gfx::Size(100, 100)); |
| tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale |
| 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); |
| |
| 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)); |
| |
| TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(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); |
| 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); |
| 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); |
| EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); |
| EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), |
| priority.time_to_visible_in_seconds); |
| } |
| |
| TEST(UpdateTilePrioritiesTest, PartiallyOffscreenRotatedLayer) { |
| // Each tile of a layer may be affected differently by a transform; Check |
| // 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); |
| 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); |
| 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; |
| |
| // 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.RotateAboutZAxis(45); |
| last_screen_transform = current_screen_transform; |
| |
| gfx::Rect viewport_in_layer_space = ViewportInLayerSpace( |
| current_screen_transform, device_viewport); |
| |
| client.SetTileSize(gfx::Size(100, 100)); |
| tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale |
| 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); |
| |
| ASSERT_TRUE(tiling->TileBundleAt(0, 0)); |
| ASSERT_TRUE(tiling->TileBundleAt(0, 1)); |
| ASSERT_TRUE(tiling->TileBundleAt(1, 0)); |
| ASSERT_TRUE(tiling->TileBundleAt(1, 1)); |
| |
| TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(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); |
| 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); |
| 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); |
| 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); |
| 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); |
| } |
| |
| TEST(UpdateTilePrioritiesTest, PerspectiveLayer) { |
| // 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); |
| 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); |
| 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; |
| |
| // A 3d perspective layer rotated about its Y axis, translated to almost |
| // fully offscreen. The left side will appear closer (i.e. larger in 2d) than |
| // the right side, so the top-left tile will technically be closer than the |
| // top-right. |
| |
| // Translate layer to offscreen |
| current_screen_transform.Translate(400.0, 630.0); |
| // Apply perspective about the center of the layer |
| current_screen_transform.Translate(100.0, 100.0); |
| current_screen_transform.ApplyPerspectiveDepth(100.0); |
| current_screen_transform.RotateAboutYAxis(10.0); |
| current_screen_transform.Translate(-100.0, -100.0); |
| last_screen_transform = current_screen_transform; |
| |
| // Sanity check that this transform wouldn't cause w<0 clipping. |
| bool clipped; |
| MathUtil::MapQuad(current_screen_transform, |
| gfx::QuadF(gfx::RectF(0, 0, 200, 200)), |
| &clipped); |
| ASSERT_FALSE(clipped); |
| |
| gfx::Rect viewport_in_layer_space = ViewportInLayerSpace( |
| current_screen_transform, device_viewport); |
| |
| client.SetTileSize(gfx::Size(100, 100)); |
| tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale |
| 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); |
| |
| ASSERT_TRUE(tiling->TileBundleAt(0, 0)); |
| ASSERT_TRUE(tiling->TileBundleAt(0, 1)); |
| ASSERT_TRUE(tiling->TileBundleAt(1, 0)); |
| ASSERT_TRUE(tiling->TileBundleAt(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); |
| 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); |
| 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); |
| 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); |
| 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 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); |
| 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_left.distance_to_visible_in_pixels, |
| top_left.distance_to_visible_in_pixels); |
| } |
| |
| TEST(UpdateTilePrioritiesTest, PerspectiveLayerClippedByW) { |
| // 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); |
| 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); |
| 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; |
| |
| // A 3d perspective layer rotated about its Y axis, translated to almost |
| // fully offscreen. The left side will appear closer (i.e. larger in 2d) than |
| // the right side, so the top-left tile will technically be closer than the |
| // top-right. |
| |
| // 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.ApplyPerspectiveDepth(10.0); |
| current_screen_transform.RotateAboutYAxis(10.0); |
| current_screen_transform.Translate(-200.0, -200.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)), |
| &clipped); |
| ASSERT_TRUE(clipped); |
| |
| MathUtil::MapQuad(current_screen_transform, |
| gfx::QuadF(gfx::RectF(200, 0, 200, 400)), |
| &clipped); |
| ASSERT_FALSE(clipped); |
| |
| gfx::Rect viewport_in_layer_space = ViewportInLayerSpace( |
| current_screen_transform, device_viewport); |
| |
| client.SetTileSize(gfx::Size(100, 100)); |
| tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale |
| 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); |
| |
| ASSERT_TRUE(tiling->TileBundleAt(0, 0)); |
| ASSERT_TRUE(tiling->TileBundleAt(0, 1)); |
| ASSERT_TRUE(tiling->TileBundleAt(1, 0)); |
| ASSERT_TRUE(tiling->TileBundleAt(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); |
| 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); |
| 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); |
| 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); |
| EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); |
| EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), |
| priority.time_to_visible_in_seconds); |
| } |
| |
| TEST(UpdateTilePrioritiesTest, BasicMotion) { |
| // 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); |
| scoped_ptr<TestablePictureLayerTiling> tiling; |
| |
| gfx::Size device_viewport(800, 600); |
| gfx::Rect visible_layer_rect(0, 0, 0, 0); |
| 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 last_frame_time_in_seconds = 1.0; |
| double current_frame_time_in_seconds = 2.0; |
| size_t max_tiles_for_interest_area = 10000; |
| |
| // Offscreen layer is coming closer to viewport at 1000 pixels per second. |
| current_screen_transform.Translate(1800, 0); |
| last_screen_transform.Translate(2800, 0); |
| |
| gfx::Rect viewport_in_layer_space = ViewportInLayerSpace( |
| current_screen_transform, device_viewport); |
| |
| client.SetTileSize(gfx::Size(50, 50)); |
| tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale |
| current_layer_bounds, |
| &client); |
| |
| // 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); |
| |
| ASSERT_TRUE(tiling->TileBundleAt(0, 0)); |
| ASSERT_TRUE(tiling->TileBundleAt(0, 1)); |
| ASSERT_TRUE(tiling->TileBundleAt(1, 0)); |
| ASSERT_TRUE(tiling->TileBundleAt(1, 1)); |
| |
| TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(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); |
| 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); |
| EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); |
| EXPECT_FLOAT_EQ(1.097f, |
| priority.time_to_visible_in_seconds); |
| |
| priority = tiling->TileBundleAt(1, 1)->GetPriority(ACTIVE_TREE); |
| EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); |
| EXPECT_FLOAT_EQ(1.097f, |
| priority.time_to_visible_in_seconds); |
| } |
| |
| TEST(UpdateTilePrioritiesTest, RotationMotion) { |
| // Each tile of a layer may be affected differently by a transform; Check |
| // 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); |
| scoped_ptr<TestablePictureLayerTiling> tiling; |
| |
| gfx::Size device_viewport(800, 600); |
| gfx::Rect visible_layer_rect(0, 0, 0, 0); // offscren. |
| 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 last_frame_time_in_seconds = 1.0; |
| double current_frame_time_in_seconds = 2.0; |
| size_t max_tiles_for_interest_area = 10000; |
| |
| // Rotation motion is set up specifically so that: |
| // - rotation occurs about the center of the layer |
| // - the top-left tile becomes visible on rotation |
| // - the top-right tile will have an infinite time_to_visible |
| // because it is rotating away from viewport. |
| // - bottom-left layer will have a positive non-zero time_to_visible |
| // because it is rotating toward the viewport. |
| current_screen_transform.Translate(400, 550); |
| current_screen_transform.RotateAboutZAxis(45); |
| |
| last_screen_transform.Translate(400, 550); |
| |
| gfx::Rect viewport_in_layer_space = ViewportInLayerSpace( |
| current_screen_transform, device_viewport); |
| |
| client.SetTileSize(gfx::Size(50, 50)); |
| tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale |
| current_layer_bounds, |
| &client); |
| |
| // 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); |
| |
| ASSERT_TRUE(tiling->TileBundleAt(0, 0)); |
| ASSERT_TRUE(tiling->TileBundleAt(0, 1)); |
| ASSERT_TRUE(tiling->TileBundleAt(1, 0)); |
| ASSERT_TRUE(tiling->TileBundleAt(1, 1)); |
| |
| TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(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); |
| 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); |
| EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); |
| EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), |
| priority.time_to_visible_in_seconds); |
| } |
| |
| } // namespace |
| } // namespace cc |
