Track the currently scrolling ScrollNode instead of the scrolling layer

cc/trees/layer_tree_host_impl.h

 // Copyright 2011 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.
 
 #ifndef CC_TREES_LAYER_TREE_HOST_IMPL_H_
 #define CC_TREES_LAYER_TREE_HOST_IMPL_H_
 
 #include <stddef.h>
 
 #include <bitset>
@@ skipping 416 matching lines @@
   const LayerTreeImpl* recycle_tree() const { return recycle_tree_.get(); }
   // Returns the tree LTH synchronizes with.
   LayerTreeImpl* sync_tree() const {
     // TODO(enne): This is bogus.  It should return based on the value of
     // CommitToActiveTree() and not whether the pending tree exists.
     return pending_tree_ ? pending_tree_.get() : active_tree_.get();
   }
   virtual void CreatePendingTree();
   virtual void ActivateSyncTree();
 
-  // Shortcuts to layers on the active tree.
+  // Shortcuts to layers/nodes on the active tree.
   LayerImpl* InnerViewportScrollLayer() const;
   LayerImpl* OuterViewportScrollLayer() const;
-  LayerImpl* CurrentlyScrollingLayer() const;
+  ScrollNode* CurrentlyScrollingNode();
+  const ScrollNode* CurrentlyScrollingNode() const;
 
   bool scroll_affects_scroll_handler() const {
     return scroll_affects_scroll_handler_;
   }
   void QueueSwapPromiseForMainThreadScrollUpdate(
       std::unique_ptr<SwapPromise> swap_promise);
 
   bool IsActivelyScrolling() const;
 
   virtual void SetVisible(bool visible);
@@ skipping 191 matching lines @@
   void UpdateSyncTreeAfterCommitOrImplSideInvalidation();
 
   // Returns true if status changed.
   bool UpdateGpuRasterizationStatus();
   void UpdateTreeResourcesForGpuRasterizationIfNeeded();
 
   Viewport* viewport() const { return viewport_.get(); }
 
   InputHandler::ScrollStatus ScrollBeginImpl(
       ScrollState* scroll_state,
-      LayerImpl* scrolling_layer_impl,
+      ScrollNode* scrolling_node,
       InputHandler::ScrollInputType type);
   bool IsInitialScrollHitTestReliable(LayerImpl* layer, const gfx::PointF&);
   void DistributeScrollDelta(ScrollState* scroll_state);
 
   bool AnimatePageScale(base::TimeTicks monotonic_time);
   bool AnimateScrollbars(base::TimeTicks monotonic_time);
   bool AnimateBrowserControls(base::TimeTicks monotonic_time);
 
   void TrackDamageForAllSurfaces(
       const LayerImplList& render_surface_layer_list);
 
   void UpdateTileManagerMemoryPolicy(const ManagedMemoryPolicy& policy);
 
   // This function should only be called from PrepareToDraw, as DidDrawAllLayers
   // must be called if this helper function is called.  Returns DRAW_SUCCESS if
   // the frame should be drawn.
   DrawResult CalculateRenderPasses(FrameData* frame);
 
-  void ClearCurrentlyScrollingLayer();
+  void ClearCurrentlyScrollingNode();
 
   LayerImpl* FindScrollLayerForDeviceViewportPoint(
       const gfx::PointF& device_viewport_point,
       InputHandler::ScrollInputType type,
       LayerImpl* layer_hit_by_point,
       bool* scroll_on_main_thread,
       uint32_t* main_thread_scrolling_reason) const;
   float DeviceSpaceDistanceToLayer(const gfx::PointF& device_viewport_point,
                                    LayerImpl* layer_impl);
   void StartScrollbarFadeRecursive(LayerImpl* layer);
@@ skipping 77 matching lines @@
   bool visible_;
   ManagedMemoryPolicy cached_managed_memory_policy_;
 
   const bool is_synchronous_single_threaded_;
   TileManager tile_manager_;
   DecodedImageTracker decoded_image_tracker_;
 
   gfx::Vector2dF accumulated_root_overscroll_;
 
   bool pinch_gesture_active_;
-  bool pinch_gesture_end_should_clear_scrolling_layer_;
+  bool pinch_gesture_end_should_clear_scrolling_node_;
 
   std::unique_ptr<BrowserControlsOffsetManager>
       browser_controls_offset_manager_;
 
   std::unique_ptr<PageScaleAnimation> page_scale_animation_;
 
   std::unique_ptr<FrameRateCounter> fps_counter_;
   std::unique_ptr<MemoryHistory> memory_history_;
   std::unique_ptr<DebugRectHistory> debug_rect_history_;
 
@@ skipping 54 matching lines @@
 
   std::unique_ptr<PendingTreeDurationHistogramTimer>
       pending_tree_duration_timer_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_IMPL_H_