| Index: cc/layers/picture_layer_impl_unittest.cc
|
| diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
|
| index 90a36f7a99881a3ccf5478ed71fa9b2cbeceb23c..7c7c899ff724ba96dfc26eba5712372059ee795d 100644
|
| --- a/cc/layers/picture_layer_impl_unittest.cc
|
| +++ b/cc/layers/picture_layer_impl_unittest.cc
|
| @@ -34,6 +34,18 @@
|
| namespace cc {
|
| namespace {
|
|
|
| +#define EXPECT_BOTH_EQ(expression, x) \
|
| + do { \
|
| + EXPECT_EQ(x, pending_layer_->expression); \
|
| + EXPECT_EQ(x, active_layer_->expression); \
|
| + } while (false)
|
| +
|
| +#define EXPECT_BOTH_NE(expression, x) \
|
| + do { \
|
| + EXPECT_NE(x, pending_layer_->expression); \
|
| + EXPECT_NE(x, active_layer_->expression); \
|
| + } while (false)
|
| +
|
| class MockCanvas : public SkCanvas {
|
| public:
|
| explicit MockCanvas(int w, int h) : SkCanvas(w, h) {}
|
| @@ -58,15 +70,21 @@ class PictureLayerImplTest : public testing::Test {
|
| PictureLayerImplTest()
|
| : proxy_(base::MessageLoopProxy::current()),
|
| host_impl_(LowResTilingsSettings(), &proxy_, &shared_bitmap_manager_),
|
| + root_id_(6),
|
| id_(7),
|
| pending_layer_(nullptr),
|
| old_pending_layer_(nullptr),
|
| - active_layer_(nullptr) {}
|
| + active_layer_(nullptr) {
|
| + host_impl_.SetViewportSize(gfx::Size(10000, 10000));
|
| + }
|
|
|
| explicit PictureLayerImplTest(const LayerTreeSettings& settings)
|
| : proxy_(base::MessageLoopProxy::current()),
|
| host_impl_(settings, &proxy_, &shared_bitmap_manager_),
|
| - id_(7) {}
|
| + root_id_(6),
|
| + id_(7) {
|
| + host_impl_.SetViewportSize(gfx::Size(10000, 10000));
|
| + }
|
|
|
| virtual ~PictureLayerImplTest() {
|
| }
|
| @@ -88,6 +106,18 @@ class PictureLayerImplTest : public testing::Test {
|
| SetupTrees(pending_pile, active_pile);
|
| }
|
|
|
| + void SetupDefaultTreesWithInvalidation(const gfx::Size& layer_bounds,
|
| + const Region& invalidation) {
|
| + gfx::Size tile_size(100, 100);
|
| +
|
| + scoped_refptr<FakePicturePileImpl> pending_pile =
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| + scoped_refptr<FakePicturePileImpl> active_pile =
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| +
|
| + SetupTreesWithInvalidation(pending_pile, active_pile, invalidation);
|
| + }
|
| +
|
| void ActivateTree() {
|
| host_impl_.ActivateSyncTree();
|
| CHECK(!host_impl_.pending_tree());
|
| @@ -96,13 +126,22 @@ class PictureLayerImplTest : public testing::Test {
|
| pending_layer_ = nullptr;
|
| active_layer_ = static_cast<FakePictureLayerImpl*>(
|
| host_impl_.active_tree()->LayerById(id_));
|
| +
|
| + host_impl_.active_tree()->UpdateDrawProperties();
|
| }
|
|
|
| void SetupDefaultTreesWithFixedTileSize(const gfx::Size& layer_bounds,
|
| - const gfx::Size& tile_size) {
|
| - SetupDefaultTrees(layer_bounds);
|
| - pending_layer_->set_fixed_tile_size(tile_size);
|
| - active_layer_->set_fixed_tile_size(tile_size);
|
| + const gfx::Size& tile_size,
|
| + const Region& invalidation) {
|
| + gfx::Size pile_tile_size(100, 100);
|
| +
|
| + scoped_refptr<FakePicturePileImpl> pending_pile =
|
| + FakePicturePileImpl::CreateFilledPile(pile_tile_size, layer_bounds);
|
| + scoped_refptr<FakePicturePileImpl> active_pile =
|
| + FakePicturePileImpl::CreateFilledPile(pile_tile_size, layer_bounds);
|
| +
|
| + SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size,
|
| + invalidation);
|
| }
|
|
|
| void SetupTrees(
|
| @@ -110,54 +149,80 @@ class PictureLayerImplTest : public testing::Test {
|
| scoped_refptr<PicturePileImpl> active_pile) {
|
| SetupPendingTree(active_pile);
|
| ActivateTree();
|
| - SetupPendingTree(pending_pile);
|
| + SetupPendingTreeInternal(pending_pile, gfx::Size(), Region());
|
| }
|
|
|
| - void CreateHighLowResAndSetAllTilesVisible() {
|
| - // Active layer must get updated first so pending layer can share from it.
|
| - active_layer_->CreateDefaultTilingsAndTiles();
|
| - active_layer_->SetAllTilesVisible();
|
| - pending_layer_->CreateDefaultTilingsAndTiles();
|
| - pending_layer_->SetAllTilesVisible();
|
| + void SetupTreesWithInvalidation(scoped_refptr<PicturePileImpl> pending_pile,
|
| + scoped_refptr<PicturePileImpl> active_pile,
|
| + const Region& pending_invalidation) {
|
| + SetupPendingTreeInternal(active_pile, gfx::Size(), Region());
|
| + ActivateTree();
|
| + SetupPendingTreeInternal(pending_pile, gfx::Size(), pending_invalidation);
|
| }
|
|
|
| - void AddDefaultTilingsWithInvalidation(const Region& invalidation) {
|
| - active_layer_->AddTiling(2.3f);
|
| - active_layer_->AddTiling(1.0f);
|
| - active_layer_->AddTiling(0.5f);
|
| - for (size_t i = 0; i < active_layer_->tilings()->num_tilings(); ++i)
|
| - active_layer_->tilings()->tiling_at(i)->CreateAllTilesForTesting();
|
| - pending_layer_->set_invalidation(invalidation);
|
| - for (size_t i = 0; i < pending_layer_->tilings()->num_tilings(); ++i)
|
| - pending_layer_->tilings()->tiling_at(i)->CreateAllTilesForTesting();
|
| + void SetupTreesWithFixedTileSize(scoped_refptr<PicturePileImpl> pending_pile,
|
| + scoped_refptr<PicturePileImpl> active_pile,
|
| + const gfx::Size& tile_size,
|
| + const Region& pending_invalidation) {
|
| + SetupPendingTreeInternal(active_pile, tile_size, Region());
|
| + ActivateTree();
|
| + SetupPendingTreeInternal(pending_pile, tile_size, pending_invalidation);
|
| }
|
|
|
| void SetupPendingTree(scoped_refptr<RasterSource> raster_source) {
|
| + SetupPendingTreeInternal(raster_source, gfx::Size(), Region());
|
| + }
|
| +
|
| + void SetupPendingTreeWithInvalidation(
|
| + scoped_refptr<RasterSource> raster_source,
|
| + const Region& invalidation) {
|
| + SetupPendingTreeInternal(raster_source, gfx::Size(), invalidation);
|
| + }
|
| +
|
| + void SetupPendingTreeWithFixedTileSize(
|
| + scoped_refptr<RasterSource> raster_source,
|
| + const gfx::Size& tile_size,
|
| + const Region& invalidation) {
|
| + SetupPendingTreeInternal(raster_source, tile_size, invalidation);
|
| + }
|
| +
|
| + void SetupPendingTreeInternal(scoped_refptr<RasterSource> raster_source,
|
| + const gfx::Size& tile_size,
|
| + const Region& invalidation) {
|
| host_impl_.CreatePendingTree();
|
| host_impl_.pending_tree()->PushPageScaleFromMainThread(1.f, 0.25f, 100.f);
|
| LayerTreeImpl* pending_tree = host_impl_.pending_tree();
|
|
|
| - // Steal from the recycled tree.
|
| - scoped_ptr<LayerImpl> old_pending_root = pending_tree->DetachLayerTree();
|
| - DCHECK_IMPLIES(old_pending_root, old_pending_root->id() == id_);
|
| -
|
| + // Steal from the recycled tree if possible.
|
| + scoped_ptr<LayerImpl> pending_root = pending_tree->DetachLayerTree();
|
| scoped_ptr<FakePictureLayerImpl> pending_layer;
|
| - if (old_pending_root) {
|
| - pending_layer.reset(
|
| - static_cast<FakePictureLayerImpl*>(old_pending_root.release()));
|
| - pending_layer->SetRasterSource(raster_source);
|
| - } else {
|
| - pending_layer = FakePictureLayerImpl::CreateWithRasterSource(
|
| - pending_tree, id_, raster_source);
|
| + DCHECK_IMPLIES(pending_root, pending_root->id() == root_id_);
|
| + if (!pending_root) {
|
| + pending_root = LayerImpl::Create(pending_tree, root_id_);
|
| + pending_layer = FakePictureLayerImpl::Create(pending_tree, id_);
|
| + if (!tile_size.IsEmpty())
|
| + pending_layer->set_fixed_tile_size(tile_size);
|
| pending_layer->SetDrawsContent(true);
|
| + } else {
|
| + pending_layer.reset(static_cast<FakePictureLayerImpl*>(
|
| + pending_root->RemoveChild(pending_root->children()[0]).release()));
|
| + if (!tile_size.IsEmpty())
|
| + pending_layer->set_fixed_tile_size(tile_size);
|
| }
|
| // The bounds() just mirror the pile size.
|
| - pending_layer->SetBounds(pending_layer->raster_source()->GetSize());
|
| - pending_tree->SetRootLayer(pending_layer.Pass());
|
| + pending_layer->SetBounds(raster_source->GetSize());
|
| + pending_layer->SetContentBounds(raster_source->GetSize());
|
| + pending_layer->SetRasterSourceOnPending(raster_source, invalidation);
|
| +
|
| + pending_root->AddChild(pending_layer.Pass());
|
| + pending_tree->SetRootLayer(pending_root.Pass());
|
|
|
| pending_layer_ = static_cast<FakePictureLayerImpl*>(
|
| host_impl_.pending_tree()->LayerById(id_));
|
| pending_layer_->DoPostCommitInitializationIfNeeded();
|
| +
|
| + // Add tilings/tiles for the layer.
|
| + host_impl_.pending_tree()->UpdateDrawProperties();
|
| }
|
|
|
| void SetupDrawPropertiesAndUpdateTiles(FakePictureLayerImpl* layer,
|
| @@ -213,6 +278,10 @@ class PictureLayerImplTest : public testing::Test {
|
| void ResetTilingsAndRasterScales() {
|
| pending_layer_->ReleaseResources();
|
| active_layer_->ReleaseResources();
|
| + if (pending_layer_)
|
| + EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
|
| + if (active_layer_)
|
| + EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
|
| }
|
|
|
| void AssertAllTilesRequired(PictureLayerTiling* tiling) {
|
| @@ -230,60 +299,12 @@ class PictureLayerImplTest : public testing::Test {
|
| }
|
|
|
| protected:
|
| - void TestTileGridAlignmentCommon() {
|
| - // Layer to span 4 raster tiles in x and in y
|
| - ImplSidePaintingSettings settings;
|
| - gfx::Size layer_size(
|
| - settings.default_tile_size.width() * 7 / 2,
|
| - settings.default_tile_size.height() * 7 / 2);
|
| -
|
| - scoped_refptr<FakePicturePileImpl> pending_pile =
|
| - FakePicturePileImpl::CreateFilledPile(layer_size, layer_size);
|
| - scoped_refptr<FakePicturePileImpl> active_pile =
|
| - FakePicturePileImpl::CreateFilledPile(layer_size, layer_size);
|
| -
|
| - SetupTrees(pending_pile, active_pile);
|
| -
|
| - SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
|
| -
|
| - // Add 1x1 rects at the centers of each tile, then re-record pile contents
|
| - active_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
|
| - std::vector<Tile*> tiles =
|
| - active_layer_->tilings()->tiling_at(0)->AllTilesForTesting();
|
| - EXPECT_EQ(16u, tiles.size());
|
| - std::vector<SkRect> rects;
|
| - std::vector<Tile*>::const_iterator tile_iter;
|
| - for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
|
| - gfx::Point tile_center = (*tile_iter)->content_rect().CenterPoint();
|
| - gfx::Rect rect(tile_center.x(), tile_center.y(), 1, 1);
|
| - active_pile->add_draw_rect(rect);
|
| - rects.push_back(SkRect::MakeXYWH(rect.x(), rect.y(), 1, 1));
|
| - }
|
| - // Force re-record with newly injected content
|
| - active_pile->RemoveRecordingAt(0, 0);
|
| - active_pile->AddRecordingAt(0, 0);
|
| -
|
| - std::vector<SkRect>::const_iterator rect_iter = rects.begin();
|
| - for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
|
| - MockCanvas mock_canvas(1000, 1000);
|
| - active_pile->PlaybackToSharedCanvas(&mock_canvas,
|
| - (*tile_iter)->content_rect(), 1.0f);
|
| -
|
| - // This test verifies that when drawing the contents of a specific tile
|
| - // at content scale 1.0, the playback canvas never receives content from
|
| - // neighboring tiles which indicates that the tile grid embedded in
|
| - // SkPicture is perfectly aligned with the compositor's tiles.
|
| - EXPECT_EQ(1u, mock_canvas.rects_.size());
|
| - EXPECT_EQ(*rect_iter, mock_canvas.rects_[0]);
|
| - rect_iter++;
|
| - }
|
| - }
|
| -
|
| void TestQuadsForSolidColor(bool test_for_solid);
|
|
|
| FakeImplProxy proxy_;
|
| TestSharedBitmapManager shared_bitmap_manager_;
|
| FakeLayerTreeHostImpl host_impl_;
|
| + int root_id_;
|
| int id_;
|
| FakePictureLayerImpl* pending_layer_;
|
| FakePictureLayerImpl* old_pending_layer_;
|
| @@ -293,14 +314,56 @@ class PictureLayerImplTest : public testing::Test {
|
| DISALLOW_COPY_AND_ASSIGN(PictureLayerImplTest);
|
| };
|
|
|
| +class NoLowResPictureLayerImplTest : public PictureLayerImplTest {
|
| + public:
|
| + NoLowResPictureLayerImplTest()
|
| + : PictureLayerImplTest(NoLowResTilingsSettings()) {}
|
| +};
|
| +
|
| TEST_F(PictureLayerImplTest, TileGridAlignment) {
|
| - host_impl_.SetDeviceScaleFactor(1.f);
|
| - TestTileGridAlignmentCommon();
|
| -}
|
| + // Layer to span 4 raster tiles in x and in y
|
| + ImplSidePaintingSettings settings;
|
| + gfx::Size layer_size(settings.default_tile_size.width() * 7 / 2,
|
| + settings.default_tile_size.height() * 7 / 2);
|
|
|
| -TEST_F(PictureLayerImplTest, TileGridAlignmentHiDPI) {
|
| - host_impl_.SetDeviceScaleFactor(2.f);
|
| - TestTileGridAlignmentCommon();
|
| + scoped_refptr<FakePicturePileImpl> pending_pile =
|
| + FakePicturePileImpl::CreateFilledPile(layer_size, layer_size);
|
| + scoped_refptr<FakePicturePileImpl> active_pile =
|
| + FakePicturePileImpl::CreateFilledPile(layer_size, layer_size);
|
| +
|
| + SetupTrees(pending_pile, active_pile);
|
| +
|
| + // Add 1x1 rects at the centers of each tile, then re-record pile contents
|
| + active_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
|
| + std::vector<Tile*> tiles =
|
| + active_layer_->tilings()->tiling_at(0)->AllTilesForTesting();
|
| + EXPECT_EQ(16u, tiles.size());
|
| + std::vector<SkRect> rects;
|
| + std::vector<Tile*>::const_iterator tile_iter;
|
| + for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
|
| + gfx::Point tile_center = (*tile_iter)->content_rect().CenterPoint();
|
| + gfx::Rect rect(tile_center.x(), tile_center.y(), 1, 1);
|
| + active_pile->add_draw_rect(rect);
|
| + rects.push_back(SkRect::MakeXYWH(rect.x(), rect.y(), 1, 1));
|
| + }
|
| + // Force re-raster with newly injected content
|
| + active_pile->RemoveRecordingAt(0, 0);
|
| + active_pile->AddRecordingAt(0, 0);
|
| +
|
| + std::vector<SkRect>::const_iterator rect_iter = rects.begin();
|
| + for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
|
| + MockCanvas mock_canvas(1000, 1000);
|
| + active_pile->PlaybackToSharedCanvas(&mock_canvas,
|
| + (*tile_iter)->content_rect(), 1.0f);
|
| +
|
| + // This test verifies that when drawing the contents of a specific tile
|
| + // at content scale 1.0, the playback canvas never receives content from
|
| + // neighboring tiles which indicates that the tile grid embedded in
|
| + // SkPicture is perfectly aligned with the compositor's tiles.
|
| + EXPECT_EQ(1u, mock_canvas.rects_.size());
|
| + EXPECT_EQ(*rect_iter, mock_canvas.rects_[0]);
|
| + rect_iter++;
|
| + }
|
| }
|
|
|
| TEST_F(PictureLayerImplTest, CloneNoInvalidation) {
|
| @@ -312,10 +375,7 @@ TEST_F(PictureLayerImplTest, CloneNoInvalidation) {
|
| scoped_refptr<FakePicturePileImpl> active_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| - SetupTrees(pending_pile, active_pile);
|
| -
|
| - Region invalidation;
|
| - AddDefaultTilingsWithInvalidation(invalidation);
|
| + SetupTreesWithInvalidation(pending_pile, active_pile, Region());
|
|
|
| EXPECT_EQ(pending_layer_->tilings()->num_tilings(),
|
| active_layer_->tilings()->num_tilings());
|
| @@ -323,7 +383,7 @@ TEST_F(PictureLayerImplTest, CloneNoInvalidation) {
|
| const PictureLayerTilingSet* tilings = pending_layer_->tilings();
|
| EXPECT_GT(tilings->num_tilings(), 0u);
|
| for (size_t i = 0; i < tilings->num_tilings(); ++i)
|
| - VerifyAllTilesExistAndHavePile(tilings->tiling_at(i), active_pile.get());
|
| + VerifyAllTilesExistAndHavePile(tilings->tiling_at(i), pending_pile.get());
|
| }
|
|
|
| TEST_F(PictureLayerImplTest, ExternalViewportRectForPrioritizingTiles) {
|
| @@ -339,10 +399,8 @@ TEST_F(PictureLayerImplTest, ExternalViewportRectForPrioritizingTiles) {
|
| scoped_refptr<FakePicturePileImpl> active_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| - SetupTrees(pending_pile, active_pile);
|
| + SetupTreesWithInvalidation(pending_pile, active_pile, Region());
|
|
|
| - Region invalidation;
|
| - AddDefaultTilingsWithInvalidation(invalidation);
|
| SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
|
|
|
| time_ticks += base::TimeDelta::FromMilliseconds(200);
|
| @@ -436,10 +494,8 @@ TEST_F(PictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
|
| scoped_refptr<FakePicturePileImpl> active_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| - SetupTrees(pending_pile, active_pile);
|
| + SetupTreesWithInvalidation(pending_pile, active_pile, Region());
|
|
|
| - Region invalidation;
|
| - AddDefaultTilingsWithInvalidation(invalidation);
|
| SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
|
|
|
| // UpdateTiles with valid viewport. Should update tile viewport.
|
| @@ -516,11 +572,20 @@ TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| scoped_refptr<FakePicturePileImpl> active_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| + scoped_refptr<FakePicturePileImpl> lost_pile =
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| - SetupTrees(pending_pile, active_pile);
|
| + SetupPendingTreeWithFixedTileSize(lost_pile, gfx::Size(50, 50), Region());
|
| + ActivateTree();
|
| + // Add a non-shared tiling on the active tree.
|
| + PictureLayerTiling* tiling = active_layer_->AddTiling(3.f);
|
| + tiling->CreateAllTilesForTesting();
|
| + // Then setup a new pending tree and activate it.
|
| + SetupTreesWithFixedTileSize(pending_pile, active_pile, gfx::Size(50, 50),
|
| + layer_invalidation);
|
|
|
| - Region invalidation(layer_invalidation);
|
| - AddDefaultTilingsWithInvalidation(invalidation);
|
| + EXPECT_EQ(2u, pending_layer_->num_tilings());
|
| + EXPECT_EQ(3u, active_layer_->num_tilings());
|
|
|
| const PictureLayerTilingSet* tilings = pending_layer_->tilings();
|
| EXPECT_GT(tilings->num_tilings(), 0u);
|
| @@ -537,61 +602,16 @@ TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
|
| ++iter) {
|
| EXPECT_TRUE(*iter);
|
| EXPECT_FALSE(iter.geometry_rect().IsEmpty());
|
| - if (iter.geometry_rect().Intersects(content_invalidation))
|
| - EXPECT_EQ(pending_pile.get(), iter->raster_source());
|
| - else
|
| - EXPECT_EQ(active_pile.get(), iter->raster_source());
|
| + EXPECT_EQ(pending_pile.get(), iter->raster_source());
|
| }
|
| }
|
| -}
|
| -
|
| -TEST_F(PictureLayerImplTest, CloneFullInvalidation) {
|
| - gfx::Size tile_size(90, 80);
|
| - gfx::Size layer_bounds(300, 500);
|
| -
|
| - scoped_refptr<FakePicturePileImpl> pending_pile =
|
| - FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| - scoped_refptr<FakePicturePileImpl> active_pile =
|
| - FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| -
|
| - SetupTrees(pending_pile, active_pile);
|
| -
|
| - Region invalidation((gfx::Rect(layer_bounds)));
|
| - AddDefaultTilingsWithInvalidation(invalidation);
|
| -
|
| - EXPECT_EQ(pending_layer_->tilings()->num_tilings(),
|
| - active_layer_->tilings()->num_tilings());
|
| -
|
| - const PictureLayerTilingSet* tilings = pending_layer_->tilings();
|
| - EXPECT_GT(tilings->num_tilings(), 0u);
|
| - for (size_t i = 0; i < tilings->num_tilings(); ++i)
|
| - VerifyAllTilesExistAndHavePile(tilings->tiling_at(i), pending_pile.get());
|
| -}
|
| -
|
| -TEST_F(PictureLayerImplTest, NoInvalidationBoundsChange) {
|
| - gfx::Size tile_size(90, 80);
|
| - gfx::Size active_layer_bounds(300, 500);
|
| - gfx::Size pending_layer_bounds(400, 800);
|
| -
|
| - scoped_refptr<FakePicturePileImpl> pending_pile =
|
| - FakePicturePileImpl::CreateFilledPile(tile_size,
|
| - pending_layer_bounds);
|
| - scoped_refptr<FakePicturePileImpl> active_pile =
|
| - FakePicturePileImpl::CreateFilledPile(tile_size, active_layer_bounds);
|
| -
|
| - SetupTrees(pending_pile, active_pile);
|
| - pending_layer_->set_fixed_tile_size(gfx::Size(100, 100));
|
| -
|
| - Region invalidation;
|
| - AddDefaultTilingsWithInvalidation(invalidation);
|
|
|
| - const PictureLayerTilingSet* tilings = pending_layer_->tilings();
|
| + tilings = active_layer_->tilings();
|
| EXPECT_GT(tilings->num_tilings(), 0u);
|
| for (size_t i = 0; i < tilings->num_tilings(); ++i) {
|
| const PictureLayerTiling* tiling = tilings->tiling_at(i);
|
| - gfx::Rect active_content_bounds = gfx::ScaleToEnclosingRect(
|
| - gfx::Rect(active_layer_bounds),
|
| - tiling->contents_scale());
|
| + gfx::Rect content_invalidation =
|
| + gfx::ScaleToEnclosingRect(layer_invalidation, tiling->contents_scale());
|
| for (PictureLayerTiling::CoverageIterator iter(
|
| tiling,
|
| tiling->contents_scale(),
|
| @@ -600,94 +620,108 @@ TEST_F(PictureLayerImplTest, NoInvalidationBoundsChange) {
|
| ++iter) {
|
| EXPECT_TRUE(*iter);
|
| EXPECT_FALSE(iter.geometry_rect().IsEmpty());
|
| - std::vector<Tile*> active_tiles =
|
| - active_layer_->tilings()->tiling_at(i)->AllTilesForTesting();
|
| - std::vector<Tile*> pending_tiles = tiling->AllTilesForTesting();
|
| - if (iter.geometry_rect().right() >= active_content_bounds.width() ||
|
| - iter.geometry_rect().bottom() >= active_content_bounds.height() ||
|
| - active_tiles[0]->content_rect().size() !=
|
| - pending_tiles[0]->content_rect().size()) {
|
| - EXPECT_EQ(pending_pile.get(), iter->raster_source());
|
| - } else {
|
| + if (iter.geometry_rect().Intersects(content_invalidation))
|
| EXPECT_EQ(active_pile.get(), iter->raster_source());
|
| - }
|
| + else if (!active_layer_->GetPendingOrActiveTwinTiling(tiling))
|
| + EXPECT_EQ(active_pile.get(), iter->raster_source());
|
| + else
|
| + EXPECT_EQ(pending_pile.get(), iter->raster_source());
|
| }
|
| }
|
| }
|
|
|
| -TEST_F(PictureLayerImplTest, AddTilesFromNewRecording) {
|
| - gfx::Size tile_size(400, 400);
|
| - gfx::Size layer_bounds(1300, 1900);
|
| +TEST_F(PictureLayerImplTest, CloneFullInvalidation) {
|
| + gfx::Size tile_size(90, 80);
|
| + gfx::Size layer_bounds(300, 500);
|
|
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| - FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| scoped_refptr<FakePicturePileImpl> active_pile =
|
| - FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| - // Fill in some of active pile, but more of pending pile.
|
| - int hole_count = 0;
|
| - for (int x = 0; x < active_pile->tiling().num_tiles_x(); ++x) {
|
| - for (int y = 0; y < active_pile->tiling().num_tiles_y(); ++y) {
|
| - if ((x + y) % 2) {
|
| - pending_pile->AddRecordingAt(x, y);
|
| - active_pile->AddRecordingAt(x, y);
|
| - } else {
|
| - hole_count++;
|
| - if (hole_count % 2)
|
| - pending_pile->AddRecordingAt(x, y);
|
| - }
|
| - }
|
| - }
|
| + SetupTreesWithInvalidation(pending_pile, active_pile,
|
| + gfx::Rect(layer_bounds));
|
|
|
| - SetupTrees(pending_pile, active_pile);
|
| - Region invalidation;
|
| - AddDefaultTilingsWithInvalidation(invalidation);
|
| + EXPECT_EQ(pending_layer_->tilings()->num_tilings(),
|
| + active_layer_->tilings()->num_tilings());
|
|
|
| const PictureLayerTilingSet* tilings = pending_layer_->tilings();
|
| EXPECT_GT(tilings->num_tilings(), 0u);
|
| - for (size_t i = 0; i < tilings->num_tilings(); ++i) {
|
| - const PictureLayerTiling* tiling = tilings->tiling_at(i);
|
| -
|
| - for (PictureLayerTiling::CoverageIterator iter(
|
| - tiling,
|
| - tiling->contents_scale(),
|
| - gfx::Rect(tiling->tiling_size()));
|
| - iter;
|
| - ++iter) {
|
| - EXPECT_FALSE(iter.full_tile_geometry_rect().IsEmpty());
|
| - // Ensure there is a recording for this tile.
|
| - bool in_pending = pending_pile->CoversRect(iter.full_tile_geometry_rect(),
|
| - tiling->contents_scale());
|
| - bool in_active = active_pile->CoversRect(iter.full_tile_geometry_rect(),
|
| - tiling->contents_scale());
|
| -
|
| - if (in_pending && !in_active)
|
| - EXPECT_EQ(pending_pile.get(), iter->raster_source());
|
| - else if (in_active)
|
| - EXPECT_EQ(active_pile.get(), iter->raster_source());
|
| - else
|
| - EXPECT_FALSE(*iter);
|
| - }
|
| - }
|
| + for (size_t i = 0; i < tilings->num_tilings(); ++i)
|
| + VerifyAllTilesExistAndHavePile(tilings->tiling_at(i), pending_pile.get());
|
| }
|
|
|
| -TEST_F(PictureLayerImplTest, ManageTilingsWithNoRecording) {
|
| +TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
|
| gfx::Size tile_size(400, 400);
|
| gfx::Size layer_bounds(1300, 1900);
|
|
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| - FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| scoped_refptr<FakePicturePileImpl> active_pile =
|
| - FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| SetupTrees(pending_pile, active_pile);
|
|
|
| - SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
|
| + float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
|
| + EXPECT_LT(low_res_factor, 1.f);
|
|
|
| - EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
|
| + active_layer_->ReleaseResources();
|
| + EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
|
| +
|
| + SetupDrawPropertiesAndUpdateTiles(active_layer_,
|
| + 6.f, // ideal contents scale
|
| + 3.f, // device scale
|
| + 2.f, // page scale
|
| + 1.f, // maximum animation scale
|
| + false);
|
| + ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
|
| + EXPECT_FLOAT_EQ(6.f,
|
| + active_layer_->tilings()->tiling_at(0)->contents_scale());
|
| + EXPECT_FLOAT_EQ(6.f * low_res_factor,
|
| + active_layer_->tilings()->tiling_at(1)->contents_scale());
|
| +
|
| + // If we change the page scale factor, then we should get new tilings.
|
| + SetupDrawPropertiesAndUpdateTiles(active_layer_,
|
| + 6.6f, // ideal contents scale
|
| + 3.f, // device scale
|
| + 2.2f, // page scale
|
| + 1.f, // maximum animation scale
|
| + false);
|
| + ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
|
| + EXPECT_FLOAT_EQ(6.6f,
|
| + active_layer_->tilings()->tiling_at(0)->contents_scale());
|
| + EXPECT_FLOAT_EQ(6.6f * low_res_factor,
|
| + active_layer_->tilings()->tiling_at(2)->contents_scale());
|
| +
|
| + // If we change the device scale factor, then we should get new tilings.
|
| + SetupDrawPropertiesAndUpdateTiles(active_layer_,
|
| + 7.26f, // ideal contents scale
|
| + 3.3f, // device scale
|
| + 2.2f, // page scale
|
| + 1.f, // maximum animation scale
|
| + false);
|
| + ASSERT_EQ(6u, active_layer_->tilings()->num_tilings());
|
| + EXPECT_FLOAT_EQ(7.26f,
|
| + active_layer_->tilings()->tiling_at(0)->contents_scale());
|
| + EXPECT_FLOAT_EQ(7.26f * low_res_factor,
|
| + active_layer_->tilings()->tiling_at(3)->contents_scale());
|
| +
|
| + // If we change the device scale factor, but end up at the same total scale
|
| + // factor somehow, then we don't get new tilings.
|
| + SetupDrawPropertiesAndUpdateTiles(active_layer_,
|
| + 7.26f, // ideal contents scale
|
| + 2.2f, // device scale
|
| + 3.3f, // page scale
|
| + 1.f, // maximum animation scale
|
| + false);
|
| + ASSERT_EQ(6u, active_layer_->tilings()->num_tilings());
|
| + EXPECT_FLOAT_EQ(7.26f,
|
| + active_layer_->tilings()->tiling_at(0)->contents_scale());
|
| + EXPECT_FLOAT_EQ(7.26f * low_res_factor,
|
| + active_layer_->tilings()->tiling_at(3)->contents_scale());
|
| }
|
|
|
| -TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
|
| +TEST_F(PictureLayerImplTest, PendingLayerOnlyHasHighAndLowResTiling) {
|
| gfx::Size tile_size(400, 400);
|
| gfx::Size layer_bounds(1300, 1900);
|
|
|
| @@ -697,11 +731,13 @@ TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| SetupTrees(pending_pile, active_pile);
|
| - EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
|
|
|
| float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
|
| EXPECT_LT(low_res_factor, 1.f);
|
|
|
| + pending_layer_->ReleaseResources();
|
| + EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
|
| +
|
| SetupDrawPropertiesAndUpdateTiles(pending_layer_,
|
| 6.f, // ideal contents scale
|
| 3.f, // device scale
|
| @@ -721,11 +757,11 @@ TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
|
| 2.2f, // page scale
|
| 1.f, // maximum animation scale
|
| false);
|
| - ASSERT_EQ(4u, pending_layer_->tilings()->num_tilings());
|
| + ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
|
| EXPECT_FLOAT_EQ(6.6f,
|
| pending_layer_->tilings()->tiling_at(0)->contents_scale());
|
| EXPECT_FLOAT_EQ(6.6f * low_res_factor,
|
| - pending_layer_->tilings()->tiling_at(2)->contents_scale());
|
| + pending_layer_->tilings()->tiling_at(1)->contents_scale());
|
|
|
| // If we change the device scale factor, then we should get new tilings.
|
| SetupDrawPropertiesAndUpdateTiles(pending_layer_,
|
| @@ -734,11 +770,11 @@ TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
|
| 2.2f, // page scale
|
| 1.f, // maximum animation scale
|
| false);
|
| - ASSERT_EQ(6u, pending_layer_->tilings()->num_tilings());
|
| + ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
|
| EXPECT_FLOAT_EQ(7.26f,
|
| pending_layer_->tilings()->tiling_at(0)->contents_scale());
|
| EXPECT_FLOAT_EQ(7.26f * low_res_factor,
|
| - pending_layer_->tilings()->tiling_at(3)->contents_scale());
|
| + pending_layer_->tilings()->tiling_at(1)->contents_scale());
|
|
|
| // If we change the device scale factor, but end up at the same total scale
|
| // factor somehow, then we don't get new tilings.
|
| @@ -748,11 +784,11 @@ TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
|
| 3.3f, // page scale
|
| 1.f, // maximum animation scale
|
| false);
|
| - ASSERT_EQ(6u, pending_layer_->tilings()->num_tilings());
|
| + ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
|
| EXPECT_FLOAT_EQ(7.26f,
|
| pending_layer_->tilings()->tiling_at(0)->contents_scale());
|
| EXPECT_FLOAT_EQ(7.26f * low_res_factor,
|
| - pending_layer_->tilings()->tiling_at(3)->contents_scale());
|
| + pending_layer_->tilings()->tiling_at(1)->contents_scale());
|
| }
|
|
|
| TEST_F(PictureLayerImplTest, CreateTilingsEvenIfTwinHasNone) {
|
| @@ -767,63 +803,22 @@ TEST_F(PictureLayerImplTest, CreateTilingsEvenIfTwinHasNone) {
|
| scoped_refptr<FakePicturePileImpl> valid_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| - float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
|
| - EXPECT_LT(low_res_factor, 1.f);
|
| -
|
| - float high_res_scale = 1.3f;
|
| - float low_res_scale = high_res_scale * low_res_factor;
|
| - float device_scale = 1.7f;
|
| - float page_scale = 3.2f;
|
| - float maximum_animation_scale = 1.f;
|
| -
|
| SetupPendingTree(valid_pile);
|
| - SetupDrawPropertiesAndUpdateTiles(pending_layer_,
|
| - high_res_scale,
|
| - device_scale,
|
| - page_scale,
|
| - maximum_animation_scale,
|
| - false);
|
| ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
|
| - EXPECT_FLOAT_EQ(high_res_scale,
|
| - pending_layer_->HighResTiling()->contents_scale());
|
| - EXPECT_FLOAT_EQ(low_res_scale,
|
| - pending_layer_->LowResTiling()->contents_scale());
|
|
|
| ActivateTree();
|
| SetupPendingTree(empty_pile);
|
| EXPECT_FALSE(pending_layer_->CanHaveTilings());
|
| - SetupDrawPropertiesAndUpdateTiles(pending_layer_,
|
| - high_res_scale,
|
| - device_scale,
|
| - page_scale,
|
| - maximum_animation_scale,
|
| - false);
|
| ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
|
| ASSERT_EQ(0u, pending_layer_->tilings()->num_tilings());
|
|
|
| ActivateTree();
|
| EXPECT_FALSE(active_layer_->CanHaveTilings());
|
| - SetupDrawPropertiesAndUpdateTiles(active_layer_,
|
| - high_res_scale,
|
| - device_scale,
|
| - page_scale,
|
| - maximum_animation_scale,
|
| - false);
|
| ASSERT_EQ(0u, active_layer_->tilings()->num_tilings());
|
|
|
| SetupPendingTree(valid_pile);
|
| - SetupDrawPropertiesAndUpdateTiles(pending_layer_,
|
| - high_res_scale,
|
| - device_scale,
|
| - page_scale,
|
| - maximum_animation_scale,
|
| - false);
|
| ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
|
| ASSERT_EQ(0u, active_layer_->tilings()->num_tilings());
|
| - EXPECT_FLOAT_EQ(high_res_scale,
|
| - pending_layer_->HighResTiling()->contents_scale());
|
| - EXPECT_FLOAT_EQ(low_res_scale,
|
| - pending_layer_->LowResTiling()->contents_scale());
|
| }
|
|
|
| TEST_F(PictureLayerImplTest, ZoomOutCrash) {
|
| @@ -837,8 +832,10 @@ TEST_F(PictureLayerImplTest, ZoomOutCrash) {
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| SetupTrees(pending_pile, active_pile);
|
| + ResetTilingsAndRasterScales();
|
| EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
|
| SetContentsScaleOnBothLayers(32.0f, 1.0f, 32.0f, 1.0f, false);
|
| + EXPECT_EQ(32.f, active_layer_->HighResTiling()->contents_scale());
|
| host_impl_.PinchGestureBegin();
|
| SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, 1.0f, false);
|
| SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, 1.0f, false);
|
| @@ -849,6 +846,8 @@ TEST_F(PictureLayerImplTest, PinchGestureTilings) {
|
| gfx::Size tile_size(400, 400);
|
| gfx::Size layer_bounds(1300, 1900);
|
|
|
| + float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
|
| +
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| scoped_refptr<FakePicturePileImpl> active_pile =
|
| @@ -856,21 +855,20 @@ TEST_F(PictureLayerImplTest, PinchGestureTilings) {
|
|
|
| // Set up the high and low res tilings before pinch zoom.
|
| SetupTrees(pending_pile, active_pile);
|
| - EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
|
| - SetContentsScaleOnBothLayers(2.0f, 1.0f, 1.0f, 1.0f, false);
|
| - float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
|
| - EXPECT_EQ(2u, active_layer_->tilings()->num_tilings());
|
| - EXPECT_FLOAT_EQ(2.0f,
|
| - active_layer_->tilings()->tiling_at(0)->contents_scale());
|
| - EXPECT_FLOAT_EQ(2.0f * low_res_factor,
|
| - active_layer_->tilings()->tiling_at(1)->contents_scale());
|
| + ResetTilingsAndRasterScales();
|
| +
|
| + SetContentsScaleOnBothLayers(2.f, 1.0f, 2.f, 1.0f, false);
|
| + EXPECT_BOTH_EQ(num_tilings(), 2u);
|
| + EXPECT_BOTH_EQ(tilings()->tiling_at(0)->contents_scale(), 2.f);
|
| + EXPECT_BOTH_EQ(tilings()->tiling_at(1)->contents_scale(),
|
| + 2.f * low_res_factor);
|
|
|
| // Start a pinch gesture.
|
| host_impl_.PinchGestureBegin();
|
|
|
| // Zoom out by a small amount. We should create a tiling at half
|
| // the scale (2/kMaxScaleRatioDuringPinch).
|
| - SetContentsScaleOnBothLayers(1.8f, 1.0f, 0.9f, 1.0f, false);
|
| + SetContentsScaleOnBothLayers(1.8f, 1.0f, 1.8f, 1.0f, false);
|
| EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
|
| EXPECT_FLOAT_EQ(2.0f,
|
| active_layer_->tilings()->tiling_at(0)->contents_scale());
|
| @@ -887,7 +885,7 @@ TEST_F(PictureLayerImplTest, PinchGestureTilings) {
|
|
|
| // Zoom in a lot now. Since we increase by increments of
|
| // kMaxScaleRatioDuringPinch, this will create a new tiling at 4.0.
|
| - SetContentsScaleOnBothLayers(3.8f, 1.0f, 2.1f, 1.f, false);
|
| + SetContentsScaleOnBothLayers(3.8f, 1.0f, 3.8f, 1.f, false);
|
| EXPECT_EQ(4u, active_layer_->tilings()->num_tilings());
|
| EXPECT_FLOAT_EQ(4.0f,
|
| active_layer_->tilings()->tiling_at(0)->contents_scale());
|
| @@ -902,9 +900,12 @@ TEST_F(PictureLayerImplTest, SnappedTilingDuringZoom) {
|
| scoped_refptr<FakePicturePileImpl> active_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| - // Set up the high and low res tilings before pinch zoom.
|
| SetupTrees(pending_pile, active_pile);
|
| +
|
| + ResetTilingsAndRasterScales();
|
| EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
|
| +
|
| + // Set up the high and low res tilings before pinch zoom.
|
| SetContentsScaleOnBothLayers(0.24f, 1.0f, 0.24f, 1.0f, false);
|
| EXPECT_EQ(2u, active_layer_->tilings()->num_tilings());
|
| EXPECT_FLOAT_EQ(0.24f,
|
| @@ -955,31 +956,28 @@ TEST_F(PictureLayerImplTest, CleanUpTilings) {
|
|
|
| std::vector<PictureLayerTiling*> used_tilings;
|
|
|
| - SetupTrees(pending_pile, active_pile);
|
| - EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
|
| -
|
| float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
|
| EXPECT_LT(low_res_factor, 1.f);
|
|
|
| - float device_scale = 1.7f;
|
| - float page_scale = 3.2f;
|
| float scale = 1.f;
|
| + float page_scale = 1.f;
|
|
|
| - SetContentsScaleOnBothLayers(scale, device_scale, page_scale, 1.f, false);
|
| - ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
|
| + SetupTrees(pending_pile, active_pile);
|
| + EXPECT_EQ(2u, active_layer_->tilings()->num_tilings());
|
| + EXPECT_EQ(1.f, active_layer_->HighResTiling()->contents_scale());
|
|
|
| // We only have ideal tilings, so they aren't removed.
|
| used_tilings.clear();
|
| active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
|
| - ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
|
| + EXPECT_EQ(2u, active_layer_->tilings()->num_tilings());
|
|
|
| host_impl_.PinchGestureBegin();
|
|
|
| // Changing the ideal but not creating new tilings.
|
| - scale *= 1.5f;
|
| - page_scale *= 1.5f;
|
| - SetContentsScaleOnBothLayers(scale, device_scale, page_scale, 1.f, false);
|
| - ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
|
| + scale = 1.5f;
|
| + page_scale = 1.5f;
|
| + SetContentsScaleOnBothLayers(scale, 1.f, page_scale, 1.f, false);
|
| + EXPECT_EQ(2u, active_layer_->tilings()->num_tilings());
|
|
|
| // The tilings are still our target scale, so they aren't removed.
|
| used_tilings.clear();
|
| @@ -989,9 +987,9 @@ TEST_F(PictureLayerImplTest, CleanUpTilings) {
|
| host_impl_.PinchGestureEnd();
|
|
|
| // Create a 1.2 scale tiling. Now we have 1.0 and 1.2 tilings. Ideal = 1.2.
|
| - scale /= 4.f;
|
| - page_scale /= 4.f;
|
| - SetContentsScaleOnBothLayers(1.2f, device_scale, page_scale, 1.f, false);
|
| + scale = 1.2f;
|
| + page_scale = 1.2f;
|
| + SetContentsScaleOnBothLayers(1.2f, 1.f, page_scale, 1.f, false);
|
| ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
|
| EXPECT_FLOAT_EQ(
|
| 1.f,
|
| @@ -1008,7 +1006,7 @@ TEST_F(PictureLayerImplTest, CleanUpTilings) {
|
| ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
|
|
|
| // Now move the ideal scale to 0.5. Our target stays 1.2.
|
| - SetContentsScaleOnBothLayers(0.5f, device_scale, page_scale, 1.f, false);
|
| + SetContentsScaleOnBothLayers(0.5f, 1.f, page_scale, 1.f, false);
|
|
|
| // The high resolution tiling is between target and ideal, so is not
|
| // removed. The low res tiling for the old ideal=1.0 scale is removed.
|
| @@ -1017,7 +1015,7 @@ TEST_F(PictureLayerImplTest, CleanUpTilings) {
|
| ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
|
|
|
| // Now move the ideal scale to 1.0. Our target stays 1.2.
|
| - SetContentsScaleOnBothLayers(1.f, device_scale, page_scale, 1.f, false);
|
| + SetContentsScaleOnBothLayers(1.f, 1.f, page_scale, 1.f, false);
|
|
|
| // All the tilings are between are target and the ideal, so they are not
|
| // removed.
|
| @@ -1026,8 +1024,8 @@ TEST_F(PictureLayerImplTest, CleanUpTilings) {
|
| ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
|
|
|
| // Now move the ideal scale to 1.1 on the active layer. Our target stays 1.2.
|
| - SetupDrawPropertiesAndUpdateTiles(
|
| - active_layer_, 1.1f, device_scale, page_scale, 1.f, false);
|
| + SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.1f, 1.f, page_scale, 1.f,
|
| + false);
|
|
|
| // Because the pending layer's ideal scale is still 1.0, our tilings fall
|
| // in the range [1.0,1.2] and are kept.
|
| @@ -1037,8 +1035,8 @@ TEST_F(PictureLayerImplTest, CleanUpTilings) {
|
|
|
| // Move the ideal scale on the pending layer to 1.1 as well. Our target stays
|
| // 1.2 still.
|
| - SetupDrawPropertiesAndUpdateTiles(
|
| - pending_layer_, 1.1f, device_scale, page_scale, 1.f, false);
|
| + SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.1f, 1.f, page_scale, 1.f,
|
| + false);
|
|
|
| // Our 1.0 tiling now falls outside the range between our ideal scale and our
|
| // target raster scale. But it is in our used tilings set, so nothing is
|
| @@ -1055,26 +1053,13 @@ TEST_F(PictureLayerImplTest, CleanUpTilings) {
|
| ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
|
| }
|
|
|
| -#define EXPECT_BOTH_EQ(expression, x) \
|
| - do { \
|
| - EXPECT_EQ(x, pending_layer_->expression); \
|
| - EXPECT_EQ(x, active_layer_->expression); \
|
| - } while (false)
|
| -
|
| -#define EXPECT_BOTH_NE(expression, x) \
|
| - do { \
|
| - EXPECT_NE(x, pending_layer_->expression); \
|
| - EXPECT_NE(x, active_layer_->expression); \
|
| - } while (false)
|
| -
|
| TEST_F(PictureLayerImplTest, DontAddLowResDuringAnimation) {
|
| // Make sure this layer covers multiple tiles, since otherwise low
|
| // res won't get created because it is too small.
|
| gfx::Size tile_size(host_impl_.settings().default_tile_size);
|
| - SetupDefaultTrees(gfx::Size(tile_size.width() + 1, tile_size.height() + 1));
|
| // Avoid max untiled layer size heuristics via fixed tile size.
|
| - pending_layer_->set_fixed_tile_size(tile_size);
|
| - active_layer_->set_fixed_tile_size(tile_size);
|
| + gfx::Size layer_bounds(tile_size.width() + 1, tile_size.height() + 1);
|
| + SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
|
|
|
| float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
|
| float contents_scale = 1.f;
|
| @@ -1083,6 +1068,8 @@ TEST_F(PictureLayerImplTest, DontAddLowResDuringAnimation) {
|
| float maximum_animation_scale = 1.f;
|
| bool animating_transform = true;
|
|
|
| + ResetTilingsAndRasterScales();
|
| +
|
| // Animating, so don't create low res even if there isn't one already.
|
| SetContentsScaleOnBothLayers(contents_scale,
|
| device_scale,
|
| @@ -1104,7 +1091,8 @@ TEST_F(PictureLayerImplTest, DontAddLowResDuringAnimation) {
|
| EXPECT_BOTH_EQ(num_tilings(), 2u);
|
|
|
| // Page scale animation, new high res, but no low res. We still have
|
| - // a tiling at the previous scale, it's just not marked as low res.
|
| + // a tiling at the previous scale, it's just not marked as low res on the
|
| + // active layer. The pending layer drops non-ideal tilings.
|
| contents_scale = 2.f;
|
| page_scale = 2.f;
|
| maximum_animation_scale = 2.f;
|
| @@ -1117,7 +1105,8 @@ TEST_F(PictureLayerImplTest, DontAddLowResDuringAnimation) {
|
| EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
|
| EXPECT_FALSE(active_layer_->LowResTiling());
|
| EXPECT_FALSE(pending_layer_->LowResTiling());
|
| - EXPECT_BOTH_EQ(num_tilings(), 3u);
|
| + EXPECT_EQ(3u, active_layer_->num_tilings());
|
| + EXPECT_EQ(1u, pending_layer_->num_tilings());
|
|
|
| // Stop animating, new low res gets created for final page scale.
|
| animating_transform = false;
|
| @@ -1128,7 +1117,8 @@ TEST_F(PictureLayerImplTest, DontAddLowResDuringAnimation) {
|
| animating_transform);
|
| EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
|
| EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), 2.f * low_res_factor);
|
| - EXPECT_BOTH_EQ(num_tilings(), 4u);
|
| + EXPECT_EQ(4u, active_layer_->num_tilings());
|
| + EXPECT_EQ(2u, pending_layer_->num_tilings());
|
| }
|
|
|
| TEST_F(PictureLayerImplTest, DontAddLowResForSmallLayers) {
|
| @@ -1185,120 +1175,187 @@ TEST_F(PictureLayerImplTest, DontAddLowResForSmallLayers) {
|
| contents_scale * low_res_factor);
|
| EXPECT_BOTH_EQ(num_tilings(), 2u);
|
|
|
| - ResetTilingsAndRasterScales();
|
| -
|
| // Mask layers dont create low res since they always fit on one tile.
|
| - pending_layer_->set_is_mask(true);
|
| - active_layer_->set_is_mask(true);
|
| - SetContentsScaleOnBothLayers(contents_scale,
|
| - device_scale,
|
| - page_scale,
|
| - maximum_animation_scale,
|
| - animating_transform);
|
| - EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
|
| - EXPECT_BOTH_EQ(num_tilings(), 1u);
|
| + scoped_ptr<FakePictureLayerImpl> mask =
|
| + FakePictureLayerImpl::CreateMaskWithRasterSource(
|
| + host_impl_.pending_tree(), 3, pending_pile);
|
| + mask->SetBounds(layer_bounds);
|
| + mask->SetContentBounds(layer_bounds);
|
| + mask->SetDrawsContent(true);
|
| +
|
| + SetupDrawPropertiesAndUpdateTiles(mask.get(), contents_scale, device_scale,
|
| + page_scale, maximum_animation_scale,
|
| + animating_transform);
|
| + EXPECT_EQ(mask->HighResTiling()->contents_scale(), contents_scale);
|
| + EXPECT_EQ(mask->num_tilings(), 1u);
|
| }
|
|
|
| TEST_F(PictureLayerImplTest, HugeMasksDontGetTiles) {
|
| + base::TimeTicks time_ticks;
|
| + time_ticks += base::TimeDelta::FromMilliseconds(1);
|
| + host_impl_.SetCurrentBeginFrameArgs(
|
| + CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
|
| +
|
| gfx::Size tile_size(100, 100);
|
| + gfx::Size layer_bounds(1000, 1000);
|
|
|
| scoped_refptr<FakePicturePileImpl> valid_pile =
|
| - FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(1000, 1000));
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| SetupPendingTree(valid_pile);
|
| - pending_layer_->set_is_mask(true);
|
|
|
| - SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
|
| - EXPECT_EQ(1.f, pending_layer_->HighResTiling()->contents_scale());
|
| - EXPECT_EQ(1u, pending_layer_->num_tilings());
|
| + scoped_ptr<FakePictureLayerImpl> mask_ptr =
|
| + FakePictureLayerImpl::CreateMaskWithRasterSource(
|
| + host_impl_.pending_tree(), 3, valid_pile);
|
| + mask_ptr->SetBounds(layer_bounds);
|
| + mask_ptr->SetContentBounds(layer_bounds);
|
| + mask_ptr->SetDrawsContent(true);
|
| + pending_layer_->SetMaskLayer(mask_ptr.Pass());
|
| +
|
| + time_ticks += base::TimeDelta::FromMilliseconds(1);
|
| + host_impl_.SetCurrentBeginFrameArgs(
|
| + CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
|
| + host_impl_.pending_tree()->UpdateDrawProperties();
|
| +
|
| + FakePictureLayerImpl* pending_mask =
|
| + static_cast<FakePictureLayerImpl*>(pending_layer_->mask_layer());
|
| +
|
| + EXPECT_EQ(1.f, pending_mask->HighResTiling()->contents_scale());
|
| + EXPECT_EQ(1u, pending_mask->num_tilings());
|
|
|
| - pending_layer_->HighResTiling()->CreateAllTilesForTesting();
|
| host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(
|
| - pending_layer_->HighResTiling()->AllTilesForTesting());
|
| + pending_mask->HighResTiling()->AllTilesForTesting());
|
|
|
| ActivateTree();
|
|
|
| + FakePictureLayerImpl* active_mask =
|
| + static_cast<FakePictureLayerImpl*>(active_layer_->mask_layer());
|
| +
|
| // Mask layers have a tiling with a single tile in it.
|
| - EXPECT_EQ(1u, active_layer_->HighResTiling()->AllTilesForTesting().size());
|
| + EXPECT_EQ(1u, active_mask->HighResTiling()->AllTilesForTesting().size());
|
| // The mask resource exists.
|
| ResourceProvider::ResourceId mask_resource_id;
|
| gfx::Size mask_texture_size;
|
| - active_layer_->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
|
| + active_mask->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
|
| EXPECT_NE(0u, mask_resource_id);
|
| - EXPECT_EQ(mask_texture_size, active_layer_->bounds());
|
| + EXPECT_EQ(mask_texture_size, active_mask->bounds());
|
|
|
| // Drop resources and recreate them, still the same.
|
| - old_pending_layer_->ReleaseResources();
|
| - active_layer_->ReleaseResources();
|
| - SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
|
| - active_layer_->HighResTiling()->CreateAllTilesForTesting();
|
| - EXPECT_EQ(1u, active_layer_->HighResTiling()->AllTilesForTesting().size());
|
| + pending_mask->ReleaseResources();
|
| + active_mask->ReleaseResources();
|
| + SetupDrawPropertiesAndUpdateTiles(active_mask, 1.f, 1.f, 1.f, 1.f, false);
|
| + active_mask->HighResTiling()->CreateAllTilesForTesting();
|
| + EXPECT_EQ(1u, active_mask->HighResTiling()->AllTilesForTesting().size());
|
| EXPECT_NE(0u, mask_resource_id);
|
| EXPECT_EQ(mask_texture_size, active_layer_->bounds());
|
|
|
| + // Drop resources and recreate them, still the same.
|
| + pending_mask->ReleaseResources();
|
| + active_mask->ReleaseResources();
|
| + SetupDrawPropertiesAndUpdateTiles(active_mask, 1.f, 1.f, 1.f, 1.f, false);
|
| + active_mask->HighResTiling()->CreateAllTilesForTesting();
|
| + EXPECT_EQ(1u, active_mask->HighResTiling()->AllTilesForTesting().size());
|
| + EXPECT_NE(0u, mask_resource_id);
|
| + EXPECT_EQ(mask_texture_size, active_mask->bounds());
|
| +
|
| // Resize larger than the max texture size.
|
| int max_texture_size = host_impl_.GetRendererCapabilities().max_texture_size;
|
| + gfx::Size huge_bounds(max_texture_size + 1, 10);
|
| scoped_refptr<FakePicturePileImpl> huge_pile =
|
| - FakePicturePileImpl::CreateFilledPile(
|
| - tile_size, gfx::Size(max_texture_size + 1, 10));
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, huge_bounds);
|
| +
|
| SetupPendingTree(huge_pile);
|
| - pending_layer_->set_is_mask(true);
|
| + pending_mask->SetBounds(huge_bounds);
|
| + pending_mask->SetContentBounds(huge_bounds);
|
| + pending_mask->SetRasterSourceOnPending(huge_pile, Region());
|
|
|
| - SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
|
| - EXPECT_EQ(1.f, pending_layer_->HighResTiling()->contents_scale());
|
| - EXPECT_EQ(1u, pending_layer_->num_tilings());
|
| + time_ticks += base::TimeDelta::FromMilliseconds(1);
|
| + host_impl_.SetCurrentBeginFrameArgs(
|
| + CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
|
| + host_impl_.pending_tree()->UpdateDrawProperties();
|
| +
|
| + EXPECT_EQ(1.f, pending_mask->HighResTiling()->contents_scale());
|
| + EXPECT_EQ(1u, pending_mask->num_tilings());
|
|
|
| - pending_layer_->HighResTiling()->CreateAllTilesForTesting();
|
| host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(
|
| - pending_layer_->HighResTiling()->AllTilesForTesting());
|
| + pending_mask->HighResTiling()->AllTilesForTesting());
|
|
|
| ActivateTree();
|
|
|
| // Mask layers have a tiling, but there should be no tiles in it.
|
| - EXPECT_EQ(0u, active_layer_->HighResTiling()->AllTilesForTesting().size());
|
| + EXPECT_EQ(0u, active_mask->HighResTiling()->AllTilesForTesting().size());
|
| // The mask resource is empty.
|
| active_layer_->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
|
| EXPECT_EQ(0u, mask_resource_id);
|
|
|
| // Drop resources and recreate them, still the same.
|
| - old_pending_layer_->ReleaseResources();
|
| - active_layer_->ReleaseResources();
|
| - SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
|
| - active_layer_->HighResTiling()->CreateAllTilesForTesting();
|
| - EXPECT_EQ(0u, active_layer_->HighResTiling()->AllTilesForTesting().size());
|
| + pending_mask->ReleaseResources();
|
| + active_mask->ReleaseResources();
|
| + SetupDrawPropertiesAndUpdateTiles(active_mask, 1.f, 1.f, 1.f, 1.f, false);
|
| + active_mask->HighResTiling()->CreateAllTilesForTesting();
|
| + EXPECT_EQ(0u, active_mask->HighResTiling()->AllTilesForTesting().size());
|
| + active_mask->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
|
| + EXPECT_EQ(0u, mask_resource_id);
|
| +
|
| + // Do another activate, the same holds.
|
| + SetupPendingTree(huge_pile);
|
| + ActivateTree();
|
| + EXPECT_EQ(0u, active_mask->HighResTiling()->AllTilesForTesting().size());
|
| active_layer_->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
|
| EXPECT_EQ(0u, mask_resource_id);
|
| }
|
|
|
| TEST_F(PictureLayerImplTest, ScaledMaskLayer) {
|
| + base::TimeTicks time_ticks;
|
| + time_ticks += base::TimeDelta::FromMilliseconds(1);
|
| + host_impl_.SetCurrentBeginFrameArgs(
|
| + CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
|
| +
|
| gfx::Size tile_size(100, 100);
|
| + gfx::Size layer_bounds(1000, 1000);
|
| +
|
| + host_impl_.SetDeviceScaleFactor(1.3f);
|
|
|
| scoped_refptr<FakePicturePileImpl> valid_pile =
|
| - FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(1000, 1000));
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| SetupPendingTree(valid_pile);
|
| - pending_layer_->set_is_mask(true);
|
|
|
| - float ideal_contents_scale = 1.3f;
|
| - SetupDrawPropertiesAndUpdateTiles(
|
| - pending_layer_, ideal_contents_scale, 1.f, 1.f, 1.f, false);
|
| - EXPECT_EQ(ideal_contents_scale,
|
| - pending_layer_->HighResTiling()->contents_scale());
|
| - EXPECT_EQ(1u, pending_layer_->num_tilings());
|
| + scoped_ptr<FakePictureLayerImpl> mask_ptr =
|
| + FakePictureLayerImpl::CreateMaskWithRasterSource(
|
| + host_impl_.pending_tree(), 3, valid_pile);
|
| + mask_ptr->SetBounds(layer_bounds);
|
| + mask_ptr->SetContentBounds(layer_bounds);
|
| + mask_ptr->SetDrawsContent(true);
|
| + pending_layer_->SetMaskLayer(mask_ptr.Pass());
|
| +
|
| + time_ticks += base::TimeDelta::FromMilliseconds(1);
|
| + host_impl_.SetCurrentBeginFrameArgs(
|
| + CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
|
| + host_impl_.pending_tree()->UpdateDrawProperties();
|
| +
|
| + FakePictureLayerImpl* pending_mask =
|
| + static_cast<FakePictureLayerImpl*>(pending_layer_->mask_layer());
|
| +
|
| + // Masks are scaled, and do not have a low res tiling.
|
| + EXPECT_EQ(1.3f, pending_mask->HighResTiling()->contents_scale());
|
| + EXPECT_EQ(1u, pending_mask->num_tilings());
|
|
|
| - pending_layer_->HighResTiling()->CreateAllTilesForTesting();
|
| host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(
|
| - pending_layer_->HighResTiling()->AllTilesForTesting());
|
| + pending_mask->HighResTiling()->AllTilesForTesting());
|
|
|
| ActivateTree();
|
|
|
| + FakePictureLayerImpl* active_mask =
|
| + static_cast<FakePictureLayerImpl*>(active_layer_->mask_layer());
|
| +
|
| // Mask layers have a tiling with a single tile in it.
|
| - EXPECT_EQ(1u, active_layer_->HighResTiling()->AllTilesForTesting().size());
|
| + EXPECT_EQ(1u, active_mask->HighResTiling()->AllTilesForTesting().size());
|
| // The mask resource exists.
|
| ResourceProvider::ResourceId mask_resource_id;
|
| gfx::Size mask_texture_size;
|
| - active_layer_->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
|
| + active_mask->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
|
| EXPECT_NE(0u, mask_resource_id);
|
| - gfx::Size expected_mask_texture_size = gfx::ToCeiledSize(
|
| - gfx::ScaleSize(active_layer_->bounds(), ideal_contents_scale));
|
| + gfx::Size expected_mask_texture_size =
|
| + gfx::ToCeiledSize(gfx::ScaleSize(active_mask->bounds(), 1.3f));
|
| EXPECT_EQ(mask_texture_size, expected_mask_texture_size);
|
| }
|
|
|
| @@ -1312,14 +1369,6 @@ TEST_F(PictureLayerImplTest, ReleaseResources) {
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| SetupTrees(pending_pile, active_pile);
|
| - EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
|
| -
|
| - SetupDrawPropertiesAndUpdateTiles(pending_layer_,
|
| - 1.3f, // ideal contents scale
|
| - 2.7f, // device scale
|
| - 3.2f, // page scale
|
| - 1.f, // maximum animation scale
|
| - false);
|
| EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
|
|
|
| // All tilings should be removed when losing output surface.
|
| @@ -1330,10 +1379,10 @@ TEST_F(PictureLayerImplTest, ReleaseResources) {
|
|
|
| // This should create new tilings.
|
| SetupDrawPropertiesAndUpdateTiles(pending_layer_,
|
| - 1.3f, // ideal contents scale
|
| - 2.7f, // device scale
|
| - 3.2f, // page scale
|
| - 1.f, // maximum animation scale
|
| + 1.f, // ideal contents scale
|
| + 1.f, // device scale
|
| + 1.f, // page scale
|
| + 1.f, // maximum animation scale
|
| false);
|
| EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
|
| }
|
| @@ -1349,10 +1398,7 @@ TEST_F(PictureLayerImplTest, ClampTilesToToMaxTileSize) {
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| SetupTrees(pending_pile, active_pile);
|
| - EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
|
| -
|
| - SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
|
| - ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
|
| + EXPECT_GE(pending_layer_->tilings()->num_tilings(), 1u);
|
|
|
| pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
|
|
|
| @@ -1364,7 +1410,7 @@ TEST_F(PictureLayerImplTest, ClampTilesToToMaxTileSize) {
|
| EXPECT_EQ(gfx::Size(256, 256).ToString(),
|
| tile->content_rect().size().ToString());
|
|
|
| - pending_layer_->ReleaseResources();
|
| + ResetTilingsAndRasterScales();
|
|
|
| // Change the max texture size on the output surface context.
|
| scoped_ptr<TestWebGraphicsContext3D> context =
|
| @@ -1396,10 +1442,7 @@ TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) {
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| SetupTrees(pending_pile, active_pile);
|
| - EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
|
| -
|
| - SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
|
| - ASSERT_LE(1u, pending_layer_->tilings()->num_tilings());
|
| + EXPECT_GE(pending_layer_->tilings()->num_tilings(), 1u);
|
|
|
| pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
|
|
|
| @@ -1411,7 +1454,7 @@ TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) {
|
| PictureLayerTiling* high_res_tiling = pending_layer_->tilings()->tiling_at(0);
|
| EXPECT_EQ(1u, high_res_tiling->AllTilesForTesting().size());
|
|
|
| - pending_layer_->ReleaseResources();
|
| + ResetTilingsAndRasterScales();
|
|
|
| // Change the max texture size on the output surface context.
|
| scoped_ptr<TestWebGraphicsContext3D> context =
|
| @@ -1448,15 +1491,12 @@ TEST_F(PictureLayerImplTest, DisallowTileDrawQuads) {
|
| scoped_refptr<FakePicturePileImpl> active_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| - SetupTrees(pending_pile, active_pile);
|
| + gfx::Rect layer_invalidation(150, 200, 30, 180);
|
| + SetupTreesWithInvalidation(pending_pile, active_pile, layer_invalidation);
|
|
|
| active_layer_->draw_properties().visible_content_rect =
|
| gfx::Rect(layer_bounds);
|
|
|
| - gfx::Rect layer_invalidation(150, 200, 30, 180);
|
| - Region invalidation(layer_invalidation);
|
| - AddDefaultTilingsWithInvalidation(invalidation);
|
| -
|
| AppendQuadsData data;
|
| active_layer_->WillDraw(DRAW_MODE_RESOURCELESS_SOFTWARE, nullptr);
|
| active_layer_->AppendQuads(render_pass.get(), Occlusion(), &data);
|
| @@ -1514,33 +1554,20 @@ TEST_F(PictureLayerImplTest, TileScalesWithSolidColorPile) {
|
| pending_pile->set_is_solid_color(false);
|
| active_pile->set_is_solid_color(true);
|
| SetupTrees(pending_pile, active_pile);
|
| - // Solid color layer should not have tilings.
|
| - ASSERT_FALSE(active_layer_->CanHaveTilings());
|
| -
|
| - // Update properties with solid color pile should not allow tilings at any
|
| - // scale.
|
| - host_impl_.active_tree()->UpdateDrawProperties();
|
| + // Solid color pile should not allow tilings at any scale.
|
| EXPECT_FALSE(active_layer_->CanHaveTilings());
|
| EXPECT_EQ(0.f, active_layer_->ideal_contents_scale());
|
|
|
| - // Push non-solid-color pending pile makes active layer can have tilings.
|
| - active_layer_->UpdateRasterSource(pending_pile);
|
| - ASSERT_TRUE(active_layer_->CanHaveTilings());
|
| -
|
| - // Update properties with non-solid color pile should allow tilings.
|
| - host_impl_.active_tree()->UpdateDrawProperties();
|
| + // Activate non-solid-color pending pile makes active layer can have tilings.
|
| + ActivateTree();
|
| EXPECT_TRUE(active_layer_->CanHaveTilings());
|
| EXPECT_GT(active_layer_->ideal_contents_scale(), 0.f);
|
| }
|
|
|
| -TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
|
| +TEST_F(NoLowResPictureLayerImplTest, MarkRequiredOffscreenTiles) {
|
| gfx::Size tile_size(100, 100);
|
| gfx::Size layer_bounds(200, 200);
|
|
|
| - scoped_refptr<FakePicturePileImpl> pending_pile =
|
| - FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| - SetupPendingTree(pending_pile);
|
| -
|
| gfx::Transform transform;
|
| gfx::Transform transform_for_tile_priority;
|
| bool resourceless_software_draw = false;
|
| @@ -1552,10 +1579,11 @@ TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
|
| transform,
|
| resourceless_software_draw);
|
|
|
| - pending_layer_->set_fixed_tile_size(tile_size);
|
| - ASSERT_TRUE(pending_layer_->CanHaveTilings());
|
| - PictureLayerTiling* tiling = pending_layer_->AddTiling(1.f);
|
| - host_impl_.pending_tree()->UpdateDrawProperties();
|
| + scoped_refptr<FakePicturePileImpl> pending_pile =
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| + SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
|
| +
|
| + EXPECT_EQ(1u, pending_layer_->num_tilings());
|
| EXPECT_EQ(viewport, pending_layer_->visible_rect_for_tile_priority());
|
|
|
| base::TimeTicks time_ticks;
|
| @@ -1563,13 +1591,13 @@ TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
|
| host_impl_.SetCurrentBeginFrameArgs(
|
| CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
|
| pending_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
|
| - EXPECT_EQ(HIGH_RESOLUTION, tiling->resolution());
|
|
|
| int num_visible = 0;
|
| int num_offscreen = 0;
|
|
|
| - for (PictureLayerTiling::TilingRasterTileIterator iter(tiling); iter;
|
| - ++iter) {
|
| + for (PictureLayerTiling::TilingRasterTileIterator iter(
|
| + pending_layer_->HighResTiling());
|
| + iter; ++iter) {
|
| const Tile* tile = *iter;
|
| DCHECK(tile);
|
| if (tile->priority(PENDING_TREE).distance_to_visible == 0.f) {
|
| @@ -1585,7 +1613,8 @@ TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
|
| EXPECT_GT(num_offscreen, 0);
|
| }
|
|
|
| -TEST_F(PictureLayerImplTest, TileOutsideOfViewportForTilePriorityNotRequired) {
|
| +TEST_F(NoLowResPictureLayerImplTest,
|
| + TileOutsideOfViewportForTilePriorityNotRequired) {
|
| base::TimeTicks time_ticks;
|
| time_ticks += base::TimeDelta::FromMilliseconds(1);
|
| host_impl_.SetCurrentBeginFrameArgs(
|
| @@ -1600,12 +1629,10 @@ TEST_F(PictureLayerImplTest, TileOutsideOfViewportForTilePriorityNotRequired) {
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| - SetupTrees(pending_pile, active_pile);
|
| + SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
|
|
|
| - active_layer_->set_fixed_tile_size(tile_size);
|
| - pending_layer_->set_fixed_tile_size(tile_size);
|
| - ASSERT_TRUE(pending_layer_->CanHaveTilings());
|
| - PictureLayerTiling* tiling = pending_layer_->AddTiling(1.f);
|
| + ASSERT_EQ(1u, pending_layer_->num_tilings());
|
| + ASSERT_EQ(1.f, pending_layer_->HighResTiling()->contents_scale());
|
|
|
| // Set external viewport for tile priority.
|
| gfx::Rect viewport = gfx::Rect(layer_bounds);
|
| @@ -1618,6 +1645,9 @@ TEST_F(PictureLayerImplTest, TileOutsideOfViewportForTilePriorityNotRequired) {
|
| external_viewport_for_tile_priority,
|
| transform_for_tile_priority,
|
| resourceless_software_draw);
|
| + time_ticks += base::TimeDelta::FromMilliseconds(1);
|
| + host_impl_.SetCurrentBeginFrameArgs(
|
| + CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
|
| host_impl_.pending_tree()->UpdateDrawProperties();
|
|
|
| // Set visible content rect that is different from
|
| @@ -1637,9 +1667,8 @@ TEST_F(PictureLayerImplTest, TileOutsideOfViewportForTilePriorityNotRequired) {
|
| int num_inside = 0;
|
| int num_outside = 0;
|
| for (PictureLayerTiling::CoverageIterator iter(
|
| - tiling, pending_layer_->contents_scale_x(), gfx::Rect(layer_bounds));
|
| - iter;
|
| - ++iter) {
|
| + pending_layer_->HighResTiling(), 1.f, gfx::Rect(layer_bounds));
|
| + iter; ++iter) {
|
| if (!*iter)
|
| continue;
|
| Tile* tile = *iter;
|
| @@ -1683,16 +1712,13 @@ TEST_F(PictureLayerImplTest, HighResTileIsComplete) {
|
| gfx::Size tile_size(100, 100);
|
| gfx::Size layer_bounds(200, 200);
|
|
|
| - host_impl_.SetViewportSize(layer_bounds);
|
| -
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| - SetupPendingTree(pending_pile);
|
| +
|
| + SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
|
| ActivateTree();
|
|
|
| // All high res tiles have resources.
|
| - active_layer_->set_fixed_tile_size(tile_size);
|
| - host_impl_.active_tree()->UpdateDrawProperties();
|
| std::vector<Tile*> tiles =
|
| active_layer_->tilings()->tiling_at(0)->AllTilesForTesting();
|
| host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
|
| @@ -1719,16 +1745,11 @@ TEST_F(PictureLayerImplTest, HighResTileIsIncomplete) {
|
| gfx::Size tile_size(100, 100);
|
| gfx::Size layer_bounds(200, 200);
|
|
|
| - host_impl_.SetViewportSize(layer_bounds);
|
| -
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| - SetupPendingTree(pending_pile);
|
| + SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
|
| ActivateTree();
|
|
|
| - active_layer_->set_fixed_tile_size(tile_size);
|
| - host_impl_.active_tree()->UpdateDrawProperties();
|
| -
|
| scoped_ptr<RenderPass> render_pass = RenderPass::Create();
|
| AppendQuadsData data;
|
| active_layer_->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
|
| @@ -1750,15 +1771,11 @@ TEST_F(PictureLayerImplTest, HighResTileIsIncompleteLowResComplete) {
|
| gfx::Size tile_size(100, 100);
|
| gfx::Size layer_bounds(200, 200);
|
|
|
| - host_impl_.SetViewportSize(layer_bounds);
|
| -
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| - SetupPendingTree(pending_pile);
|
| + SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
|
| ActivateTree();
|
|
|
| - active_layer_->set_fixed_tile_size(tile_size);
|
| - host_impl_.active_tree()->UpdateDrawProperties();
|
| std::vector<Tile*> low_tiles =
|
| active_layer_->tilings()->tiling_at(1)->AllTilesForTesting();
|
| host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(low_tiles);
|
| @@ -1784,16 +1801,12 @@ TEST_F(PictureLayerImplTest, LowResTileIsIncomplete) {
|
| gfx::Size tile_size(100, 100);
|
| gfx::Size layer_bounds(200, 200);
|
|
|
| - host_impl_.SetViewportSize(layer_bounds);
|
| -
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| - SetupPendingTree(pending_pile);
|
| + SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
|
| ActivateTree();
|
|
|
| // All high res tiles have resources except one.
|
| - active_layer_->set_fixed_tile_size(tile_size);
|
| - host_impl_.active_tree()->UpdateDrawProperties();
|
| std::vector<Tile*> high_tiles =
|
| active_layer_->tilings()->tiling_at(0)->AllTilesForTesting();
|
| high_tiles.erase(high_tiles.begin());
|
| @@ -1826,20 +1839,16 @@ TEST_F(PictureLayerImplTest,
|
|
|
| gfx::Size tile_size(100, 100);
|
| gfx::Size layer_bounds(200, 200);
|
| + gfx::Size viewport_size(400, 400);
|
|
|
| - host_impl_.SetViewportSize(layer_bounds);
|
| + host_impl_.SetViewportSize(viewport_size);
|
| + host_impl_.SetDeviceScaleFactor(2.f);
|
|
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| scoped_refptr<FakePicturePileImpl> active_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| - SetupTrees(pending_pile, active_pile);
|
| -
|
| - active_layer_->set_fixed_tile_size(tile_size);
|
| -
|
| - active_layer_->draw_properties().visible_content_rect =
|
| - gfx::Rect(layer_bounds);
|
| - SetupDrawPropertiesAndUpdateTiles(active_layer_, 2.f, 1.f, 1.f, 1.f, false);
|
| + SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
|
|
|
| // One ideal tile exists, this will get used when drawing.
|
| std::vector<Tile*> ideal_tiles;
|
| @@ -1891,14 +1900,9 @@ TEST_F(PictureLayerImplTest, HighResRequiredWhenUnsharedActiveAllReady) {
|
| gfx::Size layer_bounds(400, 400);
|
| gfx::Size tile_size(100, 100);
|
|
|
| - host_impl_.SetViewportSize(layer_bounds);
|
| -
|
| - SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
|
| -
|
| // No tiles shared.
|
| - pending_layer_->set_invalidation(gfx::Rect(layer_bounds));
|
| -
|
| - CreateHighLowResAndSetAllTilesVisible();
|
| + SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size,
|
| + gfx::Rect(layer_bounds));
|
|
|
| active_layer_->SetAllTilesReady();
|
|
|
| @@ -1915,12 +1919,8 @@ TEST_F(PictureLayerImplTest, HighResRequiredWhenMissingHighResFlagOn) {
|
| gfx::Size layer_bounds(400, 400);
|
| gfx::Size tile_size(100, 100);
|
|
|
| - host_impl_.SetViewportSize(layer_bounds);
|
| -
|
| - SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
|
| -
|
| // All tiles shared (no invalidation).
|
| - CreateHighLowResAndSetAllTilesVisible();
|
| + SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
|
|
|
| // Verify active tree not ready.
|
| Tile* some_active_tile =
|
| @@ -1942,11 +1942,7 @@ TEST_F(PictureLayerImplTest, AllHighResRequiredEvenIfShared) {
|
| gfx::Size layer_bounds(400, 400);
|
| gfx::Size tile_size(100, 100);
|
|
|
| - host_impl_.SetViewportSize(layer_bounds);
|
| -
|
| - SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
|
| -
|
| - CreateHighLowResAndSetAllTilesVisible();
|
| + SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
|
|
|
| Tile* some_active_tile =
|
| active_layer_->HighResTiling()->AllTilesForTesting()[0];
|
| @@ -1964,9 +1960,8 @@ TEST_F(PictureLayerImplTest, AllHighResRequiredEvenIfShared) {
|
| TEST_F(PictureLayerImplTest, DisallowRequiredForActivation) {
|
| gfx::Size layer_bounds(400, 400);
|
| gfx::Size tile_size(100, 100);
|
| - SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
|
|
|
| - CreateHighLowResAndSetAllTilesVisible();
|
| + SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
|
|
|
| Tile* some_active_tile =
|
| active_layer_->HighResTiling()->AllTilesForTesting()[0];
|
| @@ -1986,6 +1981,7 @@ TEST_F(PictureLayerImplTest, DisallowRequiredForActivation) {
|
| TEST_F(PictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
|
| gfx::Size layer_bounds(400, 400);
|
| gfx::Size tile_size(100, 100);
|
| +
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| // This pile will create tilings, but has no recordings so will not create any
|
| @@ -1995,11 +1991,8 @@ TEST_F(PictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
|
| scoped_refptr<FakePicturePileImpl> active_pile =
|
| FakePicturePileImpl::CreateEmptyPileThatThinksItHasRecordings(
|
| tile_size, layer_bounds);
|
| - SetupTrees(pending_pile, active_pile);
|
| - pending_layer_->set_fixed_tile_size(tile_size);
|
| - active_layer_->set_fixed_tile_size(tile_size);
|
|
|
| - CreateHighLowResAndSetAllTilesVisible();
|
| + SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
|
|
|
| // Active layer has tilings, but no tiles due to missing recordings.
|
| EXPECT_TRUE(active_layer_->CanHaveTilings());
|
| @@ -2019,17 +2012,11 @@ TEST_F(PictureLayerImplTest, HighResRequiredIfActiveCantHaveTiles) {
|
| gfx::Size layer_bounds(400, 400);
|
| gfx::Size tile_size(100, 100);
|
|
|
| - host_impl_.SetViewportSize(layer_bounds);
|
| -
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| scoped_refptr<FakePicturePileImpl> active_pile =
|
| FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
|
| - SetupTrees(pending_pile, active_pile);
|
| - pending_layer_->set_fixed_tile_size(tile_size);
|
| - active_layer_->set_fixed_tile_size(tile_size);
|
| -
|
| - CreateHighLowResAndSetAllTilesVisible();
|
| + SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
|
|
|
| // Active layer can't have tiles.
|
| EXPECT_FALSE(active_layer_->CanHaveTilings());
|
| @@ -2046,21 +2033,16 @@ TEST_F(PictureLayerImplTest, HighResRequiredIfActiveCantHaveTiles) {
|
| }
|
|
|
| TEST_F(PictureLayerImplTest, HighResRequiredWhenActiveHasDifferentBounds) {
|
| - gfx::Size layer_bounds(200, 200);
|
| - gfx::Size tile_size(100, 100);
|
| - SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
|
| -
|
| gfx::Size pending_layer_bounds(400, 400);
|
| - pending_layer_->SetBounds(pending_layer_bounds);
|
| + gfx::Size active_layer_bounds(200, 200);
|
| + gfx::Size tile_size(100, 100);
|
|
|
| - CreateHighLowResAndSetAllTilesVisible();
|
| - // TODO(vmpstr): This is confusing. Rework the test to create different bounds
|
| - // on different trees instead of fudging tilings.
|
| - pending_layer_->HighResTiling()->ComputeTilePriorityRects(
|
| - gfx::Rect(pending_layer_bounds), 1.f, 1.f, Occlusion());
|
| + scoped_refptr<FakePicturePileImpl> pending_pile =
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, pending_layer_bounds);
|
| + scoped_refptr<FakePicturePileImpl> active_pile =
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, active_layer_bounds);
|
|
|
| - pending_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();
|
| - active_layer_->SetAllTilesReady();
|
| + SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
|
|
|
| // Since the active layer has different bounds, the pending layer needs all
|
| // high res tiles in order to activate.
|
| @@ -2108,9 +2090,15 @@ TEST_F(PictureLayerImplTest, ActivateUninitializedLayer) {
|
| }
|
|
|
| TEST_F(PictureLayerImplTest, ShareTilesOnNextFrame) {
|
| - SetupDefaultTrees(gfx::Size(1500, 1500));
|
| + gfx::Size layer_bounds(1500, 1500);
|
| + gfx::Size tile_size(100, 100);
|
|
|
| - PictureLayerTiling* tiling = pending_layer_->AddTiling(1.f);
|
| + scoped_refptr<FakePicturePileImpl> pending_pile =
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| +
|
| + SetupPendingTree(pending_pile);
|
| +
|
| + PictureLayerTiling* tiling = pending_layer_->HighResTiling();
|
| gfx::Rect first_invalidate = tiling->TilingDataForTesting().TileBounds(0, 0);
|
| first_invalidate.Inset(tiling->TilingDataForTesting().border_texels(),
|
| tiling->TilingDataForTesting().border_texels());
|
| @@ -2118,22 +2106,20 @@ TEST_F(PictureLayerImplTest, ShareTilesOnNextFrame) {
|
| second_invalidate.Inset(tiling->TilingDataForTesting().border_texels(),
|
| tiling->TilingDataForTesting().border_texels());
|
|
|
| + ActivateTree();
|
| +
|
| // Make a pending tree with an invalidated raster tile 0,0.
|
| - tiling->CreateAllTilesForTesting();
|
| - pending_layer_->set_invalidation(first_invalidate);
|
| + SetupPendingTreeWithInvalidation(pending_pile, first_invalidate);
|
|
|
| // Activate and make a pending tree with an invalidated raster tile 1,1.
|
| ActivateTree();
|
|
|
| - host_impl_.CreatePendingTree();
|
| - pending_layer_ = static_cast<FakePictureLayerImpl*>(
|
| - host_impl_.pending_tree()->root_layer());
|
| - pending_layer_->set_invalidation(second_invalidate);
|
| + SetupPendingTreeWithInvalidation(pending_pile, second_invalidate);
|
|
|
| PictureLayerTiling* pending_tiling = pending_layer_->tilings()->tiling_at(0);
|
| PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(0);
|
|
|
| - pending_tiling->CreateAllTilesForTesting();
|
| + // pending_tiling->CreateAllTilesForTesting();
|
|
|
| // Tile 0,0 should be shared, but tile 1,1 should not be.
|
| EXPECT_EQ(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
|
| @@ -2162,180 +2148,138 @@ TEST_F(PictureLayerImplTest, ShareTilesOnNextFrame) {
|
| EXPECT_FALSE(pending_tiling->TileAt(1, 1)->is_shared());
|
| }
|
|
|
| -TEST_F(PictureLayerImplTest, ShareTilesOnSync) {
|
| +TEST_F(PictureLayerImplTest, ShareTilesWithNoInvalidation) {
|
| SetupDefaultTrees(gfx::Size(1500, 1500));
|
| - AddDefaultTilingsWithInvalidation(gfx::Rect());
|
|
|
| - host_impl_.ActivateSyncTree();
|
| - host_impl_.CreatePendingTree();
|
| - active_layer_ = static_cast<FakePictureLayerImpl*>(
|
| - host_impl_.active_tree()->LayerById(id_));
|
| + EXPECT_GE(active_layer_->num_tilings(), 1u);
|
| + EXPECT_GE(pending_layer_->num_tilings(), 1u);
|
| +
|
| + // No invalidation, so all tiles are shared.
|
| + PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(0);
|
| + PictureLayerTiling* pending_tiling = pending_layer_->tilings()->tiling_at(0);
|
| + ASSERT_TRUE(active_tiling);
|
| + ASSERT_TRUE(pending_tiling);
|
|
|
| - // Force the active tree to sync to the pending tree "post-commit".
|
| - pending_layer_->DoPostCommitInitializationIfNeeded();
|
| + EXPECT_TRUE(active_tiling->TileAt(0, 0));
|
| + EXPECT_TRUE(active_tiling->TileAt(1, 0));
|
| + EXPECT_TRUE(active_tiling->TileAt(0, 1));
|
| + EXPECT_TRUE(active_tiling->TileAt(1, 1));
|
|
|
| - // Both invalidations should drop tiles from the pending tree.
|
| - EXPECT_EQ(3u, active_layer_->num_tilings());
|
| - EXPECT_EQ(3u, pending_layer_->num_tilings());
|
| - for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
|
| - PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(i);
|
| - PictureLayerTiling* pending_tiling =
|
| - pending_layer_->tilings()->tiling_at(i);
|
| -
|
| - ASSERT_TRUE(active_tiling);
|
| - ASSERT_TRUE(pending_tiling);
|
| -
|
| - EXPECT_TRUE(active_tiling->TileAt(0, 0));
|
| - EXPECT_TRUE(active_tiling->TileAt(1, 0));
|
| - EXPECT_TRUE(active_tiling->TileAt(0, 1));
|
| - EXPECT_TRUE(active_tiling->TileAt(1, 1));
|
| -
|
| - EXPECT_TRUE(pending_tiling->TileAt(0, 0));
|
| - EXPECT_TRUE(pending_tiling->TileAt(1, 0));
|
| - EXPECT_TRUE(pending_tiling->TileAt(0, 1));
|
| - EXPECT_TRUE(pending_tiling->TileAt(1, 1));
|
| -
|
| - EXPECT_EQ(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
|
| - EXPECT_TRUE(active_tiling->TileAt(0, 0)->is_shared());
|
| - EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
|
| - EXPECT_TRUE(active_tiling->TileAt(1, 0)->is_shared());
|
| - EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
|
| - EXPECT_TRUE(active_tiling->TileAt(0, 1)->is_shared());
|
| - EXPECT_EQ(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
|
| - EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
|
| - }
|
| + EXPECT_TRUE(pending_tiling->TileAt(0, 0));
|
| + EXPECT_TRUE(pending_tiling->TileAt(1, 0));
|
| + EXPECT_TRUE(pending_tiling->TileAt(0, 1));
|
| + EXPECT_TRUE(pending_tiling->TileAt(1, 1));
|
| +
|
| + EXPECT_EQ(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
|
| + EXPECT_TRUE(active_tiling->TileAt(0, 0)->is_shared());
|
| + EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
|
| + EXPECT_TRUE(active_tiling->TileAt(1, 0)->is_shared());
|
| + EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
|
| + EXPECT_TRUE(active_tiling->TileAt(0, 1)->is_shared());
|
| + EXPECT_EQ(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
|
| + EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
|
| }
|
|
|
| -TEST_F(PictureLayerImplTest, ShareInvalidActiveTreeTilesOnSync) {
|
| - SetupDefaultTrees(gfx::Size(1500, 1500));
|
| - AddDefaultTilingsWithInvalidation(gfx::Rect(0, 0, 1, 1));
|
| +TEST_F(PictureLayerImplTest, ShareInvalidActiveTreeTiles) {
|
| + gfx::Size tile_size(100, 100);
|
| + gfx::Size layer_bounds(1500, 1500);
|
|
|
| - // This activates the 0,0,1,1 invalidation.
|
| - host_impl_.ActivateSyncTree();
|
| - host_impl_.CreatePendingTree();
|
| - active_layer_ = static_cast<FakePictureLayerImpl*>(
|
| - host_impl_.active_tree()->LayerById(id_));
|
| + scoped_refptr<FakePicturePileImpl> pending_pile =
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| + scoped_refptr<FakePicturePileImpl> active_pile =
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| + SetupTreesWithInvalidation(pending_pile, active_pile, gfx::Rect(1, 1));
|
| + // Activate the invalidation.
|
| + ActivateTree();
|
| + // Make another pending tree without any invalidation in it.
|
| + scoped_refptr<FakePicturePileImpl> pending_pile2 =
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| + SetupPendingTree(pending_pile2);
|
|
|
| - // Force the active tree to sync to the pending tree "post-commit".
|
| - pending_layer_->DoPostCommitInitializationIfNeeded();
|
| + EXPECT_GE(active_layer_->num_tilings(), 1u);
|
| + EXPECT_GE(pending_layer_->num_tilings(), 1u);
|
|
|
| // The active tree invalidation was handled by the active tiles, so they
|
| // can be shared with the pending tree.
|
| - EXPECT_EQ(3u, active_layer_->num_tilings());
|
| - EXPECT_EQ(3u, pending_layer_->num_tilings());
|
| - for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
|
| - PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(i);
|
| - PictureLayerTiling* pending_tiling =
|
| - pending_layer_->tilings()->tiling_at(i);
|
| -
|
| - ASSERT_TRUE(active_tiling);
|
| - ASSERT_TRUE(pending_tiling);
|
| -
|
| - EXPECT_TRUE(active_tiling->TileAt(0, 0));
|
| - EXPECT_TRUE(active_tiling->TileAt(1, 0));
|
| - EXPECT_TRUE(active_tiling->TileAt(0, 1));
|
| - EXPECT_TRUE(active_tiling->TileAt(1, 1));
|
| -
|
| - EXPECT_TRUE(pending_tiling->TileAt(0, 0));
|
| - EXPECT_TRUE(pending_tiling->TileAt(1, 0));
|
| - EXPECT_TRUE(pending_tiling->TileAt(0, 1));
|
| - EXPECT_TRUE(pending_tiling->TileAt(1, 1));
|
| -
|
| - EXPECT_EQ(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
|
| - EXPECT_TRUE(active_tiling->TileAt(0, 0)->is_shared());
|
| - EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
|
| - EXPECT_TRUE(active_tiling->TileAt(1, 0)->is_shared());
|
| - EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
|
| - EXPECT_TRUE(active_tiling->TileAt(0, 1)->is_shared());
|
| - EXPECT_EQ(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
|
| - EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
|
| - }
|
| -}
|
| + PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(0);
|
| + PictureLayerTiling* pending_tiling = pending_layer_->tilings()->tiling_at(0);
|
| + ASSERT_TRUE(active_tiling);
|
| + ASSERT_TRUE(pending_tiling);
|
|
|
| -TEST_F(PictureLayerImplTest, RemoveInvalidPendingTreeTilesOnSync) {
|
| - SetupDefaultTrees(gfx::Size(1500, 1500));
|
| - AddDefaultTilingsWithInvalidation(gfx::Rect());
|
| + EXPECT_TRUE(active_tiling->TileAt(0, 0));
|
| + EXPECT_TRUE(active_tiling->TileAt(1, 0));
|
| + EXPECT_TRUE(active_tiling->TileAt(0, 1));
|
| + EXPECT_TRUE(active_tiling->TileAt(1, 1));
|
|
|
| - host_impl_.ActivateSyncTree();
|
| - host_impl_.CreatePendingTree();
|
| - active_layer_ = static_cast<FakePictureLayerImpl*>(
|
| - host_impl_.active_tree()->LayerById(id_));
|
| + EXPECT_TRUE(pending_tiling->TileAt(0, 0));
|
| + EXPECT_TRUE(pending_tiling->TileAt(1, 0));
|
| + EXPECT_TRUE(pending_tiling->TileAt(0, 1));
|
| + EXPECT_TRUE(pending_tiling->TileAt(1, 1));
|
|
|
| - // Set some invalidation on the pending tree "during commit". We should
|
| - // replace raster tiles that touch this.
|
| - pending_layer_->set_invalidation(gfx::Rect(1, 1));
|
| + EXPECT_EQ(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
|
| + EXPECT_TRUE(active_tiling->TileAt(0, 0)->is_shared());
|
| + EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
|
| + EXPECT_TRUE(active_tiling->TileAt(1, 0)->is_shared());
|
| + EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
|
| + EXPECT_TRUE(active_tiling->TileAt(0, 1)->is_shared());
|
| + EXPECT_EQ(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
|
| + EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
|
| +}
|
|
|
| - // Force the active tree to sync to the pending tree "post-commit".
|
| - pending_layer_->DoPostCommitInitializationIfNeeded();
|
| +TEST_F(PictureLayerImplTest, RecreateInvalidPendingTreeTiles) {
|
| + // Set some invalidation on the pending tree. We should replace raster tiles
|
| + // that touch this.
|
| + SetupDefaultTreesWithInvalidation(gfx::Size(1500, 1500), gfx::Rect(1, 1));
|
| +
|
| + EXPECT_GE(active_layer_->num_tilings(), 1u);
|
| + EXPECT_GE(pending_layer_->num_tilings(), 1u);
|
|
|
| // The pending tree invalidation means tiles can not be shared with the
|
| // active tree.
|
| - EXPECT_EQ(3u, active_layer_->num_tilings());
|
| - EXPECT_EQ(3u, pending_layer_->num_tilings());
|
| - for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
|
| - PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(i);
|
| - PictureLayerTiling* pending_tiling =
|
| - pending_layer_->tilings()->tiling_at(i);
|
| -
|
| - ASSERT_TRUE(active_tiling);
|
| - ASSERT_TRUE(pending_tiling);
|
| -
|
| - EXPECT_TRUE(active_tiling->TileAt(0, 0));
|
| - EXPECT_TRUE(active_tiling->TileAt(1, 0));
|
| - EXPECT_TRUE(active_tiling->TileAt(0, 1));
|
| - EXPECT_TRUE(active_tiling->TileAt(1, 1));
|
| -
|
| - EXPECT_TRUE(pending_tiling->TileAt(0, 0));
|
| - EXPECT_TRUE(pending_tiling->TileAt(1, 0));
|
| - EXPECT_TRUE(pending_tiling->TileAt(0, 1));
|
| - EXPECT_TRUE(pending_tiling->TileAt(1, 1));
|
| -
|
| - EXPECT_NE(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
|
| - EXPECT_FALSE(active_tiling->TileAt(0, 0)->is_shared());
|
| - EXPECT_FALSE(pending_tiling->TileAt(0, 0)->is_shared());
|
| - EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
|
| - EXPECT_TRUE(active_tiling->TileAt(1, 0)->is_shared());
|
| - EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
|
| - EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
|
| - EXPECT_EQ(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
|
| - EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
|
| - }
|
| + PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(0);
|
| + PictureLayerTiling* pending_tiling = pending_layer_->tilings()->tiling_at(0);
|
| + ASSERT_TRUE(active_tiling);
|
| + ASSERT_TRUE(pending_tiling);
|
| +
|
| + EXPECT_TRUE(active_tiling->TileAt(0, 0));
|
| + EXPECT_TRUE(active_tiling->TileAt(1, 0));
|
| + EXPECT_TRUE(active_tiling->TileAt(0, 1));
|
| + EXPECT_TRUE(active_tiling->TileAt(1, 1));
|
| +
|
| + EXPECT_TRUE(pending_tiling->TileAt(0, 0));
|
| + EXPECT_TRUE(pending_tiling->TileAt(1, 0));
|
| + EXPECT_TRUE(pending_tiling->TileAt(0, 1));
|
| + EXPECT_TRUE(pending_tiling->TileAt(1, 1));
|
| +
|
| + EXPECT_NE(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
|
| + EXPECT_FALSE(active_tiling->TileAt(0, 0)->is_shared());
|
| + EXPECT_FALSE(pending_tiling->TileAt(0, 0)->is_shared());
|
| + EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
|
| + EXPECT_TRUE(active_tiling->TileAt(1, 0)->is_shared());
|
| + EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
|
| + EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
|
| + EXPECT_EQ(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
|
| + EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
|
| }
|
|
|
| -TEST_F(PictureLayerImplTest, SyncTilingAfterReleaseResource) {
|
| - SetupDefaultTrees(gfx::Size(10, 10));
|
| - host_impl_.active_tree()->UpdateDrawProperties();
|
| - EXPECT_FALSE(host_impl_.active_tree()->needs_update_draw_properties());
|
| +TEST_F(PictureLayerImplTest, SyncTilingAfterGpuRasterizationToggles) {
|
| + base::TimeTicks time_ticks;
|
| + time_ticks += base::TimeDelta::FromMilliseconds(1);
|
| + host_impl_.SetCurrentBeginFrameArgs(
|
| + CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
|
|
|
| - // Contrived unit test of a real crash. A layer is transparent during a
|
| - // context loss, and later becomes opaque, causing active layer SyncTiling to
|
| - // be called.
|
| - float new_scale = 1.f;
|
| - active_layer_->ReleaseResources();
|
| - pending_layer_->ReleaseResources();
|
| - EXPECT_FALSE(active_layer_->tilings()->FindTilingWithScale(new_scale));
|
| - pending_layer_->AddTiling(new_scale);
|
| - EXPECT_TRUE(active_layer_->tilings()->FindTilingWithScale(new_scale));
|
| -
|
| - // UpdateDrawProperties early-outs if the tree doesn't need it. It is also
|
| - // responsible for calling ManageTilings. These checks verify that
|
| - // ReleaseResources has set needs update draw properties so that the
|
| - // new tiling gets the appropriate resolution set in ManageTilings.
|
| - EXPECT_TRUE(host_impl_.active_tree()->needs_update_draw_properties());
|
| - host_impl_.active_tree()->UpdateDrawProperties();
|
| - PictureLayerTiling* high_res =
|
| - active_layer_->tilings()->FindTilingWithScale(new_scale);
|
| - ASSERT_TRUE(!!high_res);
|
| - EXPECT_EQ(HIGH_RESOLUTION, high_res->resolution());
|
| -}
|
| + gfx::Size tile_size(100, 100);
|
| + gfx::Size layer_bounds(10, 10);
|
|
|
| -TEST_F(PictureLayerImplTest, SyncTilingAfterGpuRasterizationToggles) {
|
| - SetupDefaultTrees(gfx::Size(10, 10));
|
| + scoped_refptr<FakePicturePileImpl> pending_pile =
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| + scoped_refptr<FakePicturePileImpl> active_pile =
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| +
|
| + SetupTrees(pending_pile, active_pile);
|
|
|
| - const float kScale = 1.f;
|
| - pending_layer_->AddTiling(kScale);
|
| - EXPECT_TRUE(pending_layer_->tilings()->FindTilingWithScale(kScale));
|
| - EXPECT_TRUE(active_layer_->tilings()->FindTilingWithScale(kScale));
|
| + EXPECT_TRUE(pending_layer_->tilings()->FindTilingWithScale(1.f));
|
| + EXPECT_TRUE(active_layer_->tilings()->FindTilingWithScale(1.f));
|
|
|
| // Gpu rasterization is disabled by default.
|
| EXPECT_FALSE(host_impl_.use_gpu_rasterization());
|
| @@ -2346,9 +2290,17 @@ TEST_F(PictureLayerImplTest, SyncTilingAfterGpuRasterizationToggles) {
|
|
|
| // Make sure that we can still add tiling to the pending layer,
|
| // that gets synced to the active layer.
|
| - pending_layer_->AddTiling(kScale);
|
| - EXPECT_TRUE(pending_layer_->tilings()->FindTilingWithScale(kScale));
|
| - EXPECT_TRUE(active_layer_->tilings()->FindTilingWithScale(kScale));
|
| + time_ticks += base::TimeDelta::FromMilliseconds(1);
|
| + host_impl_.SetCurrentBeginFrameArgs(
|
| + CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
|
| + host_impl_.pending_tree()->UpdateDrawProperties();
|
| + EXPECT_TRUE(pending_layer_->tilings()->FindTilingWithScale(1.f));
|
| +
|
| + ActivateTree();
|
| + EXPECT_TRUE(active_layer_->tilings()->FindTilingWithScale(1.f));
|
| +
|
| + SetupPendingTree(pending_pile);
|
| + EXPECT_TRUE(pending_layer_->tilings()->FindTilingWithScale(1.f));
|
|
|
| // Toggling the gpu rasterization clears all tilings on both trees.
|
| EXPECT_TRUE(host_impl_.use_gpu_rasterization());
|
| @@ -2360,72 +2312,62 @@ TEST_F(PictureLayerImplTest, SyncTilingAfterGpuRasterizationToggles) {
|
| TEST_F(PictureLayerImplTest, HighResCreatedWhenBoundsShrink) {
|
| gfx::Size tile_size(100, 100);
|
|
|
| - scoped_refptr<FakePicturePileImpl> active_pile =
|
| - FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(10, 10));
|
| - SetupPendingTree(active_pile);
|
| - ActivateTree();
|
| - host_impl_.active_tree()->UpdateDrawProperties();
|
| - EXPECT_FALSE(host_impl_.active_tree()->needs_update_draw_properties());
|
| + // Put 0.5 as high res.
|
| + host_impl_.SetDeviceScaleFactor(0.5f);
|
|
|
| - SetupDrawPropertiesAndUpdateTiles(
|
| - active_layer_, 0.5f, 0.5f, 0.5f, 0.5f, false);
|
| - active_layer_->tilings()->RemoveAllTilings();
|
| - PictureLayerTiling* tiling = active_layer_->AddTiling(0.5f);
|
| - active_layer_->AddTiling(1.5f);
|
| - active_layer_->AddTiling(0.25f);
|
| - tiling->set_resolution(HIGH_RESOLUTION);
|
| + scoped_refptr<FakePicturePileImpl> pending_pile =
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(10, 10));
|
| + SetupPendingTree(pending_pile);
|
|
|
| // Sanity checks.
|
| - ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
|
| - ASSERT_EQ(tiling, active_layer_->tilings()->FindTilingWithScale(0.5f));
|
| + EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
|
| + EXPECT_TRUE(pending_layer_->tilings()->FindTilingWithScale(0.5f));
|
|
|
| - // Now, set the bounds to be 1x1 (so that minimum contents scale becomes
|
| - // 1.0f). Note that we should also ensure that the pending layer needs post
|
| - // commit initialization, since this is what would happen during commit. In
|
| - // other words we want the pending layer to sync from the active layer.
|
| - scoped_refptr<FakePicturePileImpl> pending_pile =
|
| + ActivateTree();
|
| +
|
| + // Now, set the bounds to be 1x1, so that minimum contents scale becomes 1.
|
| + pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(1, 1));
|
| SetupPendingTree(pending_pile);
|
|
|
| - // Update the draw properties: sync from active tree should happen here.
|
| - host_impl_.pending_tree()->UpdateDrawProperties();
|
| - EXPECT_FALSE(pending_layer_->needs_post_commit_initialization());
|
| -
|
| // Another sanity check.
|
| - ASSERT_EQ(1.f, pending_layer_->MinimumContentsScale());
|
| + EXPECT_EQ(1.f, pending_layer_->MinimumContentsScale());
|
|
|
| - // Now we should've synced 1.5f tiling, since that's the only one that doesn't
|
| - // violate minimum contents scale. At the same time, we should've created a
|
| - // new high res tiling at scale 1.0f.
|
| - EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
|
| - ASSERT_TRUE(pending_layer_->tilings()->FindTilingWithScale(1.0f));
|
| - EXPECT_EQ(HIGH_RESOLUTION,
|
| - pending_layer_->tilings()->FindTilingWithScale(1.0f)->resolution());
|
| - ASSERT_TRUE(pending_layer_->tilings()->FindTilingWithScale(1.5f));
|
| - EXPECT_EQ(NON_IDEAL_RESOLUTION,
|
| - pending_layer_->tilings()->FindTilingWithScale(1.5f)->resolution());
|
| + // Since the MinContentsScale is 1, the 0.5 tiling should be replaced by a 1.0
|
| + // tiling.
|
| + SetupDrawPropertiesAndUpdateTiles(pending_layer_, 0.5f, 1.f, 1.f, 1.f, false);
|
| +
|
| + EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
|
| + PictureLayerTiling* tiling =
|
| + pending_layer_->tilings()->FindTilingWithScale(1.0f);
|
| + ASSERT_TRUE(tiling);
|
| + EXPECT_EQ(HIGH_RESOLUTION, tiling->resolution());
|
| }
|
|
|
| -TEST_F(PictureLayerImplTest, NoLowResTilingWithGpuRasterization) {
|
| +TEST_F(PictureLayerImplTest, LowResTilingWithoutGpuRasterization) {
|
| gfx::Size default_tile_size(host_impl_.settings().default_tile_size);
|
| gfx::Size layer_bounds(default_tile_size.width() * 4,
|
| default_tile_size.height() * 4);
|
|
|
| + host_impl_.SetUseGpuRasterization(false);
|
| +
|
| SetupDefaultTrees(layer_bounds);
|
| EXPECT_FALSE(host_impl_.use_gpu_rasterization());
|
| - EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
|
| - SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
|
| // Should have a low-res and a high-res tiling.
|
| - ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
|
| + EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
|
| +}
|
|
|
| - ResetTilingsAndRasterScales();
|
| +TEST_F(PictureLayerImplTest, NoLowResTilingWithGpuRasterization) {
|
| + gfx::Size default_tile_size(host_impl_.settings().default_tile_size);
|
| + gfx::Size layer_bounds(default_tile_size.width() * 4,
|
| + default_tile_size.height() * 4);
|
|
|
| host_impl_.SetUseGpuRasterization(true);
|
| - EXPECT_TRUE(host_impl_.use_gpu_rasterization());
|
| - SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
|
|
|
| + SetupDefaultTrees(layer_bounds);
|
| + EXPECT_TRUE(host_impl_.use_gpu_rasterization());
|
| // Should only have the high-res tiling.
|
| - ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
|
| + EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
|
| }
|
|
|
| TEST_F(PictureLayerImplTest, NoTilingIfDoesNotDrawContent) {
|
| @@ -2450,31 +2392,38 @@ TEST_F(PictureLayerImplTest, NoTilingIfDoesNotDrawContent) {
|
|
|
| TEST_F(PictureLayerImplTest, FirstTilingDuringPinch) {
|
| SetupDefaultTrees(gfx::Size(10, 10));
|
| +
|
| + // We start with a tiling at scale 1.
|
| + EXPECT_EQ(1.f, pending_layer_->HighResTiling()->contents_scale());
|
| +
|
| + // When we scale up by 2.3, we get a new tiling that is a power of 2, in this
|
| + // case 4.
|
| host_impl_.PinchGestureBegin();
|
| float high_res_scale = 2.3f;
|
| SetContentsScaleOnBothLayers(high_res_scale, 1.f, 1.f, 1.f, false);
|
| -
|
| - ASSERT_GE(pending_layer_->num_tilings(), 0u);
|
| - EXPECT_FLOAT_EQ(high_res_scale,
|
| - pending_layer_->HighResTiling()->contents_scale());
|
| + EXPECT_EQ(4.f, pending_layer_->HighResTiling()->contents_scale());
|
| }
|
|
|
| -TEST_F(PictureLayerImplTest, FirstTilingTooSmall) {
|
| +TEST_F(PictureLayerImplTest, PinchingTooSmall) {
|
| SetupDefaultTrees(gfx::Size(10, 10));
|
| +
|
| + // We start with a tiling at scale 1.
|
| + EXPECT_EQ(1.f, pending_layer_->HighResTiling()->contents_scale());
|
| +
|
| host_impl_.PinchGestureBegin();
|
| float high_res_scale = 0.0001f;
|
| - EXPECT_GT(pending_layer_->MinimumContentsScale(), high_res_scale);
|
| -
|
| - SetContentsScaleOnBothLayers(high_res_scale, 1.f, 1.f, 1.f, false);
|
| + EXPECT_LT(high_res_scale, pending_layer_->MinimumContentsScale());
|
|
|
| - ASSERT_GE(pending_layer_->num_tilings(), 0u);
|
| + SetContentsScaleOnBothLayers(high_res_scale, 1.f, high_res_scale, 1.f, false);
|
| EXPECT_FLOAT_EQ(pending_layer_->MinimumContentsScale(),
|
| pending_layer_->HighResTiling()->contents_scale());
|
| }
|
|
|
| -TEST_F(PictureLayerImplTest, PinchingTooSmall) {
|
| +TEST_F(PictureLayerImplTest, PinchingTooSmallWithContentsScale) {
|
| SetupDefaultTrees(gfx::Size(10, 10));
|
|
|
| + ResetTilingsAndRasterScales();
|
| +
|
| float contents_scale = 0.15f;
|
| SetContentsScaleOnBothLayers(contents_scale, 1.f, 1.f, 1.f, false);
|
|
|
| @@ -2542,22 +2491,18 @@ TEST_F(DeferredInitPictureLayerImplTest, PreventUpdateTilesDuringLostContext) {
|
| }
|
|
|
| TEST_F(PictureLayerImplTest, HighResTilingDuringAnimationForCpuRasterization) {
|
| - gfx::Size layer_bounds(100, 100);
|
| gfx::Size viewport_size(1000, 1000);
|
| - SetupDefaultTrees(layer_bounds);
|
| host_impl_.SetViewportSize(viewport_size);
|
|
|
| + gfx::Size layer_bounds(100, 100);
|
| + SetupDefaultTrees(layer_bounds);
|
| +
|
| float contents_scale = 1.f;
|
| - float device_scale = 1.3f;
|
| - float page_scale = 1.4f;
|
| + float device_scale = 1.f;
|
| + float page_scale = 1.f;
|
| float maximum_animation_scale = 1.f;
|
| bool animating_transform = false;
|
|
|
| - SetContentsScaleOnBothLayers(contents_scale,
|
| - device_scale,
|
| - page_scale,
|
| - maximum_animation_scale,
|
| - animating_transform);
|
| EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
|
|
|
| // Since we're CPU-rasterizing, starting an animation should cause tiling
|
| @@ -2781,6 +2726,8 @@ TEST_F(PictureLayerImplTest, TilingSetRasterQueue) {
|
| host_impl_.SetCurrentBeginFrameArgs(
|
| CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
|
|
|
| + host_impl_.SetViewportSize(gfx::Size(500, 500));
|
| +
|
| gfx::Size tile_size(100, 100);
|
| gfx::Size layer_bounds(1000, 1000);
|
|
|
| @@ -2788,24 +2735,10 @@ TEST_F(PictureLayerImplTest, TilingSetRasterQueue) {
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| SetupPendingTree(pending_pile);
|
| + EXPECT_EQ(2u, pending_layer_->num_tilings());
|
|
|
| - ASSERT_TRUE(pending_layer_->CanHaveTilings());
|
| -
|
| - float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
|
| -
|
| - // No tilings.
|
| scoped_ptr<TilingSetRasterQueue> queue =
|
| pending_layer_->CreateRasterQueue(false);
|
| - EXPECT_TRUE(queue->IsEmpty());
|
| -
|
| - pending_layer_->AddTiling(low_res_factor);
|
| - pending_layer_->AddTiling(0.3f);
|
| - pending_layer_->AddTiling(0.7f);
|
| - PictureLayerTiling* high_res_tiling = pending_layer_->AddTiling(1.0f);
|
| - pending_layer_->AddTiling(2.0f);
|
| -
|
| - host_impl_.SetViewportSize(gfx::Size(500, 500));
|
| - host_impl_.pending_tree()->UpdateDrawProperties();
|
|
|
| std::set<Tile*> unique_tiles;
|
| bool reached_prepaint = false;
|
| @@ -2883,7 +2816,8 @@ TEST_F(PictureLayerImplTest, TilingSetRasterQueue) {
|
| gfx::Rect(0, 0, 500, 500);
|
| pending_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
|
|
|
| - std::vector<Tile*> high_res_tiles = high_res_tiling->AllTilesForTesting();
|
| + std::vector<Tile*> high_res_tiles =
|
| + pending_layer_->HighResTiling()->AllTilesForTesting();
|
| for (std::vector<Tile*>::iterator tile_it = high_res_tiles.begin();
|
| tile_it != high_res_tiles.end();
|
| ++tile_it) {
|
| @@ -2916,33 +2850,23 @@ TEST_F(PictureLayerImplTest, TilingSetRasterQueue) {
|
| TEST_F(PictureLayerImplTest, TilingSetEvictionQueue) {
|
| gfx::Size tile_size(100, 100);
|
| gfx::Size layer_bounds(1000, 1000);
|
| + float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
|
| +
|
| + host_impl_.SetViewportSize(gfx::Size(500, 500));
|
|
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| + // TODO(vmpstr): Add a test with tilings other than high/low res on the active
|
| + // tree.
|
| SetupPendingTree(pending_pile);
|
| -
|
| - ASSERT_TRUE(pending_layer_->CanHaveTilings());
|
| -
|
| - float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
|
| -
|
| - std::vector<PictureLayerTiling*> tilings;
|
| - tilings.push_back(pending_layer_->AddTiling(low_res_factor));
|
| - tilings.push_back(pending_layer_->AddTiling(0.3f));
|
| - tilings.push_back(pending_layer_->AddTiling(0.7f));
|
| - tilings.push_back(pending_layer_->AddTiling(1.0f));
|
| - tilings.push_back(pending_layer_->AddTiling(2.0f));
|
| -
|
| - host_impl_.SetViewportSize(gfx::Size(500, 500));
|
| - host_impl_.pending_tree()->UpdateDrawProperties();
|
| + EXPECT_EQ(2u, pending_layer_->num_tilings());
|
|
|
| std::vector<Tile*> all_tiles;
|
| - for (std::vector<PictureLayerTiling*>::iterator tiling_iterator =
|
| - tilings.begin();
|
| - tiling_iterator != tilings.end();
|
| - ++tiling_iterator) {
|
| - std::vector<Tile*> tiles = (*tiling_iterator)->AllTilesForTesting();
|
| - std::copy(tiles.begin(), tiles.end(), std::back_inserter(all_tiles));
|
| + for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
|
| + PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
|
| + std::vector<Tile*> tiles = tiling->AllTilesForTesting();
|
| + all_tiles.insert(all_tiles.end(), tiles.begin(), tiles.end());
|
| }
|
|
|
| std::set<Tile*> all_tiles_set(all_tiles.begin(), all_tiles.end());
|
| @@ -2950,8 +2874,8 @@ TEST_F(PictureLayerImplTest, TilingSetEvictionQueue) {
|
| bool mark_required = false;
|
| size_t number_of_marked_tiles = 0u;
|
| size_t number_of_unmarked_tiles = 0u;
|
| - for (size_t i = 0; i < tilings.size(); ++i) {
|
| - PictureLayerTiling* tiling = tilings.at(i);
|
| + for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
|
| + PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
|
| for (PictureLayerTiling::CoverageIterator iter(
|
| tiling,
|
| pending_layer_->contents_scale_x(),
|
| @@ -2969,8 +2893,8 @@ TEST_F(PictureLayerImplTest, TilingSetEvictionQueue) {
|
| }
|
|
|
| // Sanity checks.
|
| - EXPECT_EQ(91u, all_tiles.size());
|
| - EXPECT_EQ(91u, all_tiles_set.size());
|
| + EXPECT_EQ(17u, all_tiles.size());
|
| + EXPECT_EQ(17u, all_tiles_set.size());
|
| EXPECT_GT(number_of_marked_tiles, 1u);
|
| EXPECT_GT(number_of_unmarked_tiles, 1u);
|
|
|
| @@ -2982,10 +2906,12 @@ TEST_F(PictureLayerImplTest, TilingSetEvictionQueue) {
|
| host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles);
|
|
|
| std::set<Tile*> unique_tiles;
|
| - float expected_scales[] = {2.0f, 0.3f, 0.7f, low_res_factor, 1.0f};
|
| + float expected_scales[] = {low_res_factor, 1.f};
|
| size_t scale_index = 0;
|
| bool reached_visible = false;
|
| Tile* last_tile = nullptr;
|
| + size_t distance_decreasing = 0;
|
| + size_t distance_increasing = 0;
|
| queue = pending_layer_->CreateEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES);
|
| while (!queue->IsEmpty()) {
|
| Tile* tile = queue->Top();
|
| @@ -3013,24 +2939,28 @@ TEST_F(PictureLayerImplTest, TilingSetEvictionQueue) {
|
| EXPECT_FLOAT_EQ(tile->contents_scale(), expected_scales[scale_index]);
|
| unique_tiles.insert(tile);
|
|
|
| - // If the tile is the same rough bin as last tile (same activation, bin, and
|
| - // scale), then distance should be decreasing.
|
| if (tile->required_for_activation() ==
|
| last_tile->required_for_activation() &&
|
| priority.priority_bin ==
|
| last_tile->priority(PENDING_TREE).priority_bin &&
|
| std::abs(tile->contents_scale() - last_tile->contents_scale()) <
|
| std::numeric_limits<float>::epsilon()) {
|
| - EXPECT_LE(priority.distance_to_visible,
|
| - last_tile->priority(PENDING_TREE).distance_to_visible);
|
| + if (priority.distance_to_visible <=
|
| + last_tile->priority(PENDING_TREE).distance_to_visible)
|
| + ++distance_decreasing;
|
| + else
|
| + ++distance_increasing;
|
| }
|
|
|
| last_tile = tile;
|
| queue->Pop();
|
| }
|
|
|
| + // 4 high res tiles are inside the viewport, the rest are evicted.
|
| EXPECT_TRUE(reached_visible);
|
| - EXPECT_EQ(65u, unique_tiles.size());
|
| + EXPECT_EQ(12u, unique_tiles.size());
|
| + EXPECT_EQ(1u, distance_increasing);
|
| + EXPECT_EQ(11u, distance_decreasing);
|
|
|
| scale_index = 0;
|
| bool reached_required = false;
|
| @@ -3069,16 +2999,12 @@ TEST_F(PictureLayerImplTest, Occlusion) {
|
| gfx::Size viewport_size(1000, 1000);
|
|
|
| LayerTestCommon::LayerImplTest impl;
|
| + host_impl_.SetViewportSize(viewport_size);
|
|
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(layer_bounds, layer_bounds);
|
| - SetupPendingTree(pending_pile);
|
| - pending_layer_->SetBounds(layer_bounds);
|
| + SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
|
| ActivateTree();
|
| - active_layer_->set_fixed_tile_size(tile_size);
|
| -
|
| - host_impl_.SetViewportSize(viewport_size);
|
| - host_impl_.active_tree()->UpdateDrawProperties();
|
|
|
| std::vector<Tile*> tiles =
|
| active_layer_->HighResTiling()->AllTilesForTesting();
|
| @@ -3121,6 +3047,8 @@ TEST_F(PictureLayerImplTest, RasterScaleChangeWithoutAnimation) {
|
| gfx::Size tile_size(host_impl_.settings().default_tile_size);
|
| SetupDefaultTrees(tile_size);
|
|
|
| + ResetTilingsAndRasterScales();
|
| +
|
| float contents_scale = 2.f;
|
| float device_scale = 1.f;
|
| float page_scale = 1.f;
|
| @@ -3161,15 +3089,9 @@ TEST_F(PictureLayerImplTest, LowResReadyToDrawNotEnoughToActivate) {
|
| gfx::Size tile_size(100, 100);
|
| gfx::Size layer_bounds(1000, 1000);
|
|
|
| - host_impl_.SetViewportSize(layer_bounds);
|
| -
|
| - SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
|
| -
|
| // Make sure some tiles are not shared.
|
| - pending_layer_->set_invalidation(gfx::Rect(gfx::Point(50, 50), tile_size));
|
| -
|
| - CreateHighLowResAndSetAllTilesVisible();
|
| - active_layer_->SetAllTilesReady();
|
| + gfx::Rect invalidation(gfx::Point(50, 50), tile_size);
|
| + SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, invalidation);
|
|
|
| // All pending layer tiles required are not ready.
|
| EXPECT_FALSE(pending_layer_->AllTilesRequiredForActivationAreReadyToDraw());
|
| @@ -3190,15 +3112,9 @@ TEST_F(PictureLayerImplTest, HighResReadyToDrawEnoughToActivate) {
|
| gfx::Size tile_size(100, 100);
|
| gfx::Size layer_bounds(1000, 1000);
|
|
|
| - host_impl_.SetViewportSize(layer_bounds);
|
| -
|
| - SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
|
| -
|
| // Make sure some tiles are not shared.
|
| - pending_layer_->set_invalidation(gfx::Rect(gfx::Point(50, 50), tile_size));
|
| -
|
| - CreateHighLowResAndSetAllTilesVisible();
|
| - active_layer_->SetAllTilesReady();
|
| + gfx::Rect invalidation(gfx::Point(50, 50), tile_size);
|
| + SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, invalidation);
|
|
|
| // All pending layer tiles required are not ready.
|
| EXPECT_FALSE(pending_layer_->AllTilesRequiredForActivationAreReadyToDraw());
|
| @@ -3215,14 +3131,9 @@ TEST_F(PictureLayerImplTest,
|
| gfx::Size tile_size(100, 100);
|
| gfx::Size layer_bounds(1000, 1000);
|
|
|
| - host_impl_.SetViewportSize(layer_bounds);
|
| -
|
| - SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
|
| -
|
| // Make sure some tiles are not shared.
|
| - pending_layer_->set_invalidation(gfx::Rect(gfx::Point(50, 50), tile_size));
|
| -
|
| - CreateHighLowResAndSetAllTilesVisible();
|
| + gfx::Rect invalidation(gfx::Point(50, 50), tile_size);
|
| + SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, invalidation);
|
|
|
| // Initialize all high-res tiles in the active layer.
|
| active_layer_->SetAllTilesReadyInTiling(active_layer_->HighResTiling());
|
| @@ -3241,33 +3152,83 @@ TEST_F(PictureLayerImplTest, SharedActiveHighResReadyNotEnoughToActivate) {
|
| gfx::Size tile_size(100, 100);
|
| gfx::Size layer_bounds(1000, 1000);
|
|
|
| - host_impl_.SetViewportSize(layer_bounds);
|
| -
|
| - SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
|
| -
|
| // Make sure some tiles are not shared.
|
| - pending_layer_->set_invalidation(gfx::Rect(gfx::Point(50, 50), tile_size));
|
| -
|
| - CreateHighLowResAndSetAllTilesVisible();
|
| + gfx::Rect invalidation(gfx::Point(50, 50), tile_size);
|
| + SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, invalidation);
|
|
|
| // Initialize all high-res tiles in the active layer.
|
| active_layer_->SetAllTilesReadyInTiling(active_layer_->HighResTiling());
|
|
|
| - // The unshared high-res tiles are not ready, so we cannot activate.
|
| - EXPECT_FALSE(pending_layer_->AllTilesRequiredForActivationAreReadyToDraw());
|
| + // The unshared high-res tiles are not ready, so we cannot activate.
|
| + EXPECT_FALSE(pending_layer_->AllTilesRequiredForActivationAreReadyToDraw());
|
| +
|
| + // When the unshared pending high-res tiles are ready, we can activate.
|
| + pending_layer_->SetAllTilesReadyInTiling(pending_layer_->HighResTiling());
|
| + EXPECT_TRUE(pending_layer_->AllTilesRequiredForActivationAreReadyToDraw());
|
| +}
|
| +
|
| +TEST_F(NoLowResPictureLayerImplTest, ManageTilingsCreatesTilings) {
|
| + gfx::Size tile_size(400, 400);
|
| + gfx::Size layer_bounds(1300, 1900);
|
| +
|
| + scoped_refptr<FakePicturePileImpl> pending_pile =
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| + scoped_refptr<FakePicturePileImpl> active_pile =
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| +
|
| + SetupTrees(pending_pile, active_pile);
|
| +
|
| + float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
|
| + EXPECT_LT(low_res_factor, 1.f);
|
| +
|
| + ResetTilingsAndRasterScales();
|
| +
|
| + SetupDrawPropertiesAndUpdateTiles(active_layer_,
|
| + 6.f, // ideal contents scale
|
| + 3.f, // device scale
|
| + 2.f, // page scale
|
| + 1.f, // maximum animation scale
|
| + false);
|
| + ASSERT_EQ(1u, active_layer_->tilings()->num_tilings());
|
| + EXPECT_FLOAT_EQ(6.f,
|
| + active_layer_->tilings()->tiling_at(0)->contents_scale());
|
| +
|
| + // If we change the page scale factor, then we should get new tilings.
|
| + SetupDrawPropertiesAndUpdateTiles(active_layer_,
|
| + 6.6f, // ideal contents scale
|
| + 3.f, // device scale
|
| + 2.2f, // page scale
|
| + 1.f, // maximum animation scale
|
| + false);
|
| + ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
|
| + EXPECT_FLOAT_EQ(6.6f,
|
| + active_layer_->tilings()->tiling_at(0)->contents_scale());
|
| +
|
| + // If we change the device scale factor, then we should get new tilings.
|
| + SetupDrawPropertiesAndUpdateTiles(active_layer_,
|
| + 7.26f, // ideal contents scale
|
| + 3.3f, // device scale
|
| + 2.2f, // page scale
|
| + 1.f, // maximum animation scale
|
| + false);
|
| + ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
|
| + EXPECT_FLOAT_EQ(7.26f,
|
| + active_layer_->tilings()->tiling_at(0)->contents_scale());
|
|
|
| - // When the unshared pending high-res tiles are ready, we can activate.
|
| - pending_layer_->SetAllTilesReadyInTiling(pending_layer_->HighResTiling());
|
| - EXPECT_TRUE(pending_layer_->AllTilesRequiredForActivationAreReadyToDraw());
|
| + // If we change the device scale factor, but end up at the same total scale
|
| + // factor somehow, then we don't get new tilings.
|
| + SetupDrawPropertiesAndUpdateTiles(active_layer_,
|
| + 7.26f, // ideal contents scale
|
| + 2.2f, // device scale
|
| + 3.3f, // page scale
|
| + 1.f, // maximum animation scale
|
| + false);
|
| + ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
|
| + EXPECT_FLOAT_EQ(7.26f,
|
| + active_layer_->tilings()->tiling_at(0)->contents_scale());
|
| }
|
|
|
| -class NoLowResPictureLayerImplTest : public PictureLayerImplTest {
|
| - public:
|
| - NoLowResPictureLayerImplTest()
|
| - : PictureLayerImplTest(NoLowResTilingsSettings()) {}
|
| -};
|
| -
|
| -TEST_F(NoLowResPictureLayerImplTest, ManageTilingsCreatesTilings) {
|
| +TEST_F(NoLowResPictureLayerImplTest, PendingLayerOnlyHasHighResTiling) {
|
| gfx::Size tile_size(400, 400);
|
| gfx::Size layer_bounds(1300, 1900);
|
|
|
| @@ -3277,11 +3238,12 @@ TEST_F(NoLowResPictureLayerImplTest, ManageTilingsCreatesTilings) {
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| SetupTrees(pending_pile, active_pile);
|
| - EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
|
|
|
| float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
|
| EXPECT_LT(low_res_factor, 1.f);
|
|
|
| + ResetTilingsAndRasterScales();
|
| +
|
| SetupDrawPropertiesAndUpdateTiles(pending_layer_,
|
| 6.f, // ideal contents scale
|
| 3.f, // device scale
|
| @@ -3299,7 +3261,7 @@ TEST_F(NoLowResPictureLayerImplTest, ManageTilingsCreatesTilings) {
|
| 2.2f, // page scale
|
| 1.f, // maximum animation scale
|
| false);
|
| - ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
|
| + ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
|
| EXPECT_FLOAT_EQ(6.6f,
|
| pending_layer_->tilings()->tiling_at(0)->contents_scale());
|
|
|
| @@ -3310,7 +3272,7 @@ TEST_F(NoLowResPictureLayerImplTest, ManageTilingsCreatesTilings) {
|
| 2.2f, // page scale
|
| 1.f, // maximum animation scale
|
| false);
|
| - ASSERT_EQ(3u, pending_layer_->tilings()->num_tilings());
|
| + ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
|
| EXPECT_FLOAT_EQ(7.26f,
|
| pending_layer_->tilings()->tiling_at(0)->contents_scale());
|
|
|
| @@ -3322,7 +3284,7 @@ TEST_F(NoLowResPictureLayerImplTest, ManageTilingsCreatesTilings) {
|
| 3.3f, // page scale
|
| 1.f, // maximum animation scale
|
| false);
|
| - ASSERT_EQ(3u, pending_layer_->tilings()->num_tilings());
|
| + ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
|
| EXPECT_FLOAT_EQ(7.26f,
|
| pending_layer_->tilings()->tiling_at(0)->contents_scale());
|
| }
|
| @@ -3331,11 +3293,7 @@ TEST_F(NoLowResPictureLayerImplTest, AllHighResRequiredEvenIfShared) {
|
| gfx::Size layer_bounds(400, 400);
|
| gfx::Size tile_size(100, 100);
|
|
|
| - host_impl_.SetViewportSize(layer_bounds);
|
| -
|
| - SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
|
| -
|
| - CreateHighLowResAndSetAllTilesVisible();
|
| + SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
|
|
|
| Tile* some_active_tile =
|
| active_layer_->HighResTiling()->AllTilesForTesting()[0];
|
| @@ -3355,6 +3313,7 @@ TEST_F(NoLowResPictureLayerImplTest, AllHighResRequiredEvenIfShared) {
|
| TEST_F(NoLowResPictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
|
| gfx::Size layer_bounds(400, 400);
|
| gfx::Size tile_size(100, 100);
|
| +
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| // This pile will create tilings, but has no recordings so will not create any
|
| @@ -3364,11 +3323,8 @@ TEST_F(NoLowResPictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
|
| scoped_refptr<FakePicturePileImpl> active_pile =
|
| FakePicturePileImpl::CreateEmptyPileThatThinksItHasRecordings(
|
| tile_size, layer_bounds);
|
| - SetupTrees(pending_pile, active_pile);
|
| - pending_layer_->set_fixed_tile_size(tile_size);
|
| - active_layer_->set_fixed_tile_size(tile_size);
|
|
|
| - CreateHighLowResAndSetAllTilesVisible();
|
| + SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
|
|
|
| // Active layer has tilings, but no tiles due to missing recordings.
|
| EXPECT_TRUE(active_layer_->CanHaveTilings());
|
| @@ -3401,10 +3357,8 @@ TEST_F(NoLowResPictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
|
| scoped_refptr<FakePicturePileImpl> active_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| - SetupTrees(pending_pile, active_pile);
|
| + SetupTreesWithInvalidation(pending_pile, active_pile, Region());
|
|
|
| - Region invalidation;
|
| - AddDefaultTilingsWithInvalidation(invalidation);
|
| SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
|
|
|
| // UpdateTiles with valid viewport. Should update tile viewport.
|
| @@ -3484,7 +3438,6 @@ TEST_F(NoLowResPictureLayerImplTest, CleanUpTilings) {
|
| std::vector<PictureLayerTiling*> used_tilings;
|
|
|
| SetupTrees(pending_pile, active_pile);
|
| - EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
|
|
|
| float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
|
| EXPECT_LT(low_res_factor, 1.f);
|
| @@ -3493,6 +3446,8 @@ TEST_F(NoLowResPictureLayerImplTest, CleanUpTilings) {
|
| float page_scale = 3.2f;
|
| float scale = 1.f;
|
|
|
| + ResetTilingsAndRasterScales();
|
| +
|
| SetContentsScaleOnBothLayers(scale, device_scale, page_scale, 1.f, false);
|
| ASSERT_EQ(1u, active_layer_->tilings()->num_tilings());
|
|
|
| @@ -3578,80 +3533,6 @@ TEST_F(NoLowResPictureLayerImplTest, CleanUpTilings) {
|
| ASSERT_EQ(1u, active_layer_->tilings()->num_tilings());
|
| }
|
|
|
| -TEST_F(PictureLayerImplTest, ScaleCollision) {
|
| - gfx::Size tile_size(400, 400);
|
| - gfx::Size layer_bounds(1300, 1900);
|
| -
|
| - scoped_refptr<FakePicturePileImpl> pending_pile =
|
| - FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| - scoped_refptr<FakePicturePileImpl> active_pile =
|
| - FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| -
|
| - std::vector<PictureLayerTiling*> used_tilings;
|
| -
|
| - SetupTrees(pending_pile, active_pile);
|
| -
|
| - float pending_contents_scale = 1.f;
|
| - float active_contents_scale = 2.f;
|
| - float device_scale_factor = 1.f;
|
| - float page_scale_factor = 1.f;
|
| - float maximum_animation_contents_scale = 1.f;
|
| - bool animating_transform = false;
|
| -
|
| - EXPECT_TRUE(host_impl_.settings().create_low_res_tiling);
|
| - float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
|
| - EXPECT_LT(low_res_factor, 1.f);
|
| -
|
| - SetupDrawPropertiesAndUpdateTiles(pending_layer_,
|
| - pending_contents_scale,
|
| - device_scale_factor,
|
| - page_scale_factor,
|
| - maximum_animation_contents_scale,
|
| - animating_transform);
|
| - SetupDrawPropertiesAndUpdateTiles(active_layer_,
|
| - active_contents_scale,
|
| - device_scale_factor,
|
| - page_scale_factor,
|
| - maximum_animation_contents_scale,
|
| - animating_transform);
|
| -
|
| - ASSERT_EQ(4u, pending_layer_->tilings()->num_tilings());
|
| - ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
|
| -
|
| - EXPECT_EQ(active_contents_scale,
|
| - pending_layer_->tilings()->tiling_at(0)->contents_scale());
|
| - EXPECT_EQ(pending_contents_scale,
|
| - pending_layer_->tilings()->tiling_at(1)->contents_scale());
|
| - EXPECT_EQ(active_contents_scale * low_res_factor,
|
| - pending_layer_->tilings()->tiling_at(2)->contents_scale());
|
| - EXPECT_EQ(pending_contents_scale * low_res_factor,
|
| - pending_layer_->tilings()->tiling_at(3)->contents_scale());
|
| -
|
| - EXPECT_EQ(active_contents_scale,
|
| - active_layer_->tilings()->tiling_at(0)->contents_scale());
|
| - EXPECT_EQ(pending_contents_scale,
|
| - active_layer_->tilings()->tiling_at(1)->contents_scale());
|
| - EXPECT_EQ(active_contents_scale * low_res_factor,
|
| - active_layer_->tilings()->tiling_at(2)->contents_scale());
|
| - EXPECT_EQ(pending_contents_scale * low_res_factor,
|
| - active_layer_->tilings()->tiling_at(3)->contents_scale());
|
| -
|
| - // The unused low res tiling from the pending tree must be kept or we may add
|
| - // it again on the active tree and collide with the pending tree.
|
| - used_tilings.push_back(active_layer_->tilings()->tiling_at(1));
|
| - active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
|
| - ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
|
| -
|
| - EXPECT_EQ(active_contents_scale,
|
| - active_layer_->tilings()->tiling_at(0)->contents_scale());
|
| - EXPECT_EQ(pending_contents_scale,
|
| - active_layer_->tilings()->tiling_at(1)->contents_scale());
|
| - EXPECT_EQ(active_contents_scale * low_res_factor,
|
| - active_layer_->tilings()->tiling_at(2)->contents_scale());
|
| - EXPECT_EQ(pending_contents_scale * low_res_factor,
|
| - active_layer_->tilings()->tiling_at(3)->contents_scale());
|
| -}
|
| -
|
| TEST_F(NoLowResPictureLayerImplTest, ReleaseResources) {
|
| gfx::Size tile_size(400, 400);
|
| gfx::Size layer_bounds(1300, 1900);
|
| @@ -3662,15 +3543,8 @@ TEST_F(NoLowResPictureLayerImplTest, ReleaseResources) {
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
|
|
| SetupTrees(pending_pile, active_pile);
|
| - EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
|
| -
|
| - SetupDrawPropertiesAndUpdateTiles(pending_layer_,
|
| - 1.3f, // ideal contents scale
|
| - 2.7f, // device scale
|
| - 3.2f, // page scale
|
| - 1.f, // maximum animation scale
|
| - false);
|
| EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
|
| + EXPECT_EQ(1u, active_layer_->tilings()->num_tilings());
|
|
|
| // All tilings should be removed when losing output surface.
|
| active_layer_->ReleaseResources();
|
| @@ -3694,7 +3568,7 @@ TEST_F(PictureLayerImplTest, SharedQuadStateContainsMaxTilingScale) {
|
| gfx::Size tile_size(400, 400);
|
| gfx::Size layer_bounds(1000, 2000);
|
|
|
| - host_impl_.SetViewportSize(layer_bounds);
|
| + host_impl_.SetViewportSize(gfx::Size(10000, 20000));
|
|
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| @@ -3703,14 +3577,12 @@ TEST_F(PictureLayerImplTest, SharedQuadStateContainsMaxTilingScale) {
|
|
|
| SetupTrees(pending_pile, active_pile);
|
|
|
| - SetupDrawPropertiesAndUpdateTiles(pending_layer_, 2.5f, 1.f, 1.f, 1.f, false);
|
| - host_impl_.pending_tree()->UpdateDrawProperties();
|
| -
|
| - active_layer_->draw_properties().visible_content_rect =
|
| - gfx::Rect(layer_bounds);
|
| - host_impl_.active_tree()->UpdateDrawProperties();
|
| + ResetTilingsAndRasterScales();
|
| + SetupDrawPropertiesAndUpdateTiles(active_layer_, 2.5f, 1.f, 1.f, 1.f, false);
|
|
|
| float max_contents_scale = active_layer_->MaximumTilingContentsScale();
|
| + EXPECT_EQ(2.5f, max_contents_scale);
|
| +
|
| gfx::Transform scaled_draw_transform = active_layer_->draw_transform();
|
| scaled_draw_transform.Scale(SK_MScalar1 / max_contents_scale,
|
| SK_MScalar1 / max_contents_scale);
|
| @@ -3747,40 +3619,35 @@ TEST_F(PictureLayerImplTest, UpdateTilesForMasksWithNoVisibleContent) {
|
|
|
| scoped_ptr<FakePictureLayerImpl> layer_with_mask =
|
| FakePictureLayerImpl::Create(host_impl_.pending_tree(), 2);
|
| -
|
| layer_with_mask->SetBounds(bounds);
|
| layer_with_mask->SetContentBounds(bounds);
|
|
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, bounds);
|
| scoped_ptr<FakePictureLayerImpl> mask =
|
| - FakePictureLayerImpl::CreateWithRasterSource(host_impl_.pending_tree(), 3,
|
| - pending_pile);
|
| - mask->set_is_mask(true);
|
| -
|
| + FakePictureLayerImpl::CreateMaskWithRasterSource(
|
| + host_impl_.pending_tree(), 3, pending_pile);
|
| mask->SetBounds(bounds);
|
| mask->SetContentBounds(bounds);
|
| mask->SetDrawsContent(true);
|
| -
|
| - FakePictureLayerImpl* pending_mask_content = mask.get();
|
| layer_with_mask->SetMaskLayer(mask.Pass());
|
|
|
| + FakePictureLayerImpl* pending_mask =
|
| + static_cast<FakePictureLayerImpl*>(layer_with_mask->mask_layer());
|
| +
|
| scoped_ptr<FakePictureLayerImpl> child_of_layer_with_mask =
|
| FakePictureLayerImpl::Create(host_impl_.pending_tree(), 4);
|
| -
|
| child_of_layer_with_mask->SetBounds(bounds);
|
| child_of_layer_with_mask->SetContentBounds(bounds);
|
| child_of_layer_with_mask->SetDrawsContent(true);
|
| -
|
| layer_with_mask->AddChild(child_of_layer_with_mask.Pass());
|
| -
|
| root->AddChild(layer_with_mask.Pass());
|
|
|
| host_impl_.pending_tree()->SetRootLayer(root.Pass());
|
|
|
| - EXPECT_FALSE(pending_mask_content->tilings());
|
| + EXPECT_EQ(0u, pending_mask->num_tilings());
|
| host_impl_.pending_tree()->UpdateDrawProperties();
|
| - EXPECT_NE(0u, pending_mask_content->num_tilings());
|
| + EXPECT_NE(0u, pending_mask->num_tilings());
|
| }
|
|
|
| class PictureLayerImplTestWithDelegatingRenderer : public PictureLayerImplTest {
|
| @@ -3804,7 +3671,6 @@ TEST_F(PictureLayerImplTestWithDelegatingRenderer,
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| SetupPendingTree(pending_pile);
|
| pending_layer_->SetBounds(layer_bounds);
|
| - host_impl_.SetViewportSize(layer_bounds);
|
| ActivateTree();
|
| host_impl_.active_tree()->UpdateDrawProperties();
|
| std::vector<Tile*> tiles =
|
| @@ -3851,14 +3717,17 @@ class OcclusionTrackingPictureLayerImplTest : public PictureLayerImplTest {
|
| OcclusionTrackingPictureLayerImplTest()
|
| : PictureLayerImplTest(OcclusionTrackingSettings()) {}
|
|
|
| - void VerifyEvictionConsidersOcclusion(
|
| - PictureLayerImpl* layer,
|
| - size_t expected_occluded_tile_count[NUM_TREE_PRIORITIES]) {
|
| + void VerifyEvictionConsidersOcclusion(FakePictureLayerImpl* layer,
|
| + FakePictureLayerImpl* twin_layer,
|
| + WhichTree tree,
|
| + size_t expected_occluded_tile_count) {
|
| + WhichTree twin_tree = tree == ACTIVE_TREE ? PENDING_TREE : ACTIVE_TREE;
|
| for (int priority_count = 0; priority_count < NUM_TREE_PRIORITIES;
|
| ++priority_count) {
|
| TreePriority tree_priority = static_cast<TreePriority>(priority_count);
|
| size_t occluded_tile_count = 0u;
|
| Tile* last_tile = nullptr;
|
| + std::set<Tile*> shared_tiles;
|
|
|
| scoped_ptr<TilingSetEvictionQueue> queue =
|
| layer->CreateEvictionQueue(tree_priority);
|
| @@ -3866,23 +3735,22 @@ class OcclusionTrackingPictureLayerImplTest : public PictureLayerImplTest {
|
| Tile* tile = queue->Top();
|
| if (!last_tile)
|
| last_tile = tile;
|
| + if (tile->is_shared())
|
| + EXPECT_TRUE(shared_tiles.insert(tile).second);
|
|
|
| // The only way we will encounter an occluded tile after an unoccluded
|
| // tile is if the priorty bin decreased, the tile is required for
|
| // activation, or the scale changed.
|
| - bool tile_is_occluded =
|
| - tile->is_occluded_for_tree_priority(tree_priority);
|
| + bool tile_is_occluded = tile->is_occluded(tree);
|
| if (tile_is_occluded) {
|
| occluded_tile_count++;
|
|
|
| - bool last_tile_is_occluded =
|
| - last_tile->is_occluded_for_tree_priority(tree_priority);
|
| + bool last_tile_is_occluded = last_tile->is_occluded(tree);
|
| if (!last_tile_is_occluded) {
|
| TilePriority::PriorityBin tile_priority_bin =
|
| - tile->priority_for_tree_priority(tree_priority).priority_bin;
|
| + tile->priority(tree).priority_bin;
|
| TilePriority::PriorityBin last_tile_priority_bin =
|
| - last_tile->priority_for_tree_priority(tree_priority)
|
| - .priority_bin;
|
| + last_tile->priority(tree).priority_bin;
|
|
|
| EXPECT_TRUE(
|
| (tile_priority_bin < last_tile_priority_bin) ||
|
| @@ -3893,8 +3761,74 @@ class OcclusionTrackingPictureLayerImplTest : public PictureLayerImplTest {
|
| last_tile = tile;
|
| queue->Pop();
|
| }
|
| - EXPECT_EQ(expected_occluded_tile_count[priority_count],
|
| - occluded_tile_count);
|
| + // Count also shared tiles which are occluded in the tree but which were
|
| + // not returned by the tiling set eviction queue. Those shared tiles
|
| + // shall be returned by the twin tiling set eviction queue.
|
| + queue = twin_layer->CreateEvictionQueue(tree_priority);
|
| + while (!queue->IsEmpty()) {
|
| + Tile* tile = queue->Top();
|
| + if (tile->is_shared()) {
|
| + EXPECT_TRUE(shared_tiles.insert(tile).second);
|
| + if (tile->is_occluded(tree))
|
| + ++occluded_tile_count;
|
| + // Check the reasons why the shared tile was not returned by
|
| + // the first tiling set eviction queue.
|
| + switch (tree_priority) {
|
| + case SAME_PRIORITY_FOR_BOTH_TREES: {
|
| + const TilePriority& priority = tile->priority(tree);
|
| + const TilePriority& priority_for_tree_priority =
|
| + tile->priority_for_tree_priority(tree_priority);
|
| + const TilePriority& twin_priority = tile->priority(twin_tree);
|
| + // Check if the shared tile was not returned by the first tiling
|
| + // set eviction queue because it was out of order for the first
|
| + // tiling set eviction queue but not for the twin tiling set
|
| + // eviction queue.
|
| + if (priority.priority_bin != twin_priority.priority_bin) {
|
| + EXPECT_LT(priority_for_tree_priority.priority_bin,
|
| + priority.priority_bin);
|
| + EXPECT_EQ(priority_for_tree_priority.priority_bin,
|
| + twin_priority.priority_bin);
|
| + EXPECT_TRUE(priority_for_tree_priority.priority_bin <
|
| + priority.priority_bin);
|
| + } else if (tile->is_occluded(tree) !=
|
| + tile->is_occluded(twin_tree)) {
|
| + EXPECT_TRUE(tile->is_occluded(tree));
|
| + EXPECT_FALSE(tile->is_occluded(twin_tree));
|
| + EXPECT_FALSE(
|
| + tile->is_occluded_for_tree_priority(tree_priority));
|
| + } else if (priority.distance_to_visible !=
|
| + twin_priority.distance_to_visible) {
|
| + EXPECT_LT(priority_for_tree_priority.distance_to_visible,
|
| + priority.distance_to_visible);
|
| + EXPECT_EQ(priority_for_tree_priority.distance_to_visible,
|
| + twin_priority.distance_to_visible);
|
| + EXPECT_TRUE(priority_for_tree_priority.distance_to_visible <
|
| + priority.distance_to_visible);
|
| + } else {
|
| + // Shared tiles having the same active and pending priorities
|
| + // should be returned only by a pending tree eviction queue.
|
| + EXPECT_EQ(ACTIVE_TREE, tree);
|
| + }
|
| + break;
|
| + }
|
| + case SMOOTHNESS_TAKES_PRIORITY:
|
| + // Shared tiles should be returned only by an active tree
|
| + // eviction queue.
|
| + EXPECT_EQ(PENDING_TREE, tree);
|
| + break;
|
| + case NEW_CONTENT_TAKES_PRIORITY:
|
| + // Shared tiles should be returned only by a pending tree
|
| + // eviction queue.
|
| + EXPECT_EQ(ACTIVE_TREE, tree);
|
| + break;
|
| + case NUM_TREE_PRIORITIES:
|
| + NOTREACHED();
|
| + break;
|
| + }
|
| + }
|
| + queue->Pop();
|
| + }
|
| + EXPECT_EQ(expected_occluded_tile_count, occluded_tile_count);
|
| }
|
| }
|
| };
|
| @@ -3911,13 +3845,11 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
|
| gfx::Size viewport_size(500, 500);
|
| gfx::Point occluding_layer_position(310, 0);
|
|
|
| + host_impl_.SetViewportSize(viewport_size);
|
| +
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| - SetupPendingTree(pending_pile);
|
| - pending_layer_->set_fixed_tile_size(tile_size);
|
| -
|
| - host_impl_.SetViewportSize(viewport_size);
|
| - host_impl_.pending_tree()->UpdateDrawProperties();
|
| + SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
|
|
|
| // No occlusion.
|
| int unoccluded_tile_count = 0;
|
| @@ -4004,13 +3936,11 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
|
| gfx::Size viewport_size(500, 500);
|
| gfx::Point occluding_layer_position(310, 0);
|
|
|
| + host_impl_.SetViewportSize(viewport_size);
|
| +
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| - SetupPendingTree(pending_pile);
|
| - pending_layer_->set_fixed_tile_size(tile_size);
|
| -
|
| - host_impl_.SetViewportSize(viewport_size);
|
| - host_impl_.pending_tree()->UpdateDrawProperties();
|
| + SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
|
|
|
| // No occlusion.
|
| int occluded_tile_count = 0;
|
| @@ -4125,6 +4055,11 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
|
| }
|
|
|
| TEST_F(OcclusionTrackingPictureLayerImplTest, OcclusionForDifferentScales) {
|
| + base::TimeTicks time_ticks;
|
| + time_ticks += base::TimeDelta::FromMilliseconds(1);
|
| + host_impl_.SetCurrentBeginFrameArgs(
|
| + CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
|
| +
|
| gfx::Size tile_size(102, 102);
|
| gfx::Size layer_bounds(1000, 1000);
|
| gfx::Size viewport_size(500, 500);
|
| @@ -4132,19 +4067,11 @@ TEST_F(OcclusionTrackingPictureLayerImplTest, OcclusionForDifferentScales) {
|
|
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| - SetupPendingTree(pending_pile);
|
| - pending_layer_->set_fixed_tile_size(tile_size);
|
|
|
| - ASSERT_TRUE(pending_layer_->CanHaveTilings());
|
| -
|
| - float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
|
| + host_impl_.SetViewportSize(viewport_size);
|
|
|
| - std::vector<PictureLayerTiling*> tilings;
|
| - tilings.push_back(pending_layer_->AddTiling(low_res_factor));
|
| - tilings.push_back(pending_layer_->AddTiling(0.3f));
|
| - tilings.push_back(pending_layer_->AddTiling(0.7f));
|
| - tilings.push_back(pending_layer_->AddTiling(1.0f));
|
| - tilings.push_back(pending_layer_->AddTiling(2.0f));
|
| + SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
|
| + ASSERT_TRUE(pending_layer_->CanHaveTilings());
|
|
|
| pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 1));
|
| LayerImpl* layer1 = pending_layer_->children()[0];
|
| @@ -4154,49 +4081,56 @@ TEST_F(OcclusionTrackingPictureLayerImplTest, OcclusionForDifferentScales) {
|
| layer1->SetContentsOpaque(true);
|
| layer1->SetPosition(occluding_layer_position);
|
|
|
| - host_impl_.SetViewportSize(viewport_size);
|
| + pending_layer_->tilings()->RemoveAllTilings();
|
| + float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
|
| + pending_layer_->AddTiling(low_res_factor);
|
| + pending_layer_->AddTiling(0.3f);
|
| + pending_layer_->AddTiling(0.7f);
|
| + pending_layer_->AddTiling(1.0f);
|
| + pending_layer_->AddTiling(2.0f);
|
| +
|
| + time_ticks += base::TimeDelta::FromMilliseconds(1);
|
| + host_impl_.SetCurrentBeginFrameArgs(
|
| + CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
|
| + // UpdateDrawProperties with the occluding layer.
|
| host_impl_.pending_tree()->UpdateDrawProperties();
|
|
|
| - int tiling_count = 0;
|
| + EXPECT_EQ(5u, pending_layer_->num_tilings());
|
| +
|
| int occluded_tile_count = 0;
|
| - for (std::vector<PictureLayerTiling*>::iterator tiling_iterator =
|
| - tilings.begin();
|
| - tiling_iterator != tilings.end();
|
| - ++tiling_iterator) {
|
| - (*tiling_iterator)->UpdateAllTilePrioritiesForTesting();
|
| - std::vector<Tile*> tiles = (*tiling_iterator)->AllTilesForTesting();
|
| + for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
|
| + PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
|
| + tiling->UpdateAllTilePrioritiesForTesting();
|
| + std::vector<Tile*> tiles = tiling->AllTilesForTesting();
|
|
|
| occluded_tile_count = 0;
|
| - for (size_t i = 0; i < tiles.size(); ++i) {
|
| - if (tiles[i]->is_occluded(PENDING_TREE)) {
|
| + for (size_t j = 0; j < tiles.size(); ++j) {
|
| + if (tiles[j]->is_occluded(PENDING_TREE)) {
|
| gfx::Rect scaled_content_rect = ScaleToEnclosingRect(
|
| - tiles[i]->content_rect(), 1.0f / tiles[i]->contents_scale());
|
| + tiles[j]->content_rect(), 1.0f / tiles[j]->contents_scale());
|
| EXPECT_GE(scaled_content_rect.x(), occluding_layer_position.x());
|
| occluded_tile_count++;
|
| }
|
| }
|
| - switch (tiling_count) {
|
| +
|
| + switch (i) {
|
| case 0:
|
| + EXPECT_EQ(occluded_tile_count, 30);
|
| + break;
|
| case 1:
|
| - EXPECT_EQ(occluded_tile_count, 2);
|
| + EXPECT_EQ(occluded_tile_count, 5);
|
| break;
|
| case 2:
|
| EXPECT_EQ(occluded_tile_count, 4);
|
| break;
|
| - case 3:
|
| - EXPECT_EQ(occluded_tile_count, 5);
|
| - break;
|
| case 4:
|
| - EXPECT_EQ(occluded_tile_count, 30);
|
| + case 3:
|
| + EXPECT_EQ(occluded_tile_count, 2);
|
| break;
|
| default:
|
| NOTREACHED();
|
| }
|
| -
|
| - tiling_count++;
|
| }
|
| -
|
| - EXPECT_EQ(tiling_count, 5);
|
| }
|
|
|
| TEST_F(OcclusionTrackingPictureLayerImplTest, DifferentOcclusionOnTrees) {
|
| @@ -4210,24 +4144,23 @@ TEST_F(OcclusionTrackingPictureLayerImplTest, DifferentOcclusionOnTrees) {
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| scoped_refptr<FakePicturePileImpl> active_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| - SetupTrees(pending_pile, active_pile);
|
| +
|
| + host_impl_.SetViewportSize(viewport_size);
|
| + SetupPendingTree(active_pile);
|
|
|
| // Partially occlude the active layer.
|
| - active_layer_->AddChild(LayerImpl::Create(host_impl_.active_tree(), 2));
|
| - LayerImpl* layer1 = active_layer_->children()[0];
|
| + pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 2));
|
| + LayerImpl* layer1 = pending_layer_->children()[0];
|
| layer1->SetBounds(layer_bounds);
|
| layer1->SetContentBounds(layer_bounds);
|
| layer1->SetDrawsContent(true);
|
| layer1->SetContentsOpaque(true);
|
| layer1->SetPosition(occluding_layer_position);
|
|
|
| - // Partially invalidate the pending layer.
|
| - pending_layer_->set_invalidation(invalidation_rect);
|
| -
|
| - host_impl_.SetViewportSize(viewport_size);
|
| + ActivateTree();
|
|
|
| - active_layer_->CreateDefaultTilingsAndTiles();
|
| - pending_layer_->CreateDefaultTilingsAndTiles();
|
| + // Partially invalidate the pending layer.
|
| + SetupPendingTreeWithInvalidation(pending_pile, invalidation_rect);
|
|
|
| for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
|
| PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
|
| @@ -4306,36 +4239,45 @@ TEST_F(OcclusionTrackingPictureLayerImplTest, DifferentOcclusionOnTrees) {
|
|
|
| TEST_F(OcclusionTrackingPictureLayerImplTest,
|
| OccludedTilesConsideredDuringEviction) {
|
| + base::TimeTicks time_ticks;
|
| + time_ticks += base::TimeDelta::FromMilliseconds(1);
|
| + host_impl_.SetCurrentBeginFrameArgs(
|
| + CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
|
| +
|
| gfx::Size tile_size(102, 102);
|
| gfx::Size layer_bounds(1000, 1000);
|
| - gfx::Size viewport_size(500, 500);
|
| + gfx::Size viewport_size(1000, 1000);
|
| gfx::Point pending_occluding_layer_position(310, 0);
|
| gfx::Point active_occluding_layer_position(0, 310);
|
| gfx::Rect invalidation_rect(230, 230, 102, 102);
|
|
|
| + host_impl_.SetViewportSize(viewport_size);
|
| + host_impl_.SetDeviceScaleFactor(2.f);
|
| +
|
| scoped_refptr<FakePicturePileImpl> pending_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| scoped_refptr<FakePicturePileImpl> active_pile =
|
| FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| - SetupTrees(pending_pile, active_pile);
|
|
|
| - pending_layer_->set_fixed_tile_size(tile_size);
|
| - active_layer_->set_fixed_tile_size(tile_size);
|
| + SetupPendingTreeWithFixedTileSize(active_pile, tile_size, Region());
|
|
|
| - float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
|
| + // Partially occlude the active layer.
|
| + pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 2));
|
| + LayerImpl* active_occluding_layer = pending_layer_->children()[0];
|
| + active_occluding_layer->SetBounds(layer_bounds);
|
| + active_occluding_layer->SetContentBounds(layer_bounds);
|
| + active_occluding_layer->SetDrawsContent(true);
|
| + active_occluding_layer->SetContentsOpaque(true);
|
| + active_occluding_layer->SetPosition(active_occluding_layer_position);
|
|
|
| - std::vector<PictureLayerTiling*> tilings;
|
| - tilings.push_back(pending_layer_->AddTiling(low_res_factor));
|
| - tilings.push_back(pending_layer_->AddTiling(0.3f));
|
| - tilings.push_back(pending_layer_->AddTiling(0.7f));
|
| - tilings.push_back(pending_layer_->AddTiling(1.0f));
|
| - tilings.push_back(pending_layer_->AddTiling(2.0f));
|
| + ActivateTree();
|
|
|
| - EXPECT_EQ(5u, pending_layer_->num_tilings());
|
| - EXPECT_EQ(5u, active_layer_->num_tilings());
|
| + // Partially invalidate the pending layer. Tiles inside the invalidation rect
|
| + // are not shared between trees.
|
| + SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, invalidation_rect);
|
|
|
| - // Partially occlude the pending layer.
|
| - pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 1));
|
| + // Partially occlude the pending layer in a different way.
|
| + pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 3));
|
| LayerImpl* pending_occluding_layer = pending_layer_->children()[0];
|
| pending_occluding_layer->SetBounds(layer_bounds);
|
| pending_occluding_layer->SetContentBounds(layer_bounds);
|
| @@ -4343,52 +4285,38 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
|
| pending_occluding_layer->SetContentsOpaque(true);
|
| pending_occluding_layer->SetPosition(pending_occluding_layer_position);
|
|
|
| - // Partially occlude the active layer.
|
| - active_layer_->AddChild(LayerImpl::Create(host_impl_.active_tree(), 2));
|
| - LayerImpl* active_occluding_layer = active_layer_->children()[0];
|
| - active_occluding_layer->SetBounds(layer_bounds);
|
| - active_occluding_layer->SetContentBounds(layer_bounds);
|
| - active_occluding_layer->SetDrawsContent(true);
|
| - active_occluding_layer->SetContentsOpaque(true);
|
| - active_occluding_layer->SetPosition(active_occluding_layer_position);
|
| -
|
| - // Partially invalidate the pending layer. Tiles inside the invalidation rect
|
| - // are not shared between trees.
|
| - pending_layer_->set_invalidation(invalidation_rect);
|
| + EXPECT_EQ(2u, pending_layer_->num_tilings());
|
| + EXPECT_EQ(2u, active_layer_->num_tilings());
|
|
|
| - host_impl_.SetViewportSize(viewport_size);
|
| - host_impl_.active_tree()->UpdateDrawProperties();
|
| + time_ticks += base::TimeDelta::FromMilliseconds(1);
|
| + host_impl_.SetCurrentBeginFrameArgs(
|
| + CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
|
| + // UpdateDrawProperties with the occluding layer.
|
| host_impl_.pending_tree()->UpdateDrawProperties();
|
|
|
| - // The expected number of occluded tiles on each of the 5 tilings for each of
|
| + // The expected number of occluded tiles on each of the 2 tilings for each of
|
| // the 3 tree priorities.
|
| - size_t expected_occluded_tile_count_on_both[] = {9u, 1u, 1u, 1u, 1u};
|
| - size_t expected_occluded_tile_count_on_active[] = {30u, 5u, 4u, 2u, 2u};
|
| - size_t expected_occluded_tile_count_on_pending[] = {30u, 5u, 4u, 2u, 2u};
|
| + size_t expected_occluded_tile_count_on_both[] = {9u, 1u};
|
| + size_t expected_occluded_tile_count_on_active[] = {30u, 3u};
|
| + size_t expected_occluded_tile_count_on_pending[] = {30u, 3u};
|
|
|
| - // The total expected number of occluded tiles on all tilings for each of the
|
| - // 3 tree priorities.
|
| - size_t total_expected_occluded_tile_count[] = {13u, 43u, 43u};
|
| -
|
| - ASSERT_EQ(arraysize(total_expected_occluded_tile_count), NUM_TREE_PRIORITIES);
|
| + size_t total_expected_occluded_tile_count_on_trees[] = {33u, 33u};
|
|
|
| // Verify number of occluded tiles on the pending layer for each tiling.
|
| for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
|
| PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
|
| - tiling->CreateAllTilesForTesting();
|
| tiling->UpdateAllTilePrioritiesForTesting();
|
|
|
| size_t occluded_tile_count_on_pending = 0u;
|
| size_t occluded_tile_count_on_active = 0u;
|
| size_t occluded_tile_count_on_both = 0u;
|
| - for (PictureLayerTiling::CoverageIterator iter(
|
| - tiling,
|
| - pending_layer_->contents_scale_x(),
|
| - gfx::Rect(layer_bounds));
|
| - iter;
|
| - ++iter) {
|
| + for (PictureLayerTiling::CoverageIterator iter(tiling, 1.f,
|
| + gfx::Rect(layer_bounds));
|
| + iter; ++iter) {
|
| Tile* tile = *iter;
|
|
|
| + if (!tile)
|
| + continue;
|
| if (tile->is_occluded(PENDING_TREE))
|
| occluded_tile_count_on_pending++;
|
| if (tile->is_occluded(ACTIVE_TREE))
|
| @@ -4398,19 +4326,18 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
|
| }
|
| EXPECT_EQ(expected_occluded_tile_count_on_pending[i],
|
| occluded_tile_count_on_pending)
|
| - << i;
|
| + << tiling->contents_scale();
|
| EXPECT_EQ(expected_occluded_tile_count_on_active[i],
|
| occluded_tile_count_on_active)
|
| - << i;
|
| + << tiling->contents_scale();
|
| EXPECT_EQ(expected_occluded_tile_count_on_both[i],
|
| occluded_tile_count_on_both)
|
| - << i;
|
| + << tiling->contents_scale();
|
| }
|
|
|
| // Verify number of occluded tiles on the active layer for each tiling.
|
| for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
|
| PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
|
| - tiling->CreateAllTilesForTesting();
|
| tiling->UpdateAllTilePrioritiesForTesting();
|
|
|
| size_t occluded_tile_count_on_pending = 0u;
|
| @@ -4424,6 +4351,8 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
|
| ++iter) {
|
| Tile* tile = *iter;
|
|
|
| + if (!tile)
|
| + continue;
|
| if (tile->is_occluded(PENDING_TREE))
|
| occluded_tile_count_on_pending++;
|
| if (tile->is_occluded(ACTIVE_TREE))
|
| @@ -4443,20 +4372,38 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
|
| }
|
|
|
| std::vector<Tile*> all_tiles;
|
| - for (std::vector<PictureLayerTiling*>::iterator tiling_iterator =
|
| - tilings.begin();
|
| - tiling_iterator != tilings.end();
|
| - ++tiling_iterator) {
|
| - std::vector<Tile*> tiles = (*tiling_iterator)->AllTilesForTesting();
|
| - std::copy(tiles.begin(), tiles.end(), std::back_inserter(all_tiles));
|
| + for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
|
| + PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
|
| + std::vector<Tile*> tiles = tiling->AllTilesForTesting();
|
| + all_tiles.insert(all_tiles.end(), tiles.begin(), tiles.end());
|
| }
|
|
|
| host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles);
|
|
|
| - VerifyEvictionConsidersOcclusion(pending_layer_,
|
| - total_expected_occluded_tile_count);
|
| - VerifyEvictionConsidersOcclusion(active_layer_,
|
| - total_expected_occluded_tile_count);
|
| + VerifyEvictionConsidersOcclusion(
|
| + pending_layer_, active_layer_, PENDING_TREE,
|
| + total_expected_occluded_tile_count_on_trees[PENDING_TREE]);
|
| + VerifyEvictionConsidersOcclusion(
|
| + active_layer_, pending_layer_, ACTIVE_TREE,
|
| + total_expected_occluded_tile_count_on_trees[ACTIVE_TREE]);
|
| +
|
| + // Repeat the tests without valid active tree priorities.
|
| + active_layer_->set_has_valid_tile_priorities(false);
|
| + VerifyEvictionConsidersOcclusion(
|
| + pending_layer_, active_layer_, PENDING_TREE,
|
| + total_expected_occluded_tile_count_on_trees[PENDING_TREE]);
|
| + VerifyEvictionConsidersOcclusion(
|
| + active_layer_, pending_layer_, ACTIVE_TREE, 0u);
|
| + active_layer_->set_has_valid_tile_priorities(true);
|
| +
|
| + // Repeat the tests without valid pending tree priorities.
|
| + pending_layer_->set_has_valid_tile_priorities(false);
|
| + VerifyEvictionConsidersOcclusion(
|
| + active_layer_, pending_layer_, ACTIVE_TREE,
|
| + total_expected_occluded_tile_count_on_trees[ACTIVE_TREE]);
|
| + VerifyEvictionConsidersOcclusion(
|
| + pending_layer_, active_layer_, PENDING_TREE, 0u);
|
| + pending_layer_->set_has_valid_tile_priorities(true);
|
| }
|
|
|
| TEST_F(PictureLayerImplTest, PendingOrActiveTwinLayer) {
|
| @@ -4530,8 +4477,6 @@ void PictureLayerImplTest::TestQuadsForSolidColor(bool test_for_solid) {
|
| host->SetRootLayer(layer);
|
| RecordingSource* recording_source = layer->GetRecordingSourceForTesting();
|
|
|
| - host_impl_.SetViewportSize(layer_bounds);
|
| -
|
| int frame_number = 0;
|
|
|
| client.set_fill_with_nonsolid_color(!test_for_solid);
|
| @@ -4544,11 +4489,9 @@ void PictureLayerImplTest::TestQuadsForSolidColor(bool test_for_solid) {
|
| scoped_refptr<RasterSource> pending_raster_source =
|
| recording_source->CreateRasterSource();
|
|
|
| - SetupPendingTree(pending_raster_source);
|
| + SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size, Region());
|
| ActivateTree();
|
|
|
| - active_layer_->set_fixed_tile_size(tile_size);
|
| - host_impl_.active_tree()->UpdateDrawProperties();
|
| if (test_for_solid) {
|
| EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
|
| } else {
|
| @@ -4597,8 +4540,6 @@ TEST_F(PictureLayerImplTest, NonSolidToSolidNoTilings) {
|
| host->SetRootLayer(layer);
|
| RecordingSource* recording_source = layer->GetRecordingSourceForTesting();
|
|
|
| - host_impl_.SetViewportSize(layer_bounds);
|
| -
|
| int frame_number = 0;
|
|
|
| client.set_fill_with_nonsolid_color(true);
|
| @@ -4696,6 +4637,66 @@ TEST_F(PictureLayerImplTest, ChangeInViewportAllowsTilingUpdates) {
|
| EXPECT_TRUE(pending_layer_->AllTilesRequiredForActivationAreReadyToDraw());
|
| }
|
|
|
| +TEST_F(PictureLayerImplTest, CloneMissingRecordings) {
|
| + gfx::Size tile_size(100, 100);
|
| + gfx::Size layer_bounds(400, 400);
|
| +
|
| + scoped_refptr<FakePicturePileImpl> filled_pile =
|
| + FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
|
| + scoped_refptr<FakePicturePileImpl> partial_pile =
|
| + FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
|
| + for (int i = 1; i < partial_pile->tiling().num_tiles_x(); ++i) {
|
| + for (int j = 1; j < partial_pile->tiling().num_tiles_y(); ++j)
|
| + partial_pile->AddRecordingAt(i, j);
|
| + }
|
| +
|
| + SetupPendingTreeWithFixedTileSize(filled_pile, tile_size, Region());
|
| + ActivateTree();
|
| +
|
| + PictureLayerTiling* pending_tiling = old_pending_layer_->HighResTiling();
|
| + PictureLayerTiling* active_tiling = active_layer_->HighResTiling();
|
| +
|
| + // We should have all tiles in both tile sets.
|
| + EXPECT_EQ(5u * 5u, pending_tiling->AllTilesForTesting().size());
|
| + EXPECT_EQ(5u * 5u, active_tiling->AllTilesForTesting().size());
|
| +
|
| + // Now put a partially-recorded pile on the pending tree (and invalidate
|
| + // everything, since the main thread PicturePile will invalidate dropped
|
| + // recordings). This will cause us to be missing some tiles.
|
| + SetupPendingTreeWithFixedTileSize(partial_pile, tile_size,
|
| + Region(gfx::Rect(layer_bounds)));
|
| + EXPECT_EQ(3u * 3u, pending_tiling->AllTilesForTesting().size());
|
| + EXPECT_FALSE(pending_tiling->TileAt(0, 0));
|
| + EXPECT_FALSE(pending_tiling->TileAt(1, 1));
|
| + EXPECT_TRUE(pending_tiling->TileAt(2, 2));
|
| +
|
| + // Active is not affected yet.
|
| + EXPECT_EQ(5u * 5u, active_tiling->AllTilesForTesting().size());
|
| +
|
| + // Activate the tree. The same tiles go missing on the active tree.
|
| + ActivateTree();
|
| + EXPECT_EQ(3u * 3u, active_tiling->AllTilesForTesting().size());
|
| + EXPECT_FALSE(active_tiling->TileAt(0, 0));
|
| + EXPECT_FALSE(active_tiling->TileAt(1, 1));
|
| + EXPECT_TRUE(active_tiling->TileAt(2, 2));
|
| +
|
| + // Now put a full recording on the pending tree again. We'll get all our tiles
|
| + // back.
|
| + SetupPendingTreeWithFixedTileSize(filled_pile, tile_size,
|
| + Region(gfx::Rect(layer_bounds)));
|
| + EXPECT_EQ(5u * 5u, pending_tiling->AllTilesForTesting().size());
|
| +
|
| + // Active is not affected yet.
|
| + EXPECT_EQ(3u * 3u, active_tiling->AllTilesForTesting().size());
|
| +
|
| + // Activate the tree. The tiles are created and shared on the active tree.
|
| + ActivateTree();
|
| + EXPECT_EQ(5u * 5u, active_tiling->AllTilesForTesting().size());
|
| + EXPECT_TRUE(active_tiling->TileAt(0, 0)->is_shared());
|
| + EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
|
| + EXPECT_TRUE(active_tiling->TileAt(2, 2)->is_shared());
|
| +}
|
| +
|
| class TileSizeSettings : public ImplSidePaintingSettings {
|
| public:
|
| TileSizeSettings() {
|
|
|
Chromium Code Reviews
Issue 812543002:
Update from https://crrev.com/308331 (Closed)
Base URL: git@github.com:domokit/mojo.git@master