Let LayerTreeHostImpl::ScrollAnimated scroll the outer viewport.

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 <map>
 #include <set>
@@ skipping 388 matching lines @@
   base::TimeTicks monotonic_time = CurrentBeginFrameArgs().frame_time;
 
   // mithro(TODO): Enable these checks.
   // DCHECK(!current_begin_frame_tracker_.HasFinished());
   // DCHECK(monotonic_time == current_begin_frame_tracker_.Current().frame_time)
   //  << "Called animate with unknown frame time!?";
 
   if (input_handler_client_) {
     // This animates fling scrolls. But on Android WebView root flings are
     // controlled by the application, so the compositor does not animate them.
-    bool ignore_fling =
-        settings_.ignore_root_layer_flings && IsCurrentlyScrollingRoot();
+    bool ignore_fling = settings_.ignore_root_layer_flings &&
+                        IsCurrentlyScrollingInnerViewport();
     if (!ignore_fling)
       input_handler_client_->Animate(monotonic_time);
   }
 
   AnimatePageScale(monotonic_time);
   AnimateLayers(monotonic_time);
   AnimateScrollbars(monotonic_time);
   AnimateTopControls(monotonic_time);
 
   // Animating stuff can change the root scroll offset, so inform the
@@ skipping 47 matching lines @@
                                   page_scale,
                                   duration.InSecondsF());
   }
 
   SetNeedsAnimate();
   client_->SetNeedsCommitOnImplThread();
   client_->RenewTreePriority();
 }
 
 void LayerTreeHostImpl::SetNeedsAnimateInput() {
-  DCHECK_IMPLIES(IsCurrentlyScrollingRoot(),
+  DCHECK_IMPLIES(IsCurrentlyScrollingInnerViewport(),
                  !settings_.ignore_root_layer_flings);
   SetNeedsAnimate();
 }
 
-bool LayerTreeHostImpl::IsCurrentlyScrollingRoot() const {
+bool LayerTreeHostImpl::IsCurrentlyScrollingInnerViewport() const {
   LayerImpl* scrolling_layer = CurrentlyScrollingLayer();
   if (!scrolling_layer)
     return false;
   return scrolling_layer == InnerViewportScrollLayer();
 }
 
 bool LayerTreeHostImpl::IsCurrentlyScrollingLayerAt(
     const gfx::Point& viewport_point,
     InputHandler::ScrollInputType type) const {
   LayerImpl* scrolling_layer_impl = CurrentlyScrollingLayer();
@@ skipping 1365 matching lines @@
 LayerImpl* LayerTreeHostImpl::CurrentlyScrollingLayer() const {
   return active_tree_->CurrentlyScrollingLayer();
 }
 
 bool LayerTreeHostImpl::IsActivelyScrolling() const {
   if (!CurrentlyScrollingLayer())
     return false;
   // On Android WebView root flings are controlled by the application,
   // so the compositor does not animate them and can't tell if they
   // are actually animating. So assume there are none.
-  if (settings_.ignore_root_layer_flings && IsCurrentlyScrollingRoot())
+  if (settings_.ignore_root_layer_flings && IsCurrentlyScrollingInnerViewport())
     return false;
   return did_lock_scrolling_layer_;
 }
 
 // Content layers can be either directly scrollable or contained in an outer
 // scrolling layer which applies the scroll transform. Given a content layer,
 // this function returns the associated scroll layer if any.
 static LayerImpl* FindScrollLayerForContentLayer(LayerImpl* layer_impl) {
   if (!layer_impl)
     return NULL;
@@ skipping 509 matching lines @@
   // notifications while preventing scroll updates from being unintentionally
   // forwarded to the main thread. The inner viewport layer represents the
   // viewport during scrolling.
   if (!potentially_scrolling_layer_impl)
     potentially_scrolling_layer_impl = InnerViewportScrollLayer();
 
   // The inner viewport layer represents the viewport.
   if (potentially_scrolling_layer_impl == OuterViewportScrollLayer())
     potentially_scrolling_layer_impl = InnerViewportScrollLayer();
 
+  // Animated wheel scrolls need to scroll the outer viewport layer, and do not
+  // go through Viewport::ScrollBy which would normally handle the distribution.
+  // NOTE: This will need refactoring if we want smooth scrolling on Android.
+  if (type == ANIMATED_WHEEL &&
+      potentially_scrolling_layer_impl == InnerViewportScrollLayer()) {
+    potentially_scrolling_layer_impl = OuterViewportScrollLayer();
+  }
+
   return potentially_scrolling_layer_impl;
 }
 
 // Similar to LayerImpl::HasAncestor, but walks up the scroll parents.
 static bool HasScrollAncestor(LayerImpl* child, LayerImpl* scroll_ancestor) {
   DCHECK(scroll_ancestor);
   for (LayerImpl* ancestor = child; ancestor;
        ancestor = NextLayerInScrollOrder(ancestor)) {
     if (ancestor->scrollable())
       return ancestor == scroll_ancestor;
   }
   return false;
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBeginImpl(
     LayerImpl* scrolling_layer_impl,
     InputHandler::ScrollInputType type) {
   if (!scrolling_layer_impl)
     return SCROLL_IGNORED;
 
   top_controls_manager_->ScrollBegin();
 
   active_tree_->SetCurrentlyScrollingLayer(scrolling_layer_impl);
-  wheel_scrolling_ = (type == WHEEL);
+  wheel_scrolling_ = (type == WHEEL || type == ANIMATED_WHEEL);
   client_->RenewTreePriority();
   UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
   return SCROLL_STARTED;
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::RootScrollBegin(
     InputHandler::ScrollInputType type) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::RootScrollBegin");
 
   DCHECK(!CurrentlyScrollingLayer());
@@ skipping 37 matching lines @@
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimated(
     const gfx::Point& viewport_point,
     const gfx::Vector2dF& scroll_delta) {
   if (LayerImpl* layer_impl = CurrentlyScrollingLayer()) {
     return ScrollAnimationUpdateTarget(layer_impl, scroll_delta)
                ? SCROLL_STARTED
                : SCROLL_IGNORED;
   }
-  // ScrollAnimated is only used for wheel scrolls. We use the same bubbling
-  // behavior as ScrollBy to determine which layer to animate, but we do not
-  // do the Android-specific things in ScrollBy like showing top controls.
-  InputHandler::ScrollStatus scroll_status = ScrollBegin(viewport_point, WHEEL);
+  // ScrollAnimated is used for animated wheel scrolls. We find the first layer
+  // that can scroll and set up an animation of its scroll offset. Note that
+  // this does not currently go through the scroll customization and viewport
+  // machinery that ScrollBy uses for non-animated wheel scrolls.
+  InputHandler::ScrollStatus scroll_status =
+      ScrollBegin(viewport_point, ANIMATED_WHEEL);
   if (scroll_status == SCROLL_STARTED) {
     gfx::Vector2dF pending_delta = scroll_delta;
     for (LayerImpl* layer_impl = CurrentlyScrollingLayer(); layer_impl;
          layer_impl = NextLayerInScrollOrder(layer_impl)) {
-      // The inner viewport layer represents the viewport.
-      if (!layer_impl->scrollable() || layer_impl == OuterViewportScrollLayer())
+      if (!layer_impl->scrollable())
         continue;
 
       gfx::ScrollOffset current_offset = layer_impl->CurrentScrollOffset();
       gfx::ScrollOffset target_offset =
           ScrollOffsetWithDelta(current_offset, pending_delta);
       target_offset.SetToMax(gfx::ScrollOffset());
       target_offset.SetToMin(layer_impl->MaxScrollOffset());
       gfx::Vector2dF actual_delta = target_offset.DeltaFrom(current_offset);
 
       const float kEpsilon = 0.1f;
@@ skipping 1108 matching lines @@
   if (active_tree()) {
     LayerAnimationValueProvider* layer = active_tree()->LayerById(layer_id);
     if (layer)
       return layer->ScrollOffsetForAnimation();
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc