Wheel scroll latching enabled behind flag.

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 2666 matching lines @@
 
   return ScrollBeginImpl(scroll_state, InnerViewportScrollLayer(), type);
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBegin(
     ScrollState* scroll_state,
     InputHandler::ScrollInputType type) {
   ScrollStatus scroll_status;
   scroll_status.main_thread_scrolling_reasons =
       MainThreadScrollingReason::kNotScrollingOnMain;
+
   TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBegin");
 
+  if (scroll_state->is_in_inertial_phase())
+    return FlingScrollBegin();

[ericrk, 2016/07/19 20:21:51]

To make sure I'm understanding this:

Is the idea that, in the case of is_in_inertial_phase, we want to behave as
though this is a fling, not a scroll?

Can you add a comment here?

[sahel, 2016/07/19 22:47:03]

Yes, because in mac flings are handled as scrolls.
I added the comment.


Done.

+
   ClearCurrentlyScrollingLayer();
 
   gfx::Point viewport_point(scroll_state->position_x(),
                             scroll_state->position_y());
 
   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);
 
@@ skipping 532 matching lines @@
   scroll_affects_scroll_handler_ = false;
   accumulated_root_overscroll_ = gfx::Vector2dF();
 }
 
 void LayerTreeHostImpl::ScrollEnd(ScrollState* scroll_state) {
   DCHECK(scroll_state);
   DCHECK(scroll_state->delta_x() == 0 && scroll_state->delta_y() == 0);
 
   DistributeScrollDelta(scroll_state);
   top_controls_manager_->ScrollEnd();
-  ClearCurrentlyScrollingLayer();
+
+  if (scroll_state->is_in_inertial_phase()) {

[ericrk, 2016/07/19 20:21:51]

I though that is_in_inertial_phase indicated that we had a new fling? I'm
probably just misunderstanding, but it seems like we are clearing the currently
scrolling layer iff we have a new fling?

[sahel, 2016/07/19 22:47:03]

in ScrollEnd, is_in_inertial_phase is true iff the fling is happening. The idea
is not to clear the scrolling layer in cases that we are in the end of a scroll
because a fling might happen afterwards and we don't want a new hit test for the
fling that happens after a scroll.

It's safe not to clear scrolling layer, because we clear it in scrollBegin. 

I can remove the condition and never clear the scrollinglayer in this function.
But after a fling we know that it's the end of current gesture sequence and
anything that happens after needs a new hit testing. So, it is safe to clear the
scrollinglayer.

[ericrk, 2016/07/20 17:44:35]

Ok, this makes sense, thanks for explaining.

+    // There might be a fling after the scroll end. In those cases,
+    // don't clear the currently scrolling layer to avoid a new hit test for the
+    // fling.
+    ClearCurrentlyScrollingLayer();
+  }
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::FlingScrollBegin() {
   InputHandler::ScrollStatus scroll_status;
   scroll_status.main_thread_scrolling_reasons =
       MainThreadScrollingReason::kNotScrollingOnMain;
   if (!CurrentlyScrollingLayer()) {
     scroll_status.thread = SCROLL_IGNORED;
     scroll_status.main_thread_scrolling_reasons =
         MainThreadScrollingReason::kNoScrollingLayer;
@@ skipping 787 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc