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 115 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_didLockScrollingLayer(false)
+    , m_shouldBubbleScrolls(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 1029 matching lines @@
             m_numMainThreadScrolls++;
             return ScrollOnMainThread;
         }
 
         if (status == ScrollStarted && !potentiallyScrollingLayerImpl)
             potentiallyScrollingLayerImpl = scrollLayerImpl;
     }
 
     if (potentiallyScrollingLayerImpl) {
         m_activeTree->set_currently_scrolling_layer(potentiallyScrollingLayerImpl);
+        m_shouldBubbleScrolls = (type != NonBubblingGesture);
         // Gesture events need to be transformed from viewport coordinates to local layer coordinates
         // so that the scrolling contents exactly follow the user's finger. In contrast, wheel
         // events are already in local layer coordinates so we can just apply them directly.
         m_scrollDeltaIsInViewportSpace = (type == Gesture);
         m_numImplThreadScrolls++;
         m_client->renewTreePriority();
         return ScrollStarted;
     }
     return ScrollIgnored;
 }
@@ skipping 76 matching lines @@
             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 (m_shouldBubbleScrolls || !m_didLockScrollingLayer)
+                continue;
+            else
+                break;
+        }
         didScroll = true;
+        m_didLockScrollingLayer = true;
+        if (!m_shouldBubbleScrolls) {
+            m_activeTree->set_currently_scrolling_layer(layerImpl);
+            break;
+        }
 
         // 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
         // moved.
         gfx::Vector2dF perpendicularAxis(-appliedDelta.y(), appliedDelta.x());
         pendingDelta = MathUtil::projectVector(pendingDelta, perpendicularAxis);
 
         if (gfx::ToFlooredVector2d(pendingDelta).IsZero())
             break;
     }
 
     if (didScroll) {
         m_client->setNeedsCommitOnImplThread();
         m_client->setNeedsRedrawOnImplThread();
         m_client->renewTreePriority();
     }
     return didScroll;
 }
 
 void LayerTreeHostImpl::clearCurrentlyScrollingLayer()
 {
     m_activeTree->ClearCurrentlyScrollingLayer();
+    m_didLockScrollingLayer = false;
 }
 
 void LayerTreeHostImpl::scrollEnd()
 {
     if (m_topControlsManager)
         m_topControlsManager->ScrollEnd();
     clearCurrentlyScrollingLayer();
 }
 
 void LayerTreeHostImpl::pinchGestureBegin()
@@ skipping 358 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