Made layout viewport scroll updates from compositor work like ordinary layers.

cc/trees/layer_tree_host_unittest_scroll.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host.h"
 
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 75 matching lines @@
         scroll_amount_(2, -1),
         num_scrolls_(0) {}
 
   void BeginTest() override {
     outer_viewport_container_layer_id_ = layer_tree_host()
                                              ->outer_viewport_scroll_layer()
                                              ->scroll_clip_layer()
                                              ->id();
     layer_tree_host()->outer_viewport_scroll_layer()->SetScrollOffset(
         initial_scroll_);
+    layer_tree_host()->outer_viewport_scroll_layer()->set_did_scroll_callback(
+        base::Bind(&LayerTreeHostScrollTestScrollSimple::DidScrollOuterViewport,
+                   base::Unretained(this)));
     PostSetNeedsCommitToMainThread();
   }
 
   void UpdateLayerTreeHost() override {
     Layer* scroll_layer = layer_tree_host()->outer_viewport_scroll_layer();
     if (!layer_tree_host()->source_frame_number()) {
       EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->scroll_offset());
     } else {
       EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(initial_scroll_,
                                                   scroll_amount_),
@@ skipping 25 matching lines @@
       case 1:
         EXPECT_VECTOR_EQ(second_scroll_, ScrollTreeForLayer(scroll_layer)
                                              ->GetScrollOffsetBaseForTesting(
                                                  scroll_layer->id()));
         EXPECT_VECTOR_EQ(scroll_amount_, ScrollDelta(scroll_layer));
         EndTest();
         break;
     }
   }
 
-  void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
-                           const gfx::Vector2dF& outer_delta,
-                           const gfx::Vector2dF& elastic_overscroll_delta,
-                           float scale,
-                           float top_controls_delta) override {
-    num_scrolls_++;
-  }
+  void DidScrollOuterViewport() { num_scrolls_++; }
 
   void AfterTest() override { EXPECT_EQ(1, num_scrolls_); }
 
  private:
   gfx::ScrollOffset initial_scroll_;
   gfx::ScrollOffset second_scroll_;
   gfx::Vector2dF scroll_amount_;
   int num_scrolls_;
   int outer_viewport_container_layer_id_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestScrollSimple);
 
 class LayerTreeHostScrollTestScrollMultipleRedraw
     : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollMultipleRedraw()
       : initial_scroll_(40, 10), scroll_amount_(-3, 17), num_scrolls_(0) {}
 
   void BeginTest() override {
     scroll_layer_ = layer_tree_host()->outer_viewport_scroll_layer();
     scroll_layer_->SetScrollOffset(initial_scroll_);
+    scroll_layer_->set_did_scroll_callback(base::Bind(
+        &LayerTreeHostScrollTestScrollMultipleRedraw::DidScrollOuterViewport,
+        base::Unretained(this)));
     PostSetNeedsCommitToMainThread();
   }
 
   void BeginCommitOnThread(LayerTreeHostImpl* impl) override {
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
         EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer_->scroll_offset());
         break;
       case 1:
         EXPECT_VECTOR_EQ(
@@ skipping 37 matching lines @@
       // Third or later draw after second commit.
       EXPECT_GE(impl->SourceAnimationFrameNumberForTesting(), 3u);
       EXPECT_VECTOR_EQ(
           gfx::ScrollOffsetWithDelta(initial_scroll_,
                                      scroll_amount_ + scroll_amount_),
           scroll_layer_->scroll_offset());
       EndTest();
     }
   }
 
-  void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
-                           const gfx::Vector2dF& outer_delta,
-                           const gfx::Vector2dF& elastic_overscroll_delta,
-                           float scale,
-                           float top_controls_delta) override {
-    num_scrolls_++;
-  }
+  void DidScrollOuterViewport() { num_scrolls_++; }
 
   void AfterTest() override { EXPECT_EQ(1, num_scrolls_); }
 
  private:
   gfx::ScrollOffset initial_scroll_;
   gfx::Vector2dF scroll_amount_;
   int num_scrolls_;
   scoped_refptr<Layer> scroll_layer_;
 };
 
@@ skipping 10 matching lines @@
         num_will_begin_main_frames_(0),
         num_did_begin_main_frames_(0),
         num_will_commits_(0),
         num_did_commits_(0),
         num_impl_commits_(0),
         num_impl_scrolls_(0) {}
 
   void BeginTest() override {
     layer_tree_host()->outer_viewport_scroll_layer()->SetScrollOffset(
         initial_scroll_);
+    layer_tree_host()->outer_viewport_scroll_layer()->set_did_scroll_callback(
+        base::Bind(
+            &LayerTreeHostScrollTestScrollAbortedCommit::DidScrollOuterViewport,
+            base::Unretained(this)));
     PostSetNeedsCommitToMainThread();
   }
 
   void SetupTree() override {
     LayerTreeHostScrollTest::SetupTree();
 
     gfx::Size scroll_layer_bounds(200, 200);
     layer_tree_host()->outer_viewport_scroll_layer()->SetBounds(
         scroll_layer_bounds);
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
@@ skipping 128 matching lines @@
           gfx::ScrollOffsetWithDelta(initial_scroll_, delta),
           ScrollTreeForLayer(root_scroll_layer)
               ->GetScrollOffsetBaseForTesting(root_scroll_layer->id()));
       EndTest();
     } else {
       // Commit for source frame 3 is aborted.
       NOTREACHED();
     }
   }
 
-  void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
-                           const gfx::Vector2dF& outer_delta,
-                           const gfx::Vector2dF& elastic_overscroll_delta,
-                           float scale,
-                           float top_controls_delta) override {
-    num_impl_scrolls_++;
-  }
+  void DidScrollOuterViewport() { num_impl_scrolls_++; }
 
   void AfterTest() override {
     EXPECT_EQ(3, num_impl_scrolls_);
     // Verify that the embedder sees aborted commits as real commits.
     EXPECT_EQ(4, num_will_begin_main_frames_);
     EXPECT_EQ(4, num_did_begin_main_frames_);
     EXPECT_EQ(4, num_will_commits_);
     EXPECT_EQ(4, num_did_commits_);
     // ...but the compositor thread only sees two real ones.
     EXPECT_EQ(2, num_impl_commits_);
@@ skipping 180 matching lines @@
     } else {
       expected_scroll_layer_ = root_scroll_layer_;
       expected_no_scroll_layer_ = child_layer_;
     }
 
     expected_scroll_layer_->SetScrollOffset(initial_offset_);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeTest::SetupTree();
     fake_content_layer_client_.set_bounds(root_layer->bounds());
+
+    layer_tree_host()->outer_viewport_scroll_layer()->set_did_scroll_callback(
+        base::Bind(
+            &LayerTreeHostScrollTestCaseWithChild::DidScrollOuterViewport,
+            base::Unretained(this)));
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void WillCommit() override {
     // Keep the test committing (otherwise the early out for no update
     // will stall the test).
     if (layer_tree_host()->source_frame_number() < 2) {
       layer_tree_host()->SetNeedsCommit();
     }
   }
 
   void DidScroll() {
     final_scroll_offset_ = expected_scroll_layer_->scroll_offset();
   }
 
-  void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
-                           const gfx::Vector2dF& outer_delta,
-                           const gfx::Vector2dF& elastic_overscroll_delta,
-                           float scale,
-                           float top_controls_delta) override {
-    num_scrolls_++;
-  }
+  void DidScrollOuterViewport() { num_scrolls_++; }
 
   void UpdateLayerTreeHost() override {
     EXPECT_VECTOR_EQ(gfx::Vector2d(),
                      expected_no_scroll_layer_->scroll_offset());
 
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
         EXPECT_VECTOR_EQ(initial_offset_,
                          expected_scroll_layer_->scroll_offset());
         break;
@@ skipping 223 matching lines @@
         num_scrolls_(0) {}
 
   void SetupTree() override {
     LayerTreeHostScrollTest::SetupTree();
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
   }
 
   void BeginTest() override {
     layer_tree_host()->outer_viewport_scroll_layer()->SetScrollOffset(
         initial_scroll_);
+    layer_tree_host()->outer_viewport_scroll_layer()->set_did_scroll_callback(
+        base::Bind(&LayerTreeHostScrollTestSimple::DidScrollOuterViewport,
+                   base::Unretained(this)));
     PostSetNeedsCommitToMainThread();
   }
 
   void UpdateLayerTreeHost() override {
     Layer* scroll_layer = layer_tree_host()->outer_viewport_scroll_layer();
     if (!layer_tree_host()->source_frame_number()) {
       EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->scroll_offset());
     } else {
       EXPECT_VECTOR_EQ(
           scroll_layer->scroll_offset(),
@@ skipping 67 matching lines @@
             gfx::ScrollOffsetWithDelta(
                 initial_scroll_, main_thread_scroll_ + impl_thread_scroll1_),
             ScrollTreeForLayer(scroll_layer)
                 ->GetScrollOffsetBaseForTesting(scroll_layer->id()));
         EXPECT_VECTOR_EQ(impl_thread_scroll2_, ScrollDelta(scroll_layer));
         EndTest();
         break;
     }
   }
 
-  void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
-                           const gfx::Vector2dF& outer_delta,
-                           const gfx::Vector2dF& elastic_overscroll_delta,
-                           float scale,
-                           float top_controls_delta) override {
-    num_scrolls_++;
-  }
+  void DidScrollOuterViewport() { num_scrolls_++; }
 
   void AfterTest() override { EXPECT_EQ(1, num_scrolls_); }
 
  private:
   gfx::ScrollOffset initial_scroll_;
   gfx::Vector2dF main_thread_scroll_;
   gfx::Vector2dF impl_thread_scroll1_;
   gfx::Vector2dF impl_thread_scroll2_;
   int num_scrolls_;
 };
@@ skipping 543 matching lines @@
     settings->main_frame_before_activation_enabled = true;
   }
 
   void BeginTest() override {
     outer_viewport_container_layer_id_ = layer_tree_host()
                                              ->outer_viewport_scroll_layer()
                                              ->scroll_clip_layer()
                                              ->id();
     layer_tree_host()->outer_viewport_scroll_layer()->SetScrollOffset(
         initial_scroll_);
+    layer_tree_host()->outer_viewport_scroll_layer()->set_did_scroll_callback(
+        base::Bind(&LayerTreeHostScrollTestScrollMFBA::DidScrollOuterViewport,
+                   base::Unretained(this)));
     PostSetNeedsCommitToMainThread();
   }
 
   void StartCommitOnImpl() override {
     switch (num_commits_) {
       case 1:
         // Ask for commit here because activation (and draw) will be blocked.
         GetProxyImplForTest()->SetNeedsCommitOnImpl();
         // Block activation after second commit until third commit is ready.
         GetProxyImplForTest()->BlockNotifyReadyToActivateForTesting(true);
@@ skipping 54 matching lines @@
         // The scroll hasn't been consumed by the main thread.
         EXPECT_VECTOR_EQ(scroll_amount_, ScrollDelta(scroll_layer));
         EXPECT_VECTOR_EQ(third_scroll_, ScrollTreeForLayer(scroll_layer)
                                             ->GetScrollOffsetBaseForTesting(
                                                 scroll_layer->id()));
         EndTest();
         break;
     }
   }
 
-  void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
-                           const gfx::Vector2dF& outer_delta,
-                           const gfx::Vector2dF& elastic_overscroll_delta,
-                           float scale,
-                           float top_controls_delta) override {
-    num_scrolls_++;
-  }
+  void DidScrollOuterViewport() { num_scrolls_++; }
 
   void AfterTest() override {
     EXPECT_EQ(3, num_commits_);
     EXPECT_EQ(1, num_scrolls_);
   }
 
  private:
   void Scroll(LayerTreeHostImpl* impl) {
     LayerImpl* root = impl->active_tree()->root_layer_for_testing();
     LayerImpl* scroll_layer = impl->OuterViewportScrollLayer();
@@ skipping 31 matching lines @@
         num_impl_scrolls_(0),
         num_draws_(0) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->main_frame_before_activation_enabled = true;
   }
 
   void BeginTest() override {
     layer_tree_host()->outer_viewport_scroll_layer()->SetScrollOffset(
         initial_scroll_);
+    layer_tree_host()->outer_viewport_scroll_layer()->set_did_scroll_callback(
+        base::Bind(&LayerTreeHostScrollTestScrollAbortedCommitMFBA::
+                       DidScrollOuterViewport,
+                   base::Unretained(this)));
     PostSetNeedsCommitToMainThread();
   }
 
   void SetupTree() override {
     LayerTreeHostScrollTest::SetupTree();
 
     gfx::Size scroll_layer_bounds(200, 200);
     layer_tree_host()->outer_viewport_scroll_layer()->SetBounds(
         scroll_layer_bounds);
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
@@ skipping 143 matching lines @@
             EndTest();
             break;
           }
         }
         break;
       }
     }
     num_draws_++;
   }
 
-  void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
-                           const gfx::Vector2dF& outer_delta,
-                           const gfx::Vector2dF& elastic_overscroll_delta,
-                           float scale,
-                           float top_controls_delta) override {
-    num_impl_scrolls_++;
-  }
+  void DidScrollOuterViewport() { num_impl_scrolls_++; }
 
   void AfterTest() override {
     EXPECT_EQ(3, num_impl_scrolls_);
     // Verify that the embedder sees aborted commits as real commits.
     EXPECT_EQ(4, num_will_begin_main_frames_);
     EXPECT_EQ(4, num_did_begin_main_frames_);
     EXPECT_EQ(4, num_will_commits_);
     EXPECT_EQ(4, num_did_commits_);
     // ...but the compositor thread only sees two real ones.
     EXPECT_EQ(2, num_impl_commits_);
@@ skipping 14 matching lines @@
   int num_impl_commits_;
   int num_aborted_commits_;
   int num_impl_scrolls_;
   int num_draws_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestScrollAbortedCommitMFBA);
 
 }  // namespace
 }  // namespace cc