Return main thread scroll layer in FindScrollLayerForDeviceViewportPoint

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 1641 matching lines @@
 
   // Collect all resource ids in the render passes into a single array.
   ResourceProvider::ResourceIdArray resources;
   for (const auto& render_pass : frame->render_passes) {
     for (auto* quad : render_pass->quad_list) {
       for (ResourceId resource_id : quad->resources)
         resources.push_back(resource_id);
     }
   }
 
-
   CompositorFrame compositor_frame;
   compositor_frame.metadata = std::move(metadata);
   resource_provider_->PrepareSendToParent(resources,
                                           &compositor_frame.resource_list);
   compositor_frame.render_pass_list = std::move(frame->render_passes);
   compositor_frame_sink_->SubmitCompositorFrame(std::move(compositor_frame));
 
   // Clears the list of swap promises after calling DidSwap on each of them to
   // signal that the swap is over.
   active_tree()->ClearSwapPromises();
@@ skipping 896 matching lines @@
     if (IsMainThreadScrolling(status, scroll_node)) {
       *scroll_on_main_thread = true;
       *main_thread_scrolling_reasons = status.main_thread_scrolling_reasons;
       return NULL;
     }
   }
 
   return potentially_scrolling_layer_impl;
 }
 
+LayerImpl* LayerTreeHostImpl::FindScrollLayerByLayer(

[bokan, 2017/01/10 22:36:22]

This method avoids the walk up the parent layers looking for a scrollable one.
i.e. if the hit layer isn't itself scrollable this wont work. Instead, I think
you should modify FindScrollLayerForDeviceViewportPoint to return a layer even
if it's main thread scrolling. Since it returns whether the layer scrolls on
main, you can modify the other call sites that expect NULL to check
scrolls_on_main_thread.

+    LayerImpl* layer_impl) const {
+  ScrollTree& scroll_tree = active_tree_->property_trees()->scroll_tree;
+  LayerImpl* potentially_scrolling_layer_impl = nullptr;
+  if (layer_impl) {
+    ScrollNode* scroll_node = scroll_tree.Node(layer_impl->scroll_tree_index());
+    potentially_scrolling_layer_impl =
+        active_tree_->LayerById(scroll_node->owning_layer_id);
+  }
+
+  // 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.
+  if (!potentially_scrolling_layer_impl ||
+      potentially_scrolling_layer_impl == OuterViewportScrollLayer() ||
+      potentially_scrolling_layer_impl == InnerViewportScrollLayer()) {
+    potentially_scrolling_layer_impl = viewport()->MainScrollLayer();
+  }
+
+  return potentially_scrolling_layer_impl;
+}
+
 static bool IsClosestScrollAncestor(LayerImpl* child,
                                     LayerImpl* scroll_ancestor) {
   DCHECK(scroll_ancestor);
   if (!child)
     return false;
   ScrollTree& scroll_tree =
       child->layer_tree_impl()->property_trees()->scroll_tree;
   ScrollNode* scroll_node = scroll_tree.Node(child->scroll_tree_index());
   for (; scroll_tree.parent(scroll_node);
        scroll_node = scroll_tree.parent(scroll_node)) {
@@ skipping 647 matching lines @@
 }
 
 void LayerTreeHostImpl::MouseMoveAt(const gfx::Point& viewport_point) {
   float distance_to_scrollbar = std::numeric_limits<float>::max();
   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, as well.
   int new_id = Layer::INVALID_ID;
   if (layer_impl && layer_impl->ToScrollbarLayer())
     new_id = layer_impl->ToScrollbarLayer()->ScrollLayerId();
   if (new_id != Layer::INVALID_ID) {
     // Mouse over a scrollbar.
     distance_to_scrollbar = 0;
   } else {
-    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);
+    LayerImpl* scroll_layer_impl = FindScrollLayerByLayer(layer_impl);
 
     // Scrollbars for the viewport are registered with the outer viewport layer.
     if (scroll_layer_impl == InnerViewportScrollLayer())
       scroll_layer_impl = OuterViewportScrollLayer();
 
     new_id = scroll_layer_impl ? scroll_layer_impl->id() : Layer::INVALID_ID;
   }
 
   if (new_id != scroll_layer_id_mouse_currently_over_) {
     ScrollbarAnimationController* old_animation_controller =
@@ skipping 821 matching lines @@
       worker_context_visibility_ =
           worker_context->CacheController()->ClientBecameVisible();
     } else {
       worker_context->CacheController()->ClientBecameNotVisible(
           std::move(worker_context_visibility_));
     }
   }
 }
 
 }  // namespace cc