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 1992 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 88 matching lines @@
                                  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);
+      (scroll_delta.y() < 0 ||
+       (RootScrollLayer() && CurrentlyScrollingLayer() == RootScrollLayer() &&
+        RootScrollLayer()->max_scroll_offset().y() > 0));
 
   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