cc/layers/picture_layer_impl_unittest.cc - Issue 1051993002: cc: Remove tile sharing from tilings.

Unified Diff: cc/layers/picture_layer_impl_unittest.cc

Issue 1051993002: cc: Remove tile sharing from tilings. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Created 5 years, 8 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

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 1ed32874972cea3acad86707ce7e3ed0b14701e5..31fa8b25093e2a6cf0d27887f14c5f95b06cd3a2 100644

--- a/cc/layers/picture_layer_impl_unittest.cc

+++ b/cc/layers/picture_layer_impl_unittest.cc

@@ -404,7 +404,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), pending_pile.get());

+ EXPECT_TRUE(tilings->tiling_at(i)->AllTilesForTesting().empty());

}

TEST_F(PictureLayerImplTest, ExternalViewportRectForPrioritizingTiles) {

@@ -682,9 +682,13 @@ TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {

gfx::Rect(tiling->tiling_size()));

iter;

++iter) {

- EXPECT_TRUE(*iter);

- EXPECT_FALSE(iter.geometry_rect().IsEmpty());

- EXPECT_EQ(pending_pile.get(), iter->raster_source());

+ if (*iter) {

danakj 2015/04/08 00:13:06 can you add a comment explaining the expectations

vmpstr 2015/04/10 20:25:13 Done.

+ EXPECT_FALSE(iter.geometry_rect().IsEmpty());

+ EXPECT_EQ(pending_pile.get(), iter->raster_source());

+ EXPECT_TRUE(iter.geometry_rect().Intersects(content_invalidation));

+ } else {

+ EXPECT_FALSE(iter.geometry_rect().Intersects(content_invalidation));

+ }

}

@@ -702,12 +706,8 @@ TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {

++iter) {

EXPECT_TRUE(*iter);

EXPECT_FALSE(iter.geometry_rect().IsEmpty());

- 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());

+ // Pile will be updated upon activation.

+ EXPECT_EQ(active_pile.get(), iter->raster_source());

}

@@ -1536,15 +1536,15 @@ TEST_F(PictureLayerImplTest, ClampTilesToToMaxTileSize) {

FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);

SetupTrees(pending_pile, active_pile);

danakj 2015/04/08 00:13:06 Would it keep these tests simpler to test on the p

vmpstr 2015/04/10 20:25:13 Done.

- EXPECT_GE(pending_layer_->tilings()->num_tilings(), 1u);

+ EXPECT_GE(active_layer_->tilings()->num_tilings(), 1u);

- pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();

+ active_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();

// The default value.

EXPECT_EQ(gfx::Size(256, 256).ToString(),

host_impl_.settings().default_tile_size.ToString());

- Tile* tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];

+ Tile* tile = active_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];

EXPECT_EQ(gfx::Size(256, 256).ToString(),

tile->content_rect().size().ToString());

@@ -1558,13 +1558,13 @@ TEST_F(PictureLayerImplTest, ClampTilesToToMaxTileSize) {

host_impl_.InitializeRenderer(

FakeOutputSurface::Create3d(context.Pass()).Pass());

- SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);

- ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());

+ SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);

+ ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());

- pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();

+ active_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();

// Verify the tiles are not larger than the context's max texture size.

- tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];

+ tile = active_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];

EXPECT_GE(140, tile->content_rect().width());

EXPECT_GE(140, tile->content_rect().height());

}

@@ -1580,16 +1580,16 @@ TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) {

FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);

SetupTrees(pending_pile, active_pile);

- EXPECT_GE(pending_layer_->tilings()->num_tilings(), 1u);

+ EXPECT_GE(active_layer_->tilings()->num_tilings(), 1u);

- pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();

+ active_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();

// The default value. The layer is smaller than this.

EXPECT_EQ(gfx::Size(512, 512).ToString(),

host_impl_.settings().max_untiled_layer_size.ToString());

// There should be a single tile since the layer is small.

- PictureLayerTiling* high_res_tiling = pending_layer_->tilings()->tiling_at(0);

+ PictureLayerTiling* high_res_tiling = active_layer_->tilings()->tiling_at(0);

EXPECT_EQ(1u, high_res_tiling->AllTilesForTesting().size());

ResetTilingsAndRasterScales();

@@ -1602,18 +1602,18 @@ TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) {

host_impl_.InitializeRenderer(

FakeOutputSurface::Create3d(context.Pass()).Pass());

- SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);

- ASSERT_LE(1u, pending_layer_->tilings()->num_tilings());

+ SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);

+ ASSERT_LE(1u, active_layer_->tilings()->num_tilings());

- pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();

+ active_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();

// There should be more than one tile since the max texture size won't cover

// the layer.

- high_res_tiling = pending_layer_->tilings()->tiling_at(0);

+ high_res_tiling = active_layer_->tilings()->tiling_at(0);

EXPECT_LT(1u, high_res_tiling->AllTilesForTesting().size());

// Verify the tiles are not larger than the context's max texture size.

- Tile* tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];

+ Tile* tile = active_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];

EXPECT_GE(140, tile->content_rect().width());

EXPECT_GE(140, tile->content_rect().height());

}

@@ -1802,10 +1802,12 @@ TEST_F(NoLowResPictureLayerImplTest,

pending_layer_->viewport_rect_for_tile_priority_in_content_space();

viewport_for_tile_priority.Intersect(pending_layer_->visible_content_rect());

+ EXPECT_TRUE(pending_layer_->HighResTiling()->AllTilesForTesting().empty());

int num_inside = 0;

int num_outside = 0;

- for (PictureLayerTiling::CoverageIterator iter(

- pending_layer_->HighResTiling(), 1.f, gfx::Rect(layer_bounds));

+ for (PictureLayerTiling::CoverageIterator iter(active_layer_->HighResTiling(),

+ 1.f, gfx::Rect(layer_bounds));

iter; ++iter) {

if (!*iter)

continue;

@@ -2071,9 +2073,13 @@ TEST_F(PictureLayerImplTest, HighResRequiredWhenMissingHighResFlagOn) {

pending_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();

pending_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();

+ active_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();

+ active_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();

- AssertAllTilesRequired(pending_layer_->HighResTiling());

- AssertNoTilesRequired(pending_layer_->LowResTiling());

+ EXPECT_TRUE(pending_layer_->HighResTiling()->AllTilesForTesting().empty());

+ EXPECT_TRUE(pending_layer_->LowResTiling()->AllTilesForTesting().empty());

+ AssertAllTilesRequired(active_layer_->HighResTiling());

+ AssertNoTilesRequired(active_layer_->LowResTiling());

}

TEST_F(PictureLayerImplTest, AllHighResRequiredEvenIfShared) {

@@ -2086,13 +2092,15 @@ TEST_F(PictureLayerImplTest, AllHighResRequiredEvenIfShared) {

active_layer_->HighResTiling()->AllTilesForTesting()[0];

EXPECT_FALSE(some_active_tile->IsReadyToDraw());

- // All tiles shared (no invalidation), so even though the active tree's

- // tiles aren't ready, the high res tiles are required for activation.

- pending_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();

- pending_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();

+ // Since there are no invalidations, pending tree should have no tiles.

+ EXPECT_TRUE(pending_layer_->HighResTiling()->AllTilesForTesting().empty());

+ EXPECT_TRUE(pending_layer_->LowResTiling()->AllTilesForTesting().empty());

- AssertAllTilesRequired(pending_layer_->HighResTiling());

- AssertNoTilesRequired(pending_layer_->LowResTiling());

+ active_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();

+ active_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();

+ AssertAllTilesRequired(active_layer_->HighResTiling());

+ AssertNoTilesRequired(active_layer_->LowResTiling());

}

TEST_F(PictureLayerImplTest, DisallowRequiredForActivation) {

@@ -2105,15 +2113,19 @@ TEST_F(PictureLayerImplTest, DisallowRequiredForActivation) {

active_layer_->HighResTiling()->AllTilesForTesting()[0];

EXPECT_FALSE(some_active_tile->IsReadyToDraw());

+ EXPECT_TRUE(pending_layer_->HighResTiling()->AllTilesForTesting().empty());

+ EXPECT_TRUE(pending_layer_->LowResTiling()->AllTilesForTesting().empty());

+ active_layer_->HighResTiling()->set_can_require_tiles_for_activation(false);

+ active_layer_->LowResTiling()->set_can_require_tiles_for_activation(false);

pending_layer_->HighResTiling()->set_can_require_tiles_for_activation(false);

pending_layer_->LowResTiling()->set_can_require_tiles_for_activation(false);

// If we disallow required for activation, no tiles can be required.

- pending_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();

- pending_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();

+ active_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();

+ active_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();

- AssertNoTilesRequired(pending_layer_->HighResTiling());

- AssertNoTilesRequired(pending_layer_->LowResTiling());

+ AssertNoTilesRequired(active_layer_->HighResTiling());

+ AssertNoTilesRequired(active_layer_->LowResTiling());

}

TEST_F(PictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {

@@ -2187,9 +2199,16 @@ TEST_F(PictureLayerImplTest, HighResRequiredWhenActiveHasDifferentBounds) {

// high res tiles in order to activate.

pending_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();

pending_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();

+ active_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();

+ active_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();

AssertAllTilesRequired(pending_layer_->HighResTiling());

- AssertNoTilesRequired(pending_layer_->LowResTiling());

+ AssertAllTilesRequired(active_layer_->HighResTiling());

+ AssertNoTilesRequired(active_layer_->LowResTiling());

+ // Since the test doesn't invalidate the resized region, we expect that the

+ // same low res tile would exist (which means we don't create a new one of the

+ // pending tree).

+ EXPECT_TRUE(pending_layer_->LowResTiling()->AllTilesForTesting().empty());

}

TEST_F(PictureLayerImplTest, ActivateUninitializedLayer) {

@@ -2259,14 +2278,15 @@ TEST_F(PictureLayerImplTest, ShareTilesOnNextFrame) {

// 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));

- EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));

- EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));

+ EXPECT_TRUE(active_tiling->TileAt(0, 0));

+ EXPECT_TRUE(active_tiling->TileAt(1, 0));

+ EXPECT_TRUE(active_tiling->TileAt(0, 1));

+ EXPECT_FALSE(pending_tiling->TileAt(0, 0));

+ EXPECT_FALSE(pending_tiling->TileAt(1, 0));

+ EXPECT_FALSE(pending_tiling->TileAt(0, 1));

EXPECT_NE(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));

- EXPECT_TRUE(pending_tiling->TileAt(0, 0)->is_shared());

- EXPECT_TRUE(pending_tiling->TileAt(1, 0)->is_shared());

- EXPECT_TRUE(pending_tiling->TileAt(0, 1)->is_shared());

- EXPECT_FALSE(pending_tiling->TileAt(1, 1)->is_shared());

+ EXPECT_TRUE(active_tiling->TileAt(1, 1));

+ EXPECT_TRUE(pending_tiling->TileAt(1, 1));

// Drop the tiles on the active tree and recreate them. The same tiles

// should be shared or not.

@@ -2275,14 +2295,15 @@ TEST_F(PictureLayerImplTest, ShareTilesOnNextFrame) {

active_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));

- EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));

- EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));

+ EXPECT_TRUE(active_tiling->TileAt(0, 0));

+ EXPECT_TRUE(active_tiling->TileAt(1, 0));

+ EXPECT_TRUE(active_tiling->TileAt(0, 1));

+ EXPECT_FALSE(pending_tiling->TileAt(0, 0));

+ EXPECT_FALSE(pending_tiling->TileAt(1, 0));

+ EXPECT_FALSE(pending_tiling->TileAt(0, 1));

EXPECT_NE(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));

- EXPECT_TRUE(pending_tiling->TileAt(0, 0)->is_shared());

- EXPECT_TRUE(pending_tiling->TileAt(1, 0)->is_shared());

- EXPECT_TRUE(pending_tiling->TileAt(0, 1)->is_shared());

- EXPECT_FALSE(pending_tiling->TileAt(1, 1)->is_shared());

+ EXPECT_TRUE(active_tiling->TileAt(1, 1));

+ EXPECT_TRUE(pending_tiling->TileAt(1, 1));

}

TEST_F(PictureLayerImplTest, ShareTilesWithNoInvalidation) {

@@ -2302,19 +2323,10 @@ TEST_F(PictureLayerImplTest, ShareTilesWithNoInvalidation) {

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_FALSE(pending_tiling->TileAt(0, 0));

+ EXPECT_FALSE(pending_tiling->TileAt(1, 0));

+ EXPECT_FALSE(pending_tiling->TileAt(0, 1));

+ EXPECT_FALSE(pending_tiling->TileAt(1, 1));

}

TEST_F(PictureLayerImplTest, ShareInvalidActiveTreeTiles) {

@@ -2348,19 +2360,10 @@ TEST_F(PictureLayerImplTest, ShareInvalidActiveTreeTiles) {

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_FALSE(pending_tiling->TileAt(0, 0));

+ EXPECT_FALSE(pending_tiling->TileAt(1, 0));

+ EXPECT_FALSE(pending_tiling->TileAt(0, 1));

+ EXPECT_FALSE(pending_tiling->TileAt(1, 1));

}

TEST_F(PictureLayerImplTest, RecreateInvalidPendingTreeTiles) {

@@ -2384,19 +2387,11 @@ TEST_F(PictureLayerImplTest, RecreateInvalidPendingTreeTiles) {

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_FALSE(pending_tiling->TileAt(1, 0));

+ EXPECT_FALSE(pending_tiling->TileAt(0, 1));

+ EXPECT_FALSE(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, SyncTilingAfterGpuRasterizationToggles) {

@@ -3325,12 +3320,14 @@ TEST_F(PictureLayerImplTest, LowResReadyToDrawNotEnoughToActivate) {

// Initialize all low-res tiles.

pending_layer_->SetAllTilesReadyInTiling(pending_layer_->LowResTiling());

+ pending_layer_->SetAllTilesReadyInTiling(active_layer_->LowResTiling());

// Low-res tiles should not be enough.

EXPECT_FALSE(host_impl_.tile_manager()->IsReadyToActivate());

// Initialize remaining tiles.

pending_layer_->SetAllTilesReady();

+ active_layer_->SetAllTilesReady();

EXPECT_TRUE(host_impl_.tile_manager()->IsReadyToActivate());

}

@@ -3348,6 +3345,7 @@ TEST_F(PictureLayerImplTest, HighResReadyToDrawEnoughToActivate) {

// Initialize all high-res tiles.

pending_layer_->SetAllTilesReadyInTiling(pending_layer_->HighResTiling());

+ active_layer_->SetAllTilesReadyInTiling(active_layer_->HighResTiling());

// High-res tiles should be enough, since they cover everything visible.

EXPECT_TRUE(host_impl_.tile_manager()->IsReadyToActivate());

@@ -3526,15 +3524,18 @@ TEST_F(NoLowResPictureLayerImplTest, AllHighResRequiredEvenIfShared) {

active_layer_->HighResTiling()->AllTilesForTesting()[0];

EXPECT_FALSE(some_active_tile->IsReadyToDraw());

- // All tiles shared (no invalidation), so even though the active tree's

- // tiles aren't ready, there is nothing required.

- pending_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();

+ // Since there is no invalidaiton, pending tree should have no tiles.

+ EXPECT_TRUE(pending_layer_->HighResTiling()->AllTilesForTesting().empty());

if (host_impl_.settings().create_low_res_tiling)

- pending_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();

+ EXPECT_TRUE(pending_layer_->LowResTiling()->AllTilesForTesting().empty());

- AssertAllTilesRequired(pending_layer_->HighResTiling());

+ active_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();

if (host_impl_.settings().create_low_res_tiling)

- AssertNoTilesRequired(pending_layer_->LowResTiling());

+ active_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();

+ AssertAllTilesRequired(active_layer_->HighResTiling());

+ if (host_impl_.settings().create_low_res_tiling)

+ AssertNoTilesRequired(active_layer_->LowResTiling());

}

TEST_F(NoLowResPictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {

@@ -4836,6 +4837,13 @@ TEST_F(PictureLayerImplTest, ChangeInViewportAllowsTilingUpdates) {

if (*iter)

tiles.push_back(*iter);

}

+ for (PictureLayerTiling::CoverageIterator iter(

+ active_layer_->HighResTiling(), 1.f,

+ active_layer_->HighResTiling()->GetCurrentVisibleRectForTesting());

+ iter; ++iter) {

+ if (*iter)

+ tiles.push_back(*iter);

+ }

host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);

@@ -4865,8 +4873,8 @@ TEST_F(PictureLayerImplTest, CloneMissingRecordings) {

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());

+ // We should have all tiles on active, and none on pending.

+ EXPECT_EQ(0u, pending_tiling->AllTilesForTesting().size());

EXPECT_EQ(5u * 5u, active_tiling->AllTilesForTesting().size());

// Now put a partially-recorded pile on the pending tree (and invalidate

@@ -4894,6 +4902,9 @@ TEST_F(PictureLayerImplTest, CloneMissingRecordings) {

SetupPendingTreeWithFixedTileSize(filled_pile, tile_size,

Region(gfx::Rect(layer_bounds)));

EXPECT_EQ(5u * 5u, pending_tiling->AllTilesForTesting().size());

+ Tile* tile00 = pending_tiling->TileAt(0, 0);

+ Tile* tile11 = pending_tiling->TileAt(1, 1);

+ Tile* tile22 = pending_tiling->TileAt(2, 2);

// Active is not affected yet.

EXPECT_EQ(3u * 3u, active_tiling->AllTilesForTesting().size());

@@ -4901,9 +4912,9 @@ TEST_F(PictureLayerImplTest, CloneMissingRecordings) {

// 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());

+ EXPECT_EQ(tile00, active_tiling->TileAt(0, 0));

+ EXPECT_EQ(tile11, active_tiling->TileAt(1, 1));

+ EXPECT_EQ(tile22, active_tiling->TileAt(2, 2));

}

class TileSizeSettings : public ImplSidePaintingSettings {

« no previous file with comments | « cc/base/tiling_data.cc ('k') | cc/resources/picture_layer_tiling.h » ('j') | cc/resources/picture_layer_tiling.h » ('J')