Always fall back to root scroll layer for otherwise ignored scrolls

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 <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 1991 matching lines @@
     // If any layer wants to divert the scroll event to the main thread, abort.
     if (status == ScrollOnMainThread) {
       *scroll_on_main_thread = true;
       return NULL;
     }
 
     if (status == ScrollStarted && !potentially_scrolling_layer_impl)
       potentially_scrolling_layer_impl = scroll_layer_impl;
   }
 
-  // When hiding top controls is enabled and the controls are hidden or
-  // overlaying the content, force scrolls to be enabled on the root layer to
-  // allow bringing the top controls back into view.
-  if (!potentially_scrolling_layer_impl && top_controls_manager_ &&
-      top_controls_manager_->content_top_offset() !=
-      settings_.top_controls_height) {
-    potentially_scrolling_layer_impl = RootScrollLayer();
-  }
-
   return potentially_scrolling_layer_impl;
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBegin(
     gfx::Point viewport_point, InputHandler::ScrollInputType type) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBegin");
 
   if (top_controls_manager_)
     top_controls_manager_->ScrollBegin();
 
@@ skipping 11 matching lines @@
   bool scroll_on_main_thread = false;
   LayerImpl* potentially_scrolling_layer_impl =
       FindScrollLayerForDeviceViewportPoint(device_viewport_point, type,
           layer_impl, &scroll_on_main_thread);
 
   if (scroll_on_main_thread) {
     UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
     return ScrollOnMainThread;
   }
 
-  // If we want to send a DidOverscroll for this scroll it can't be ignored.
-  if (!potentially_scrolling_layer_impl && settings_.always_overscroll)
+  if (!potentially_scrolling_layer_impl)
     potentially_scrolling_layer_impl = RootScrollLayer();
 
   if (potentially_scrolling_layer_impl) {
     active_tree_->SetCurrentlyScrollingLayer(
         potentially_scrolling_layer_impl);
     should_bubble_scrolls_ = (type != NonBubblingGesture);
     wheel_scrolling_ = (type == Wheel);
     client_->RenewTreePriority();
     UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
     return ScrollStarted;
@@ skipping 87 matching lines @@
 bool LayerTreeHostImpl::ScrollBy(gfx::Point viewport_point,
                                  gfx::Vector2dF scroll_delta) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBy");
   if (!CurrentlyScrollingLayer())
     return false;
 
   gfx::Vector2dF pending_delta = scroll_delta;
   gfx::Vector2dF unused_root_delta;
   bool did_scroll_x = false;
   bool did_scroll_y = false;
-  bool consume_by_top_controls = top_controls_manager_ &&
-      (CurrentlyScrollingLayer() == RootScrollLayer() || scroll_delta.y() < 0);
+  bool consume_by_top_controls = false;
+  if (top_controls_manager_) {
+    gfx::PointF screen_space_point =
+        gfx::ScalePoint(viewport_point, device_scale_factor_);

[aelias_OOO_until_Jul13, 2013/12/26 20:38:00]

This would be incorrect when the transformation is more complex than this (for
example, in some WebView and devtools scenarios).  We should be reusing the
logic in ScrollLayerWithViewportSpaceDelta for this.  So probably the top
controls consumption logic needs to move to that method as well.

[jdduke (slow), 2014/01/09 20:37:29]

What if we simply use the |max_scroll_offset()|?  I tested this with the latest
patch set, and it seems to work really well in practice. 

+    bool root_layer_gesture_scroll_active_and_possible =
+        CurrentlyScrollingLayer() == RootScrollLayer() &&
+        RootScrollLayer()->TryScroll(screen_space_point, Gesture)
+            != ScrollIgnored;
+    // Showing the top controls should always be possible, while hiding them
+    // should be possible only if the root layer can be scrolled.
+    consume_by_top_controls =
+      (scroll_delta.y() < 0 || root_layer_gesture_scroll_active_and_possible);
+  }
 
   for (LayerImpl* layer_impl = CurrentlyScrollingLayer();
        layer_impl;
        layer_impl = layer_impl->parent()) {
     if (!layer_impl->scrollable())
       continue;
 
     if (layer_impl == RootScrollLayer()) {
       // Only allow bubble scrolling when the scroll is in the direction to make
       // the top controls visible.
-      if (consume_by_top_controls && layer_impl == RootScrollLayer()) {
+      if (consume_by_top_controls) {
         pending_delta = top_controls_manager_->ScrollBy(pending_delta);
         UpdateMaxScrollOffset();
       }
       // Track root layer deltas for reporting overscroll.
       unused_root_delta = pending_delta;
     }
 
     gfx::Vector2dF applied_delta;
     // Gesture events need to be transformed from viewport coordinates to local
     // layer coordinates so that the scrolling contents exactly follow the
@@ skipping 730 matching lines @@
   swap_promise_monitor_.erase(monitor);
 }
 
 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfSetNeedsRedraw() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnSetNeedsRedrawOnImpl();
 }
 
 }  // namespace cc