Index: cc/trees/layer_tree_host_unittest.cc |
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc |
index 8d554dcf0c942426f45c6811b4937ea4dffd6e72..bcdfd8bb9137696b025d4ff3c3afe74439d7ddc6 100644 |
--- a/cc/trees/layer_tree_host_unittest.cc |
+++ b/cc/trees/layer_tree_host_unittest.cc |
@@ -26,6 +26,7 @@ |
#include "cc/output/output_surface.h" |
#include "cc/quads/draw_quad.h" |
#include "cc/quads/io_surface_draw_quad.h" |
+#include "cc/quads/tile_draw_quad.h" |
#include "cc/resources/prioritized_resource.h" |
#include "cc/resources/prioritized_resource_manager.h" |
#include "cc/resources/resource_update_queue.h" |
@@ -5152,4 +5153,160 @@ class LayerTreeHostTestSynchronousCompositeSwapPromise |
// Impl-side painting is not supported for synchronous compositing. |
SINGLE_THREAD_NOIMPL_TEST_F(LayerTreeHostTestSynchronousCompositeSwapPromise); |
+class LayerTreeHostTestCrispUpAfterPinchEnds : public LayerTreeHostTest { |
+ protected: |
+ void InitializeSettings(LayerTreeSettings* settings) override { |
+ settings->impl_side_painting = true; |
+ } |
+ |
+ void SetupTree() override { |
+ frame_ = 1; |
+ posted_ = false; |
+ client_.set_fill_with_nonsolid_color(true); |
+ |
+ scoped_refptr<Layer> root = Layer::Create(); |
+ root->SetBounds(gfx::Size(500, 500)); |
+ |
+ scoped_refptr<Layer> pinch = Layer::Create(); |
+ pinch->SetBounds(gfx::Size(500, 500)); |
+ pinch->SetScrollClipLayerId(root->id()); |
+ pinch->SetIsContainerForFixedPositionLayers(true); |
+ root->AddChild(pinch); |
+ |
+ scoped_refptr<FakePictureLayer> layer = FakePictureLayer::Create(&client_); |
+ layer->SetBounds(gfx::Size(500, 500)); |
+ pinch->AddChild(layer); |
+ |
+ layer_tree_host()->RegisterViewportLayers(root, pinch, pinch); |
+ layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 1.f, 4.f); |
+ layer_tree_host()->SetRootLayer(root); |
+ LayerTreeHostTest::SetupTree(); |
+ } |
+ |
+ float FrameQuadScale(LayerTreeHostImpl::FrameData* frame_data) { |
+ RenderPass* root_pass = frame_data->render_passes.back(); |
+ EXPECT_EQ(DrawQuad::TILED_CONTENT, root_pass->quad_list.front()->material); |
+ const TileDrawQuad* quad = |
+ TileDrawQuad::MaterialCast(root_pass->quad_list.front()); |
+ float quad_scale = |
+ quad->tex_coord_rect.width() / static_cast<float>(quad->rect.width()); |
+ float transform_scale = |
+ SkMScalarToFloat(quad->quadTransform().matrix().get(0, 0)); |
+ return quad_scale / transform_scale; |
+ } |
+ |
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); } |
+ |
+ DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl, |
+ LayerTreeHostImpl::FrameData* frame_data, |
+ DrawResult draw_result) override { |
+ switch (frame_) { |
+ case 1: |
+ // Drew at scale 1 before any pinching. |
+ EXPECT_EQ(1.f, host_impl->active_tree()->total_page_scale_factor()); |
+ EXPECT_EQ(1.f, FrameQuadScale(frame_data)); |
+ PostNextAfterDraw(host_impl); |
+ break; |
+ case 2: |
+ if (frame_data->has_no_damage || frame_data->contains_incomplete_tile) |
+ break; |
+ // Drew at scale 2.2 after pinching in. |
+ EXPECT_EQ(2.2f, host_impl->active_tree()->total_page_scale_factor()); |
+ EXPECT_EQ(1.f, FrameQuadScale(frame_data)); |
+ PostNextAfterDraw(host_impl); |
+ break; |
+ case 3: |
+ if (frame_data->has_no_damage || frame_data->contains_incomplete_tile) |
+ break; |
+ // Drew at scale 1 with the 1.1 tiling while pinching out. |
+ EXPECT_EQ(1.f, host_impl->active_tree()->total_page_scale_factor()); |
+ EXPECT_EQ(1.1f, FrameQuadScale(frame_data)); |
+ PostNextAfterDraw(host_impl); |
+ break; |
+ case 4: |
+ // Drew at scale 1 with the 1.1 tiling after pinching out completed |
+ // while waiting for texture uploads to complete. |
+ EXPECT_EQ(1.f, host_impl->active_tree()->total_page_scale_factor()); |
+ // This frame may not have any damage, since it's actually the same as |
+ // the last frame, and should contain incomplete tiles. We just want to |
+ // make sure we drew here at least once after the pinch ended to be sure |
+ // that drawing after pinch doesn't leave us at the wrong scale forever. |
+ if (!frame_data->has_no_damage) { |
+ EXPECT_EQ(1.1f, FrameQuadScale(frame_data)); |
+ EXPECT_TRUE(frame_data->contains_incomplete_tile); |
+ } |
+ PostNextAfterDraw(host_impl); |
+ break; |
+ case 5: |
+ if (frame_data->has_no_damage || frame_data->contains_incomplete_tile) |
+ break; |
+ // Drew at scale 1 after texture uploads are done. |
+ EXPECT_EQ(1.f, host_impl->active_tree()->total_page_scale_factor()); |
+ EXPECT_EQ(1.f, FrameQuadScale(frame_data)); |
+ EndTest(); |
+ break; |
+ } |
+ return draw_result; |
+ } |
+ |
+ void PostNextAfterDraw(LayerTreeHostImpl* host_impl) { |
+ if (posted_) |
+ return; |
+ posted_ = true; |
+ ImplThreadTaskRunner()->PostDelayedTask( |
+ FROM_HERE, |
+ base::Bind(&LayerTreeHostTestCrispUpAfterPinchEnds::Next, |
+ base::Unretained(this), |
+ host_impl), |
+ // Use a delay to allow raster/upload to happen in between frames. This |
+ // should cause flakiness if we fail to block raster/upload when |
+ // desired. |
+ base::TimeDelta::FromMilliseconds(16 * 6)); |
+ } |
+ |
+ void Next(LayerTreeHostImpl* host_impl) { |
+ ++frame_; |
+ posted_ = false; |
+ switch (frame_) { |
+ case 2: |
+ // Pinch zoom in. |
+ host_impl->PinchGestureBegin(); |
+ host_impl->PinchGestureUpdate(2.2f, gfx::Point(100, 100)); |
+ host_impl->PinchGestureEnd(); |
+ break; |
+ case 3: |
+ // Pinch zoom back but don't end it. |
+ host_impl->PinchGestureBegin(); |
+ host_impl->PinchGestureUpdate(1.f / 2.2f, gfx::Point(100, 100)); |
+ break; |
+ case 4: |
+ // End the pinch, but delay texture uploads. |
+ TestContext()->set_query_result_available_ext(0); |
+ host_impl->PinchGestureEnd(); |
+ break; |
+ case 5: |
+ // Let texture uploads complete. |
+ TestContext()->set_query_result_available_ext(1); |
+ break; |
+ } |
+ } |
+ |
+ void NotifyTileStateChangedOnThread(LayerTreeHostImpl* host_impl, |
+ const Tile* tile) override { |
+ // On frame_ == 4, we are preventing texture uploads from completing, |
+ // so this verifies they are not completing before frame_ == 5. |
+ // Flaky failures here indicate we're failing to prevent uploads from |
+ // completing. |
+ EXPECT_NE(4, frame_); |
+ } |
+ |
+ void AfterTest() override {} |
+ |
+ FakeContentLayerClient client_; |
+ int frame_; |
+ bool posted_; |
+}; |
+ |
+MULTI_THREAD_TEST_F(LayerTreeHostTestCrispUpAfterPinchEnds); |
+ |
} // namespace cc |