cc: Add an integration test for what scale we draw with after pinching

cc/trees/layer_tree_host_unittest.cc

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