Refactor FindScrollLayerForDeviceViewportPoint to use scroll nodes over layer ids

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 557 matching lines @@
     return false;
 
   gfx::PointF device_viewport_point = gfx::ScalePoint(
       gfx::PointF(viewport_point), active_tree_->device_scale_factor());
 
   LayerImpl* layer_impl =
       active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
 
   bool scroll_on_main_thread = false;
   uint32_t main_thread_scrolling_reasons;
-  LayerImpl* test_layer_impl = FindScrollLayerForDeviceViewportPoint(
+  auto* test_scroll_node = FindScrollNodeForDeviceViewportPoint(
       device_viewport_point, type, layer_impl, &scroll_on_main_thread,
       &main_thread_scrolling_reasons);
 
   if (scroll_on_main_thread)
     return false;
 
-  int test_scroll_tree_index = test_layer_impl->scroll_tree_index();
-  if (scrolling_node->id == test_scroll_tree_index)
+  if (scrolling_node == test_scroll_node)
     return true;
 
   // For active scrolling state treat the inner/outer viewports interchangeably.
   if (scrolling_node->scrolls_inner_viewport ||
       scrolling_node->scrolls_outer_viewport) {
-    return test_layer_impl == viewport()->MainScrollLayer();
+    return test_scroll_node == OuterViewportScrollNode();
   }
 
   return false;
 }
 
 EventListenerProperties LayerTreeHostImpl::GetEventListenerProperties(
     EventListenerClass event_class) const {
   return active_tree_->event_listener_properties(event_class);
 }
 
@@ skipping 2016 matching lines @@
           status.main_thread_scrolling_reasons));
     } else {
       DCHECK(MainThreadScrollingReason::CompositorCanSetScrollReasons(
           status.main_thread_scrolling_reasons));
     }
     return true;
   }
   return false;
 }
 
-LayerImpl* LayerTreeHostImpl::FindScrollLayerForDeviceViewportPoint(
+ScrollNode* LayerTreeHostImpl::FindScrollNodeForDeviceViewportPoint(
     const gfx::PointF& device_viewport_point,
     InputHandler::ScrollInputType type,
     LayerImpl* layer_impl,
     bool* scroll_on_main_thread,
     uint32_t* main_thread_scrolling_reasons) const {
   DCHECK(scroll_on_main_thread);
   DCHECK(main_thread_scrolling_reasons);
   *main_thread_scrolling_reasons =
       MainThreadScrollingReason::kNotScrollingOnMain;
 
   // Walk up the hierarchy and look for a scrollable layer.
   ScrollTree& scroll_tree = active_tree_->property_trees()->scroll_tree;
   ScrollNode* impl_scroll_node = nullptr;
   if (layer_impl) {
     ScrollNode* scroll_node = scroll_tree.Node(layer_impl->scroll_tree_index());
     for (; scroll_tree.parent(scroll_node);
          scroll_node = scroll_tree.parent(scroll_node)) {
       // The content layer can also block attempts to scroll outside the main
       // thread.
       ScrollStatus status =
           TryScroll(device_viewport_point, type, scroll_tree, scroll_node);
       if (IsMainThreadScrolling(status, scroll_node)) {
         *scroll_on_main_thread = true;
         *main_thread_scrolling_reasons = status.main_thread_scrolling_reasons;
-        return active_tree_->LayerById(scroll_node->owning_layer_id);
+        return scroll_node;
       }
 
       if (status.thread == InputHandler::SCROLL_ON_IMPL_THREAD &&
           !impl_scroll_node) {
         impl_scroll_node = scroll_node;
       }
     }
   }
 
   // Falling back to the viewport layer ensures generation of root overscroll
   // notifications. We use the viewport's main scroll layer to represent the
   // viewport in scrolling code.
   bool scrolls_inner_viewport =
       impl_scroll_node && impl_scroll_node->scrolls_inner_viewport;
   bool scrolls_outer_viewport =
       impl_scroll_node && impl_scroll_node->scrolls_outer_viewport;
   if (!impl_scroll_node || scrolls_inner_viewport || scrolls_outer_viewport)
     impl_scroll_node = OuterViewportScrollNode();
 
   if (impl_scroll_node) {
     // Ensure that final layer scrolls on impl thread (crbug.com/625100)
     ScrollStatus status =
         TryScroll(device_viewport_point, type, scroll_tree, impl_scroll_node);
     if (IsMainThreadScrolling(status, impl_scroll_node)) {
       *scroll_on_main_thread = true;
       *main_thread_scrolling_reasons = status.main_thread_scrolling_reasons;
     }
   }
 
-  // TODO(pdr): Refactor this function to directly return |impl_scroll_node|
-  // instead of using ScrollNode's owning_layer_id to return a LayerImpl.
-  if (!impl_scroll_node)
-    return nullptr;
-  return active_tree_->LayerById(impl_scroll_node->owning_layer_id);
+  return impl_scroll_node;
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBeginImpl(
     ScrollState* scroll_state,
     ScrollNode* scrolling_node,
     InputHandler::ScrollInputType type) {
   DCHECK(scroll_state);
   DCHECK(scroll_state->delta_x() == 0 && scroll_state->delta_y() == 0);
 
   InputHandler::ScrollStatus scroll_status;
@@ skipping 64 matching lines @@
 
     if (layer_impl) {
       if (!IsInitialScrollHitTestReliable(layer_impl, device_viewport_point)) {
         scroll_status.thread = SCROLL_UNKNOWN;
         scroll_status.main_thread_scrolling_reasons =
             MainThreadScrollingReason::kFailedHitTest;
         return scroll_status;
       }
     }
 
-    auto* scrolling_layer = FindScrollLayerForDeviceViewportPoint(
+    scrolling_node = FindScrollNodeForDeviceViewportPoint(
         device_viewport_point, type, layer_impl, &scroll_on_main_thread,
         &scroll_status.main_thread_scrolling_reasons);
-    ScrollTree& scroll_tree = active_tree_->property_trees()->scroll_tree;
-    scrolling_node =
-        scrolling_layer ? scroll_tree.Node(scrolling_layer->scroll_tree_index())
-                        : nullptr;
   }
 
   if (scroll_on_main_thread) {
     RecordCompositorSlowScrollMetric(type, MAIN_THREAD);
 
     scroll_status.thread = SCROLL_ON_MAIN_THREAD;
     return scroll_status;
   } else if (scrolling_node) {
     scroll_affects_scroll_handler_ = active_tree_->have_scroll_event_handlers();
   }
@@ skipping 621 matching lines @@
 }
 
 void LayerTreeHostImpl::MouseMoveAt(const gfx::Point& viewport_point) {
   gfx::PointF device_viewport_point = gfx::ScalePoint(
       gfx::PointF(viewport_point), active_tree_->device_scale_factor());
   LayerImpl* layer_impl =
       active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
 
   // Check if mouse is over a scrollbar or not.
   // TODO(sahel): get rid of this extera checking when
-  // FindScrollLayerForDeviceViewportPoint finds the proper layer for
-  // scrolling on main thread when mouse is over scrollbar as well.
-  ElementId new_element_id;
+  // FindScrollNodeForDeviceViewportPoint finds the proper node for scrolling on
+  // the main thread when the mouse is over a scrollbar as well.
+  ElementId scroll_element_id;
   if (layer_impl && layer_impl->ToScrollbarLayer())
-    new_element_id = layer_impl->ToScrollbarLayer()->scroll_element_id();
-  if (!new_element_id) {
+    scroll_element_id = layer_impl->ToScrollbarLayer()->scroll_element_id();
+  if (!scroll_element_id) {
     bool scroll_on_main_thread = false;
     uint32_t main_thread_scrolling_reasons;
-    LayerImpl* scroll_layer_impl = FindScrollLayerForDeviceViewportPoint(
+    auto* scroll_node = FindScrollNodeForDeviceViewportPoint(
         device_viewport_point, InputHandler::TOUCHSCREEN, layer_impl,
         &scroll_on_main_thread, &main_thread_scrolling_reasons);
+    if (scroll_node)
+      scroll_element_id = scroll_node->element_id;
 
     // Scrollbars for the viewport are registered with the outer viewport layer.
-    if (scroll_layer_impl == InnerViewportScrollLayer())
-      scroll_layer_impl = OuterViewportScrollLayer();
-
-    if (scroll_layer_impl)
-      new_element_id = scroll_layer_impl->element_id();
+    if (InnerViewportScrollLayer() && OuterViewportScrollLayer() &&
+        scroll_element_id == InnerViewportScrollLayer()->element_id())
+      scroll_element_id = OuterViewportScrollLayer()->element_id();
   }
 
-  if (new_element_id != scroll_element_id_mouse_currently_over_) {
+  if (scroll_element_id != scroll_element_id_mouse_currently_over_) {
     ScrollbarAnimationController* old_animation_controller =
         ScrollbarAnimationControllerForElementId(
             scroll_element_id_mouse_currently_over_);
     if (old_animation_controller) {
       old_animation_controller->DidMouseLeave();
     }
-    scroll_element_id_mouse_currently_over_ = new_element_id;
+    scroll_element_id_mouse_currently_over_ = scroll_element_id;
   }
 
   ScrollbarAnimationController* new_animation_controller =
-      ScrollbarAnimationControllerForElementId(new_element_id);
+      ScrollbarAnimationControllerForElementId(scroll_element_id);
   if (!new_animation_controller)
     return;
 
-  int new_layer_id = active_tree_->LayerIdByElementId(new_element_id);
+  int scroll_layer_id = active_tree_->LayerIdByElementId(scroll_element_id);
   for (ScrollbarLayerImplBase* scrollbar :
-       active_tree_->ScrollbarsFor(new_layer_id)) {
+       active_tree_->ScrollbarsFor(scroll_layer_id)) {
     new_animation_controller->DidMouseMoveNear(
         scrollbar->orientation(),
         DeviceSpaceDistanceToLayer(device_viewport_point, scrollbar) /
             active_tree_->device_scale_factor());
   }
 }
 
 void LayerTreeHostImpl::MouseLeave() {
   for (auto& pair : scrollbar_animation_controllers_)
     pair.second->DidMouseLeave();
@@ skipping 817 matching lines @@
 }
 
 void LayerTreeHostImpl::UpdateScrollSourceInfo(bool is_wheel_scroll) {
   if (is_wheel_scroll)
     has_scrolled_by_wheel_ = true;
   else
     has_scrolled_by_touch_ = true;
 }
 
 }  // namespace cc