Add a bit to not bubble scrolls to parent scrolling layers

cc/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/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 114 matching lines @@
 }
 
 scoped_ptr<LayerTreeHostImpl> LayerTreeHostImpl::create(const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy)
 {
     return make_scoped_ptr(new LayerTreeHostImpl(settings, client, proxy));
 }
 
 LayerTreeHostImpl::LayerTreeHostImpl(const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy)
     : m_client(client)
     , m_proxy(proxy)
+    , m_didScrollOnce(false)
     , m_scrollDeltaIsInViewportSpace(false)
     , m_settings(settings)
     , m_debugState(settings.initialDebugState)
     , m_deviceScaleFactor(1)
     , m_visible(true)
     , m_managedMemoryPolicy(PrioritizedResourceManager::defaultMemoryAllocationLimit(),
                             ManagedMemoryPolicy::CUTOFF_ALLOW_EVERYTHING,
                             0,
                             ManagedMemoryPolicy::CUTOFF_ALLOW_NOTHING)
     , m_pinchGestureActive(false)
@@ skipping 1022 matching lines @@
 
 InputHandlerClient::ScrollStatus LayerTreeHostImpl::scrollBegin(gfx::Point viewportPoint, InputHandlerClient::ScrollInputType type)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBegin");
 
     if (m_topControlsManager)
         m_topControlsManager->ScrollBegin();
 
     DCHECK(!currentlyScrollingLayer());
     clearCurrentlyScrollingLayer();
+    m_didScrollOnce = false;
 
     if (!ensureRenderSurfaceLayerList())
         return ScrollIgnored;
 
     gfx::PointF deviceViewportPoint = gfx::ScalePoint(viewportPoint, m_deviceScaleFactor);
 
     // First find out which layer was hit from the saved list of visible layers
     // in the most recent frame.
     LayerImpl* layerImpl = LayerTreeHostCommon::findLayerThatIsHitByPoint(deviceViewportPoint, activeTree()->RenderSurfaceLayerList());
 
@@ skipping 93 matching lines @@
 }
 
 static gfx::Vector2dF scrollLayerWithLocalDelta(LayerImpl& layerImpl, gfx::Vector2dF localDelta)
 {
     gfx::Vector2dF previousDelta(layerImpl.scrollDelta());
     layerImpl.scrollBy(localDelta);
     return layerImpl.scrollDelta() - previousDelta;
 }
 
 bool LayerTreeHostImpl::scrollBy(const gfx::Point& viewportPoint,
-                                 const gfx::Vector2d& scrollDelta)
+                                 const gfx::Vector2d& scrollDelta,
+                                 bool shouldBubble)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBy");
     if (!currentlyScrollingLayer())
         return false;
 
     gfx::Vector2dF pendingDelta = scrollDelta;
     bool didScroll = false;
 
     for (LayerImpl* layerImpl = currentlyScrollingLayer(); layerImpl; layerImpl = layerImpl->parent()) {
         if (!layerImpl->scrollable())
             continue;
 
         gfx::Vector2dF appliedDelta;
         if (m_topControlsManager && layerImpl == rootScrollLayer())
             pendingDelta = m_topControlsManager->ScrollBy(pendingDelta);
 
         if (m_scrollDeltaIsInViewportSpace) {
             float scaleFromViewportToScreenSpace = m_deviceScaleFactor;
             appliedDelta = scrollLayerWithViewportSpaceDelta(layerImpl, scaleFromViewportToScreenSpace, viewportPoint, pendingDelta);
         } else
             appliedDelta = scrollLayerWithLocalDelta(*layerImpl, pendingDelta);
 
         // If the layer wasn't able to move, try the next one in the hierarchy.
         float moveThresholdSquared = 0.1f * 0.1f;
-        if (appliedDelta.LengthSquared() < moveThresholdSquared)
-            continue;
+        if (appliedDelta.LengthSquared() < moveThresholdSquared) {
+            if (shouldBubble || !m_didScrollOnce)

[Sami, 2013/01/29 11:42:34]

I'm not sure this is correct. When we're not bubbling, this seems to allow
scrollBy to bubble once up to a layer that can scroll. The next time scrollBy is
called, it terminates at the first layer that couldn't scroll.

Let's say you have a page with an overflow div that was already scrolled all the
way down. Flinging that div further down should fling the page instead. I think
with this code that wouldn't happen.

[Yusuf, 2013/01/29 18:59:21]

Yes, I think you are right. I somehow thought the current_scrolling_layer gets
updated when we bubble up here, so that we remember where we left of, but that
doesn't look like the case. I might need to keep the layer itself like we had
talked before.

On 2013/01/29 11:42:34, Sami wrote:

+                continue;
+            else
+              break;

[Sami, 2013/01/29 11:42:34]

Indentation seem off.

+        }
         didScroll = true;
+        m_didScrollOnce = true;
 
         // If the applied delta is within 45 degrees of the input delta, bail out to make it easier
         // to scroll just one layer in one direction without affecting any of its parents.
         float angleThreshold = 45;
         if (MathUtil::smallestAngleBetweenVectors(appliedDelta, pendingDelta) < angleThreshold) {
             pendingDelta = gfx::Vector2d();
             break;
         }
 
         // Allow further movement only on an axis perpendicular to the direction in which the layer
@@ skipping 385 matching lines @@
     LayerImpl* layer = getNonCompositedContentLayerRecursive(tree->RootLayer());
     return layer ? layer->getPicture() : skia::RefPtr<SkPicture>();
 }
 
 void LayerTreeHostImpl::savePaintTime(const base::TimeDelta& totalPaintTime)
 {
     m_paintTimeCounter->SavePaintTime(totalPaintTime);
 }
 
 }  // namespace cc