maximum_animation_contents_scale;
layer->draw_properties().screen_space_transform_is_animating =
animating_transform_to_screen;
- layer->UpdateTiles(Occlusion());
+ bool resourceless_software_draw = false;
+ layer->UpdateTiles(Occlusion(), resourceless_software_draw);
}
static void VerifyAllTilesExistAndHavePile(
const PictureLayerTiling* tiling,
// 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_RECT_EQ(*rect_iter, mock_canvas.rects_[0]);
+ EXPECT_EQ(*rect_iter, mock_canvas.rects_[0]);
rect_iter++;
}
}
resourceless_software_draw);
active_layer_->draw_properties().visible_content_rect = viewport;
active_layer_->draw_properties().screen_space_transform = transform;
- active_layer_->UpdateTiles(Occlusion());
+ active_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
gfx::Rect viewport_rect_for_tile_priority_in_view_space =
viewport_rect_for_tile_priority;
resourceless_software_draw);
active_layer_->draw_properties().visible_content_rect = viewport;
active_layer_->draw_properties().screen_space_transform = transform;
- active_layer_->UpdateTiles(Occlusion());
+ active_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
gfx::Transform screen_to_view(gfx::Transform::kSkipInitialization);
bool success = transform_for_tile_priority.GetInverse(&screen_to_view);
}
}
-TEST_F(PictureLayerImplTest,
- ResourcelessSoftwareDrawHasValidViewportForTilePriority) {
+TEST_F(PictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
base::TimeTicks time_ticks;
time_ticks += base::TimeDelta::FromMilliseconds(1);
host_impl_.SetCurrentBeginFrameArgs(
SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
// UpdateTiles with valid viewport. Should update tile viewport.
+ // Note viewport is considered invalid if and only if in resourceless
+ // software draw.
bool resourceless_software_draw = false;
gfx::Rect viewport = gfx::Rect(layer_bounds);
gfx::Transform transform;
resourceless_software_draw);
active_layer_->draw_properties().visible_content_rect = viewport;
active_layer_->draw_properties().screen_space_transform = transform;
- active_layer_->UpdateTiles(Occlusion());
+ active_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
gfx::Rect visible_rect_for_tile_priority =
active_layer_->visible_rect_for_tile_priority();
gfx::Transform screen_space_transform_for_tile_priority =
active_layer_->screen_space_transform_for_tile_priority();
- // PictureLayerImpl does not make a special case for
- // resource_less_software_draw, so the tile viewport and matrix should be
- // respected.
+ // Expand viewport and set it as invalid for prioritizing tiles.
+ // Should update viewport and transform, but not update visible rect.
time_ticks += base::TimeDelta::FromMilliseconds(200);
host_impl_.SetCurrentBeginFrameArgs(
CreateBeginFrameArgsForTesting(time_ticks));
viewport,
transform,
resourceless_software_draw);
- active_layer_->UpdateTiles(Occlusion());
-
- visible_rect_for_tile_priority =
- gfx::ScaleToEnclosingRect(visible_rect_for_tile_priority, 2);
- viewport_rect_for_tile_priority =
- gfx::ScaleToEnclosingRect(viewport_rect_for_tile_priority, 2);
- screen_space_transform_for_tile_priority = transform;
- EXPECT_RECT_EQ(visible_rect_for_tile_priority,
- active_layer_->visible_rect_for_tile_priority());
- EXPECT_RECT_EQ(viewport_rect_for_tile_priority,
- active_layer_->viewport_rect_for_tile_priority());
+ active_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
+
+ // Viewport and transform for tile priority are updated.
+ EXPECT_EQ(viewport, active_layer_->viewport_rect_for_tile_priority());
+ EXPECT_TRANSFORMATION_MATRIX_EQ(
+ transform, active_layer_->screen_space_transform_for_tile_priority());
+ // Visible rect for tile priority retains old value.
+ EXPECT_EQ(visible_rect_for_tile_priority,
+ active_layer_->visible_rect_for_tile_priority());
+
+ // Keep expanded viewport but mark it valid. Should update tile viewport.
+ time_ticks += base::TimeDelta::FromMilliseconds(200);
+ host_impl_.SetCurrentBeginFrameArgs(
+ CreateBeginFrameArgsForTesting(time_ticks));
+ resourceless_software_draw = false;
+ host_impl_.SetExternalDrawConstraints(transform,
+ viewport,
+ viewport,
+ viewport,
+ transform,
+ resourceless_software_draw);
+ active_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
+
EXPECT_TRANSFORMATION_MATRIX_EQ(
- screen_space_transform_for_tile_priority,
- active_layer_->screen_space_transform_for_tile_priority());
+ transform, active_layer_->screen_space_transform_for_tile_priority());
+ EXPECT_EQ(viewport, active_layer_->visible_rect_for_tile_priority());
+
+ // Match the reverse translate in |transform|.
+ EXPECT_EQ(viewport - gfx::Vector2d(1, 1),
+ active_layer_->viewport_rect_for_tile_priority());
}
TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
// Page scale animation, new high res, but not new low res because animating.
contents_scale = 2.f;
page_scale = 2.f;
+ maximum_animation_scale = 2.f;
animating_transform = true;
SetContentsScaleOnBothLayers(contents_scale,
device_scale,
pending_layer_->MarkVisibleResourcesAsRequired();
}
+TEST_F(PictureLayerImplTest, TileScalesWithSolidColorPile) {
+ gfx::Size layer_bounds(200, 200);
+ gfx::Size tile_size(host_impl_.settings().default_tile_size);
+ scoped_refptr<FakePicturePileImpl> pending_pile =
+ FakePicturePileImpl::CreateEmptyPileThatThinksItHasRecordings(
+ tile_size, layer_bounds);
+ scoped_refptr<FakePicturePileImpl> active_pile =
+ FakePicturePileImpl::CreateEmptyPileThatThinksItHasRecordings(
+ tile_size, layer_bounds);
+
+ 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();
+ 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_->UpdatePile(pending_pile);
+ ASSERT_TRUE(active_layer_->CanHaveTilings());
+
+ // Update properties with non-solid color pile should allow tilings.
+ host_impl_.active_tree()->UpdateDrawProperties();
+ EXPECT_TRUE(active_layer_->CanHaveTilings());
+ EXPECT_GT(active_layer_->ideal_contents_scale(), 0.f);
+}
+
TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
gfx::Size tile_size(100, 100);
gfx::Size layer_bounds(200, 200);
FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
SetupPendingTree(pending_pile);
+ gfx::Transform transform;
+ gfx::Transform transform_for_tile_priority;
+ bool resourceless_software_draw = false;
+ gfx::Rect viewport(0, 0, 100, 200);
+ host_impl_.SetExternalDrawConstraints(transform,
+ viewport,
+ viewport,
+ viewport,
+ 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();
EXPECT_EQ(tiling->resolution(), HIGH_RESOLUTION);
-
- pending_layer_->draw_properties().visible_content_rect =
- gfx::Rect(0, 0, 100, 200);
+ EXPECT_EQ(viewport, pending_layer_->visible_rect_for_tile_priority());
// Fake set priorities.
for (PictureLayerTiling::CoverageIterator iter(
TilePriority priority;
priority.resolution = HIGH_RESOLUTION;
gfx::Rect tile_bounds = iter.geometry_rect();
- if (pending_layer_->visible_content_rect().Intersects(tile_bounds)) {
+ if (pending_layer_->visible_rect_for_tile_priority().Intersects(
+ tile_bounds)) {
priority.priority_bin = TilePriority::NOW;
priority.distance_to_visible = 0.f;
} else {
time_ticks += base::TimeDelta::FromMilliseconds(200);
host_impl_.SetCurrentBeginFrameArgs(
CreateBeginFrameArgsForTesting(time_ticks));
- pending_layer_->UpdateTiles(Occlusion());
+ pending_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
pending_layer_->MarkVisibleResourcesAsRequired();
EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 4.f);
// When animating with an unknown maximum animation scale factor, a new
- // high-res tiling should be created at the animation's initial scale.
+ // high-res tiling should be created at a source scale of 1.
animating_transform = true;
contents_scale = 2.f;
maximum_animation_scale = 0.f;
page_scale,
maximum_animation_scale,
animating_transform);
- EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
+ EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), page_scale * device_scale);
// Further changes to scale during the animation should not cause a new
// high-res tiling to get created.
page_scale,
maximum_animation_scale,
animating_transform);
- EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
+ EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), page_scale * device_scale);
// Once we stop animating, a new high-res tiling should be created.
animating_transform = false;
// When animating with a maxmium animation scale factor that is so large
// that the layer grows larger than the viewport at this scale, a new
- // high-res tiling should get created at the animation's initial scale, not
- // at its maximum scale.
+ // high-res tiling should get created at a source scale of 1, not at its
+ // maximum scale.
animating_transform = true;
contents_scale = 2.f;
maximum_animation_scale = 11.f;
page_scale,
maximum_animation_scale,
animating_transform);
- EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
+ EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), page_scale * device_scale);
// Once we stop animating, a new high-res tiling should be created.
animating_transform = false;
// Once we stop animating, a new high-res tiling should be created.
animating_transform = false;
+ contents_scale = 12.f;
+
+ SetContentsScaleOnBothLayers(contents_scale,
+ device_scale,
+ page_scale,
+ maximum_animation_scale,
+ animating_transform);
+ EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 12.f);
+
+ // When animating toward a smaller scale, but that is still so large that the
+ // layer grows larger than the viewport at this scale, a new high-res tiling
+ // should get created at source scale 1.
+ animating_transform = true;
+ contents_scale = 11.f;
+ maximum_animation_scale = 11.f;
+
+ SetContentsScaleOnBothLayers(contents_scale,
+ device_scale,
+ page_scale,
+ maximum_animation_scale,
+ animating_transform);
+ EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), device_scale * page_scale);
+
+ // Once we stop animating, a new high-res tiling should be created.
+ animating_transform = false;
contents_scale = 11.f;
SetContentsScaleOnBothLayers(contents_scale,
pending_layer_->draw_properties().visible_content_rect =
gfx::Rect(1100, 1100, 500, 500);
- pending_layer_->UpdateTiles(Occlusion());
+ bool resourceless_software_draw = false;
+ pending_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
unique_tiles.clear();
high_res_tile_count = 0u;
pending_layer_->draw_properties().visible_content_rect =
gfx::Rect(0, 0, 500, 500);
- pending_layer_->UpdateTiles(Occlusion());
+ pending_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
std::vector<Tile*> high_res_tiles = high_res_tiling->AllTilesForTesting();
for (std::vector<Tile*>::iterator tile_it = high_res_tiles.begin();
AssertNoTilesRequired(pending_layer_->LowResTiling());
}
-TEST_F(NoLowResPictureLayerImplTest,
- ResourcelessSoftwareDrawHasValidViewportForTilePriority) {
+TEST_F(NoLowResPictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
base::TimeTicks time_ticks;
time_ticks += base::TimeDelta::FromMilliseconds(1);
host_impl_.SetCurrentBeginFrameArgs(
SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
// UpdateTiles with valid viewport. Should update tile viewport.
+ // Note viewport is considered invalid if and only if in resourceless
+ // software draw.
bool resourceless_software_draw = false;
gfx::Rect viewport = gfx::Rect(layer_bounds);
gfx::Transform transform;
resourceless_software_draw);
active_layer_->draw_properties().visible_content_rect = viewport;
active_layer_->draw_properties().screen_space_transform = transform;
- active_layer_->UpdateTiles(Occlusion());
+ active_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
gfx::Rect visible_rect_for_tile_priority =
active_layer_->visible_rect_for_tile_priority();
gfx::Transform screen_space_transform_for_tile_priority =
active_layer_->screen_space_transform_for_tile_priority();
- // PictureLayerImpl does not make a special case for
- // resource_less_software_draw, so the tile viewport and matrix should be
- // respected.
+ // Expand viewport and set it as invalid for prioritizing tiles.
+ // Should update viewport and transform, but not update visible rect.
time_ticks += base::TimeDelta::FromMilliseconds(200);
host_impl_.SetCurrentBeginFrameArgs(
CreateBeginFrameArgsForTesting(time_ticks));
viewport,
transform,
resourceless_software_draw);
- active_layer_->UpdateTiles(Occlusion());
-
- visible_rect_for_tile_priority =
- gfx::ScaleToEnclosingRect(visible_rect_for_tile_priority, 2);
- viewport_rect_for_tile_priority =
- gfx::ScaleToEnclosingRect(viewport_rect_for_tile_priority, 2);
- screen_space_transform_for_tile_priority = transform;
-
- EXPECT_RECT_EQ(visible_rect_for_tile_priority,
- active_layer_->visible_rect_for_tile_priority());
- EXPECT_RECT_EQ(viewport_rect_for_tile_priority,
- active_layer_->viewport_rect_for_tile_priority());
+ active_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
+
+ // Viewport and transform for tile priority are updated.
+ EXPECT_EQ(viewport, active_layer_->viewport_rect_for_tile_priority());
EXPECT_TRANSFORMATION_MATRIX_EQ(
- screen_space_transform_for_tile_priority,
- active_layer_->screen_space_transform_for_tile_priority());
+ transform, active_layer_->screen_space_transform_for_tile_priority());
+ // Visible rect for tile priority retains old value.
+ EXPECT_EQ(visible_rect_for_tile_priority,
+ active_layer_->visible_rect_for_tile_priority());
+
+ // Keep expanded viewport but mark it valid. Should update tile viewport.
+ time_ticks += base::TimeDelta::FromMilliseconds(200);
+ host_impl_.SetCurrentBeginFrameArgs(
+ CreateBeginFrameArgsForTesting(time_ticks));
+ resourceless_software_draw = false;
+ host_impl_.SetExternalDrawConstraints(transform,
+ viewport,
+ viewport,
+ viewport,
+ transform,
+ resourceless_software_draw);
+ active_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
+
+ EXPECT_TRANSFORMATION_MATRIX_EQ(
+ transform, active_layer_->screen_space_transform_for_tile_priority());
+ EXPECT_EQ(viewport, active_layer_->visible_rect_for_tile_priority());
+
+ // Match the reverse translate in |transform|.
+ EXPECT_EQ(viewport - gfx::Vector2d(1, 1),
+ active_layer_->viewport_rect_for_tile_priority());
}
TEST_F(NoLowResPictureLayerImplTest, CleanUpTilings) {
SetupPendingTree(pending_pile);
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 {
ASSERT_TRUE(active_layer_->tilings());
- active_layer_->set_fixed_tile_size(tile_size);
- host_impl_.active_tree()->UpdateDrawProperties();
ASSERT_GT(active_layer_->tilings()->num_tilings(), 0u);
std::vector<Tile*> tiles =
active_layer_->tilings()->tiling_at(0)->AllTilesForTesting();
projects / platform / framework / web / crosswalk.git / blobdiff