Fix scroll chaining for non-descendants of root scroller.

cc/trees/layer_tree_host_impl.cc

 // 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.
 
 #include "cc/trees/layer_tree_host_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 2203 matching lines @@
 void LayerTreeHostImpl::SetLayerTreeMutator(
     std::unique_ptr<LayerTreeMutator> mutator) {
   if (mutator == mutator_)
     return;
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
                "LayerTreeHostImpl::SetLayerTreeMutator");
   mutator_ = std::move(mutator);
   mutator_->SetClient(this);
 }
 
+LayerImpl* LayerTreeHostImpl::ViewportMainScrollLayer() {
+  return viewport()->MainScrollLayer();
+}
+
 void LayerTreeHostImpl::CleanUpTileManagerAndUIResources() {
   ClearUIResources();
   tile_manager_.FinishTasksAndCleanUp();
   resource_pool_ = nullptr;
   tile_task_manager_ = nullptr;
   single_thread_synchronous_task_graph_runner_ = nullptr;
   image_decode_controller_ = nullptr;
 
   // We've potentially just freed a large number of resources on our various
   // contexts. Flushing now helps ensure these are cleaned up quickly
@@ skipping 589 matching lines @@
   // that can scroll and set up an animation of its scroll offset. Note that
   // this does not currently go through the scroll customization machinery
   // that ScrollBy uses for non-animated wheel scrolls.
   scroll_status = ScrollBegin(&scroll_state, WHEEL);
   scroll_node = scroll_tree.CurrentlyScrollingNode();
   if (scroll_status.thread == SCROLL_ON_IMPL_THREAD) {
     gfx::Vector2dF pending_delta = scroll_delta;
     if (scroll_node) {
       for (; scroll_tree.parent(scroll_node);
            scroll_node = scroll_tree.parent(scroll_node)) {
-        if (!scroll_node->scrollable ||
-            scroll_node->is_outer_viewport_scroll_layer)
+        if (!scroll_node->scrollable)
           continue;
 
-        if (scroll_node->is_inner_viewport_scroll_layer) {
+        if (viewport()->MainScrollLayer() &&
+            scroll_node->owner_id == viewport()->MainScrollLayer()->id()) {
           gfx::Vector2dF scrolled =
               viewport()->ScrollAnimated(pending_delta, delayed_by);
           // Viewport::ScrollAnimated returns pending_delta as long as it
           // starts an animation.
           if (scrolled == pending_delta)
             return scroll_status;
-          pending_delta -= scrolled;
-          continue;
+          break;
         }
 
         gfx::Vector2dF scroll_delta =
             ComputeScrollDelta(scroll_node, pending_delta);
         if (ScrollAnimationCreate(scroll_node, scroll_delta, delayed_by))
           return scroll_status;
 
         pending_delta -= scroll_delta;
       }
     }
@@ skipping 179 matching lines @@
 }
 
 void LayerTreeHostImpl::DistributeScrollDelta(ScrollState* scroll_state) {
   // TODO(majidvp): in Blink we compute scroll chain only at scroll begin which
   // is not the case here. We eventually want to have the same behaviour on both
   // sides but it may become a non issue if we get rid of scroll chaining (see
   // crbug.com/526462)
   std::list<const ScrollNode*> current_scroll_chain;
   ScrollTree& scroll_tree = active_tree_->property_trees()->scroll_tree;
   ScrollNode* scroll_node = scroll_tree.CurrentlyScrollingNode();
+  ScrollNode* viewport_scroll_node =
+      viewport()->MainScrollLayer()
+          ? scroll_tree.Node(viewport()->MainScrollLayer()->scroll_tree_index())
+          : nullptr;
   if (scroll_node) {
+    // TODO(bokan): The loop checks for a null parent but don't we still want to
+    // distribute to the root scroll node?
     for (; scroll_tree.parent(scroll_node);
          scroll_node = scroll_tree.parent(scroll_node)) {
-      if (scroll_node->is_outer_viewport_scroll_layer) {
-        // TODO(bokan): This should use Viewport::MainScrollLayer once that
-        // returns the outer viewport scroll layer.
+      if (scroll_node == viewport_scroll_node) {
         // Don't chain scrolls past the outer viewport scroll layer. Once we
         // reach that, we should scroll the viewport which is represented by the
         // main viewport scroll layer.
-        DCHECK(viewport()->MainScrollLayer());
-        ScrollNode* viewport_scroll_node = scroll_tree.Node(
-            viewport()->MainScrollLayer()->scroll_tree_index());
         DCHECK(viewport_scroll_node);
         current_scroll_chain.push_front(viewport_scroll_node);
         break;
       }
 
       if (!scroll_node->scrollable)
         continue;
 
       current_scroll_chain.push_front(scroll_node);
     }
@@ skipping 177 matching lines @@
       active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
   HandleMouseOverScrollbar(layer_impl);
   if (scroll_layer_id_when_mouse_over_scrollbar_ != Layer::INVALID_ID)
     return;
 
   bool scroll_on_main_thread = false;
   uint32_t main_thread_scrolling_reasons;
   LayerImpl* scroll_layer_impl = FindScrollLayerForDeviceViewportPoint(
       device_viewport_point, InputHandler::TOUCHSCREEN, layer_impl,
       &scroll_on_main_thread, &main_thread_scrolling_reasons);
+
   // Scrollbars for the viewport are registered with the outer viewport layer.
   if (scroll_layer_impl == InnerViewportScrollLayer())
     scroll_layer_impl = OuterViewportScrollLayer();
+
   if (scroll_on_main_thread || !scroll_layer_impl)
     return;
 
   ScrollbarAnimationController* animation_controller =
       ScrollbarAnimationControllerForId(scroll_layer_impl->id());
   if (!animation_controller)
     return;
 
   float distance_to_scrollbar = std::numeric_limits<float>::max();
   for (ScrollbarLayerImplBase* scrollbar :
@@ skipping 822 matching lines @@
   if (is_visible) {
     worker_context_visibility_ =
         worker_context->CacheController()->ClientBecameVisible();
   } else {
     worker_context->CacheController()->ClientBecameNotVisible(
         std::move(worker_context_visibility_));
   }
 }
 
 }  // namespace cc