End-to-end prototype of compositor scrolling with slimming paint v2

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/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 129 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 DidScrollOuterViewport() { num_scrolls_++; }
+  void DidScrollOuterViewport(const gfx::ScrollOffset&) { 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_;
 };
@@ skipping 62 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 DidScrollOuterViewport() { num_scrolls_++; }
+  void DidScrollOuterViewport(const gfx::ScrollOffset&) { 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 161 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 DidScrollOuterViewport() { num_impl_scrolls_++; }
+  void DidScrollOuterViewport(const gfx::ScrollOffset&) { 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 197 matching lines @@
   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()->SourceFrameNumber() < 2) {
       layer_tree_host()->SetNeedsCommit();
     }
   }
 
-  void DidScroll() {
+  void DidScroll(const gfx::ScrollOffset&) {

[ajuma, 2017/02/06 21:28:52]

Perhaps this (or one of the other tests in this file) could check that the
offset passed in has the right value?

[pdr., 2017/02/07 22:14:34]

I talked offline with both Ali and Walter and both seem cautiously optimistic
about this approach. I've gone ahead and split out the largest (and most
mechanical) part which moves didScroll to ScrollableArea:
https://codereview.chromium.org/2680953002


On 2017/02/06 at 21:28:52, ajuma wrote:
Good idea, done in the split-out patch.

     final_scroll_offset_ = expected_scroll_layer_->scroll_offset();
   }
 
-  void DidScrollOuterViewport() { num_scrolls_++; }
+  void DidScrollOuterViewport(const gfx::ScrollOffset&) { num_scrolls_++; }
 
   void UpdateLayerTreeHost() override {
     EXPECT_VECTOR_EQ(gfx::Vector2d(),
                      expected_no_scroll_layer_->scroll_offset());
 
     switch (layer_tree_host()->SourceFrameNumber()) {
       case 0:
         EXPECT_VECTOR_EQ(initial_offset_,
                          expected_scroll_layer_->scroll_offset());
         break;
@@ skipping 268 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 DidScrollOuterViewport() { num_scrolls_++; }
+  void DidScrollOuterViewport(const gfx::ScrollOffset&) { 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 476 matching lines @@
       layer_tree_host()->SetRootLayer(NULL);
       EndTest();
       return;
     }
     layer->RemoveFromParent();
   }
 
  protected:
   class FakeLayerScrollClient {
    public:
-    void DidScroll() {
+    void DidScroll(const gfx::ScrollOffset&) {
       owner_->DidScroll(layer_);
     }
     LayerTreeHostScrollTestLayerStructureChange* owner_;
     Layer* layer_;
   };
 
   Layer* CreateScrollLayer(Layer* parent, FakeLayerScrollClient* client) {
     scoped_refptr<PictureLayer> scroll_layer =
         PictureLayer::Create(&fake_content_layer_client_);
     scroll_layer->SetBounds(gfx::Size(110, 110));
@@ skipping 131 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 DidScrollOuterViewport() { num_scrolls_++; }
+  void DidScrollOuterViewport(const gfx::ScrollOffset&) { 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 198 matching lines @@
             EndTest();
             break;
           }
         }
         break;
       }
     }
     num_draws_++;
   }
 
-  void DidScrollOuterViewport() { num_impl_scrolls_++; }
+  void DidScrollOuterViewport(const gfx::ScrollOffset&) { 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 261 matching lines @@
  private:
   gfx::ScrollOffset initial_scroll_;
   gfx::ScrollOffset second_scroll_;
   gfx::Vector2dF scroll_amount_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostScrollTestPropertyTreeUpdate);
 
 }  // namespace
 }  // namespace cc