Suppress scrolls that begin on fixed-pos layers.

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 1909 matching lines @@
   active_tree_->UpdateDrawProperties();
   return !active_tree_->RenderSurfaceLayerList().empty();
 }
 
 void LayerTreeHostImpl::BindToClient(InputHandlerClient* client) {
   DCHECK(input_handler_client_ == NULL);
   input_handler_client_ = client;
 }
 
 static LayerImpl* NextScrollLayer(LayerImpl* layer) {
+  if (layer->position_constraint().is_fixed_position())
+    return NULL;
   if (LayerImpl* scroll_parent = layer->scroll_parent())
     return scroll_parent;
   return layer->parent();
 }
 
 LayerImpl* LayerTreeHostImpl::FindScrollLayerForViewportPoint(
     gfx::Point viewport_point, InputHandler::ScrollInputType type,
-    bool* scroll_on_main_thread) {
+    bool* scroll_on_main_thread) const {
   DCHECK(scroll_on_main_thread);
 
   gfx::PointF device_viewport_point = gfx::ScalePoint(viewport_point,
                                                       device_scale_factor_);
 
   // First find out which layer was hit from the saved list of visible layers
   // in the most recent frame.
   LayerImpl* layer_impl = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       device_viewport_point, active_tree_->RenderSurfaceLayerList());
 
@@ skipping 12 matching lines @@
     if (!scroll_layer_impl)
       continue;
 
     status = scroll_layer_impl->TryScroll(device_viewport_point, type);
     // 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();
+     if ((layer_impl == RootScrollLayer() || status == ScrollStarted) &&
+         !potentially_scrolling_layer_impl)
+       potentially_scrolling_layer_impl = scroll_layer_impl;
   }
 
   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();
 
   DCHECK(!CurrentlyScrollingLayer());
   ClearCurrentlyScrollingLayer();
 
   if (!EnsureRenderSurfaceLayerList())
     return ScrollIgnored;
 
   bool scroll_on_main_thread = false;
   LayerImpl* potentially_scrolling_layer_impl = FindScrollLayerForViewportPoint(
       viewport_point, type, &scroll_on_main_thread);
 
   if (scroll_on_main_thread) {
     rendering_stats_instrumentation_->IncrementMainThreadScrolls();
     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)
-    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);
     rendering_stats_instrumentation_->IncrementImplThreadScrolls();
     client_->RenewTreePriority();
     UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
     return ScrollStarted;
   }
@@ skipping 92 matching lines @@
   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);
 
   for (LayerImpl* layer_impl = CurrentlyScrollingLayer();
        layer_impl;
        layer_impl = layer_impl->parent()) {
-    if (!layer_impl->scrollable())
+    if (!layer_impl->scrollable()) {
+      if (layer_impl->position_constraint().is_fixed_position()) {
+        break;
+      }
       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()) {
         pending_delta = top_controls_manager_->ScrollBy(pending_delta);
         UpdateMaxScrollOffset();
       }
       // Track root layer deltas for reporting overscroll.
       unused_root_delta = pending_delta;
@@ skipping 14 matching lines @@
       applied_delta = ScrollLayerWithLocalDelta(layer_impl, pending_delta);
     }
 
     // If the layer wasn't able to move, try the next one in the hierarchy.
     float move_threshold = 0.1f;
     bool did_move_layer_x = std::abs(applied_delta.x()) > move_threshold;
     bool did_move_layer_y = std::abs(applied_delta.y()) > move_threshold;
     did_scroll_x |= did_move_layer_x;
     did_scroll_y |= did_move_layer_y;
     if (!did_move_layer_x && !did_move_layer_y) {
-      if (should_bubble_scrolls_ || !did_lock_scrolling_layer_)
+      if (layer_impl->position_constraint().is_fixed_position())
+        break;
+      if (should_bubble_scrolls_ || !did_lock_scrolling_layer_) {
         continue;
-      else
+      } else {
         break;
+      }
     }
 
     if (layer_impl == RootScrollLayer())
       unused_root_delta.Subtract(applied_delta);
 
     did_lock_scrolling_layer_ = true;
     if (!should_bubble_scrolls_) {
       active_tree_->SetCurrentlyScrollingLayer(layer_impl);
       break;
     }
@@ skipping 612 matching lines @@
   std::set<UIResourceId>::iterator found_in_evicted =
       evicted_ui_resources_.find(uid);
   if (found_in_evicted == evicted_ui_resources_.end())
     return;
   evicted_ui_resources_.erase(found_in_evicted);
   if (evicted_ui_resources_.empty())
     client_->OnCanDrawStateChanged(CanDraw());
 }
 
 }  // namespace cc