Attachment 134541 Details for Bug 73350 – Patch

[patch] Patch

bug-73350-20120329115209.patch (text/plain), 60.01 KB, created by Sami Kyostila on 2012-03-29 03:52:10 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Sami Kyostila

Created: 2012-03-29 03:52:10 PDT

Size: 60.01 KB

patch

obsolete

>Subversion Revision: 112509
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index e93f19644c77195c300621f2c61c61acb438dc7c..0decfab9f0999d7c538c61831c1a3fdbbd418a77 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,76 @@
>+2012-03-28  Sami Kyostila  <skyostil@chromium.org>
>+
>+        [chromium] Allow scrolling non-root layers in the compositor thread
>+        https://bugs.webkit.org/show_bug.cgi?id=73350
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This patch enables scrolling child layers in the compositor thread.
>+        Scroll deltas are accumulated for each scrolled CCLayerImpl and
>+        synchronized to the main thread.
>+
>+        If a layer has no room to scroll in a given direction, one of its
>+        ancestor layers is scrolled instead if possible.
>+
>+        Added new webkit_unit_tests to verify scrolling behavior.
>+
>+        * platform/graphics/chromium/ContentLayerChromium.cpp:
>+        (WebCore::ContentLayerChromium::scrollBy):
>+        (WebCore):
>+        * platform/graphics/chromium/ContentLayerChromium.h:
>+        (ContentLayerDelegate):
>+        (ContentLayerChromium):
>+        * platform/graphics/chromium/GraphicsLayerChromium.h:
>+        (WebCore::GraphicsLayerChromium::didScroll):
>+        * platform/graphics/chromium/LayerChromium.cpp:
>+        (WebCore::LayerChromium::setMaxScrollPosition):
>+        (WebCore):
>+        (WebCore::LayerChromium::pushPropertiesTo):
>+        * platform/graphics/chromium/LayerChromium.h:
>+        (LayerChromium):
>+        (WebCore::LayerChromium::maxScrollPosition):
>+        (WebCore::LayerChromium::scrollable):
>+        (WebCore::LayerChromium::scrollBy):
>+        * platform/graphics/chromium/cc/CCLayerImpl.cpp:
>+        (WebCore::CCLayerImpl::findLayerInSubtree):
>+        (WebCore):
>+        (WebCore::CCLayerImpl::tryScroll):
>+        * platform/graphics/chromium/cc/CCLayerImpl.h:
>+        (CCLayerImpl):
>+        * platform/graphics/chromium/cc/CCLayerTreeHost.cpp:
>+        (WebCore::findLayerById):
>+        (WebCore):
>+        (WebCore::findFirstScrollableLayer):
>+        (WebCore::CCLayerTreeHost::applyScrollAndScale):
>+        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:
>+        (WebCore::CCLayerTreeHostImpl::CCLayerTreeHostImpl):
>+        (WebCore::CCLayerTreeHostImpl::startPageScaleAnimation):
>+        (WebCore::CCLayerTreeHostImpl::contentSize):
>+        (WebCore):
>+        (WebCore::CCLayerTreeHostImpl::calculateVisibleLayers):
>+        (WebCore::CCLayerTreeHostImpl::prepareToDraw):
>+        (WebCore::findRootScrollLayer):
>+        (WebCore::findScrollLayerForContentLayer):
>+        (WebCore::CCLayerTreeHostImpl::setRootLayer):
>+        (WebCore::adjustScrollsForPageScaleChange):
>+        (WebCore::applyPageScaleDeltaToScrollLayers):
>+        (WebCore::CCLayerTreeHostImpl::setPageScaleFactorAndLimits):
>+        (WebCore::CCLayerTreeHostImpl::setPageScaleDelta):
>+        (WebCore::CCLayerTreeHostImpl::updateMaxScrollPosition):
>+        (WebCore::CCLayerTreeHostImpl::scrollBegin):
>+        (WebCore::CCLayerTreeHostImpl::scrollBy):
>+        (WebCore::CCLayerTreeHostImpl::scrollEnd):
>+        (WebCore::CCLayerTreeHostImpl::pinchGestureUpdate):
>+        (WebCore::CCLayerTreeHostImpl::computePinchZoomDeltas):
>+        (WebCore::CCLayerTreeHostImpl::makeScrollAndScaleSet):
>+        (WebCore::collectScrollDeltas):
>+        (WebCore::CCLayerTreeHostImpl::processScrollDeltas):
>+        (WebCore::CCLayerTreeHostImpl::animatePageScale):
>+        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.h:
>+        (WebCore::CCLayerTreeHostImpl::rootScrollLayer):
>+        (CCLayerTreeHostImpl):
>+        (LayerGeometry):
>+
> 2012-03-29  Vineet Chaudhary  <rgf748@motorola.com>
> 
>         Remove custom bindings form Internals.idl of attribute type Array.
>diff --git a/Source/WebKit/chromium/ChangeLog b/Source/WebKit/chromium/ChangeLog
>index 5801ee83d62b79e731747c6edc11ce59600d1348..bd244a0fdb86912f04ba180621e2da7dcfaa716c 100644
>--- a/Source/WebKit/chromium/ChangeLog
>+++ b/Source/WebKit/chromium/ChangeLog
>@@ -1,3 +1,38 @@
>+2012-03-28  Sami Kyostila  <skyostil@chromium.org>
>+
>+        [chromium] Add tests for scrolling non-root layers in the compositor thread
>+        https://bugs.webkit.org/show_bug.cgi?id=73350
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * src/WebContentLayerImpl.cpp:
>+        (WebKit::WebContentLayerImpl::didScroll):
>+        (WebKit):
>+        * src/WebContentLayerImpl.h:
>+        (WebContentLayerImpl):
>+        * tests/CCLayerImplTest.cpp:
>+        (WebCore::TEST):
>+        (WebCore):
>+        * tests/CCLayerTreeHostImplTest.cpp:
>+        (WebKitTests::CCLayerTreeHostImplTest::createScrollableLayer):
>+        (CCLayerTreeHostImplTest):
>+        (WebKitTests::CCLayerTreeHostImplTest::initializeLayerRendererAndDrawFrame):
>+        (WebKitTests::TEST_F):
>+        (WebKitTests):
>+        * tests/CCLayerTreeHostTest.cpp:
>+        (WTF::TestOpacityChangeLayerDelegate::didScroll):
>+        (WTF::MockContentLayerDelegate::paintContents):
>+        (WTF::MockContentLayerDelegate::didScroll):
>+        (CCLayerTreeHostTestScrollChildLayer):
>+        (WTF::CCLayerTreeHostTestScrollChildLayer::CCLayerTreeHostTestScrollChildLayer):
>+        (WTF::CCLayerTreeHostTestScrollChildLayer::beginTest):
>+        (WTF::CCLayerTreeHostTestScrollChildLayer::applyScrollAndScale):
>+        (WTF::CCLayerTreeHostTestScrollChildLayer::beginCommitOnCCThread):
>+        (WTF::CCLayerTreeHostTestScrollChildLayer::drawLayersOnCCThread):
>+        (WTF::CCLayerTreeHostTestScrollChildLayer::afterTest):
>+        (WTF):
>+        (WTF::TEST_F):
>+
> 2012-03-29  Kinuko Yasuda  <kinuko@chromium.org>
> 
>         Unreviewed; rolling chromium deps to 129583.
>diff --git a/Source/WebCore/platform/graphics/chromium/ContentLayerChromium.cpp b/Source/WebCore/platform/graphics/chromium/ContentLayerChromium.cpp
>index 73a8a424615713e69d5a2c1e78cfe93cb688005b..4c5505f9b19934c462d4f910af7efdddaf408bf4 100644
>--- a/Source/WebCore/platform/graphics/chromium/ContentLayerChromium.cpp
>+++ b/Source/WebCore/platform/graphics/chromium/ContentLayerChromium.cpp
>@@ -144,5 +144,12 @@ void ContentLayerChromium::setOpaque(bool opaque)
>         m_textureUpdater->setOpaque(opaque);
> }
> 
>+void ContentLayerChromium::scrollBy(const IntSize& scrollDelta)
>+{
>+    setScrollPosition(scrollPosition() + scrollDelta);
>+    if (m_delegate)
>+        m_delegate->didScroll(scrollDelta);
>+}
>+
> }
> #endif // USE(ACCELERATED_COMPOSITING)
>diff --git a/Source/WebCore/platform/graphics/chromium/ContentLayerChromium.h b/Source/WebCore/platform/graphics/chromium/ContentLayerChromium.h
>index e6994a21aefac2140887e5bbd8abb203c9ab8179..16d678ed64a061f8f815d63ace0592f904e3503d 100644
>--- a/Source/WebCore/platform/graphics/chromium/ContentLayerChromium.h
>+++ b/Source/WebCore/platform/graphics/chromium/ContentLayerChromium.h
>@@ -46,6 +46,7 @@ class ContentLayerDelegate {
> public:
>     virtual ~ContentLayerDelegate() { }
>     virtual void paintContents(GraphicsContext&, const IntRect& clip) = 0;
>+    virtual void didScroll(const IntSize&) = 0;
> };
> 
> // A Layer that requires a GraphicsContext to render its contents.
>@@ -63,6 +64,8 @@ public:
> 
>     virtual void setOpaque(bool);
> 
>+    virtual void scrollBy(const IntSize&);
>+
> protected:
>     explicit ContentLayerChromium(ContentLayerDelegate*);
> 
>diff --git a/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.h b/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.h
>index 91a455a541e66f9d876be6ace611fc8a0fac47a5..f297303f2587e9ee36c6dae6363b431d7b3280f7 100644
>--- a/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.h
>+++ b/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.h
>@@ -113,6 +113,7 @@ public:
> 
>     // ContentLayerDelegate implementation.
>     virtual void paintContents(GraphicsContext&, const IntRect& clip);
>+    virtual void didScroll(const IntSize&) { }
> 
>     // CCLayerAnimationDelegate implementation.
>     virtual void notifyAnimationStarted(double startTime);
>diff --git a/Source/WebCore/platform/graphics/chromium/LayerChromium.cpp b/Source/WebCore/platform/graphics/chromium/LayerChromium.cpp
>index 2ad09b948a43bb3ce3a71951fc7b5d9e1300ea55..d0b3c692fa38863e40851db171a0ae60f923b99f 100644
>--- a/Source/WebCore/platform/graphics/chromium/LayerChromium.cpp
>+++ b/Source/WebCore/platform/graphics/chromium/LayerChromium.cpp
>@@ -380,6 +380,14 @@ void LayerChromium::setScrollPosition(const IntPoint& scrollPosition)
>     setNeedsCommit();
> }
> 
>+void LayerChromium::setMaxScrollPosition(const IntSize& maxScrollPosition)
>+{
>+    if (m_maxScrollPosition == maxScrollPosition)
>+        return;
>+    m_maxScrollPosition = maxScrollPosition;
>+    setNeedsCommit();
>+}
>+
> void LayerChromium::setScrollable(bool scrollable)
> {
>     if (m_scrollable == scrollable)
>@@ -491,6 +499,7 @@ void LayerChromium::pushPropertiesTo(CCLayerImpl* layer)
>     layer->setPosition(m_position);
>     layer->setPreserves3D(preserves3D());
>     layer->setScrollPosition(m_scrollPosition);
>+    layer->setMaxScrollPosition(m_maxScrollPosition);
>     layer->setSublayerTransform(m_sublayerTransform);
>     if (!transformIsAnimating())
>         layer->setTransform(m_transform);
>diff --git a/Source/WebCore/platform/graphics/chromium/LayerChromium.h b/Source/WebCore/platform/graphics/chromium/LayerChromium.h
>index b98022b52da58b9197cbf5448cb6d40a9a07c270..b01c6dae80d529d8750e2788384050494c889f49 100644
>--- a/Source/WebCore/platform/graphics/chromium/LayerChromium.h
>+++ b/Source/WebCore/platform/graphics/chromium/LayerChromium.h
>@@ -139,12 +139,17 @@ public:
>     void setScrollPosition(const IntPoint&);
>     const IntPoint& scrollPosition() const { return m_scrollPosition; }
> 
>+    void setMaxScrollPosition(const IntSize&);
>+    const IntSize& maxScrollPosition() const { return m_maxScrollPosition; }
>+
>     void setScrollable(bool);
>+    bool scrollable() const { return m_scrollable; }
>     void setShouldScrollOnMainThread(bool);
>     void setHaveWheelEventHandlers(bool);
>     const Region& nonFastScrollableRegion() { return m_nonFastScrollableRegion; }
>     void setNonFastScrollableRegion(const Region&);
>     void setNonFastScrollableRegionChanged() { m_nonFastScrollableRegionChanged = true; }
>+    virtual void scrollBy(const IntSize&) { }
> 
>     IntSize scrollDelta() const { return IntSize(); }
> 
>@@ -297,6 +302,7 @@ private:
>     IntSize m_bounds;
>     IntRect m_visibleLayerRect;
>     IntPoint m_scrollPosition;
>+    IntSize m_maxScrollPosition;
>     bool m_scrollable;
>     bool m_shouldScrollOnMainThread;
>     bool m_haveWheelEventHandlers;
>diff --git a/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.cpp b/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.cpp
>index 2afb9d8ff741f93359566a169fd43729702a7969..6a044cdd7c88247d5ef23c1d8b27ee6dced9ae59 100644
>--- a/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.cpp
>+++ b/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.cpp
>@@ -107,6 +107,22 @@ void CCLayerImpl::removeAllChildren()
>         m_children[0]->removeFromParent();
> }
> 
>+CCLayerImpl* CCLayerImpl::findLayerInSubtree(int layerId)
>+{
>+    if (id() == layerId)
>+        return this;
>+    if (m_maskLayer && m_maskLayer->id() == layerId)
>+        return m_maskLayer.get();
>+    if (m_replicaLayer && m_replicaLayer->id() == layerId)
>+        return m_replicaLayer.get();
>+    for (size_t i = 0; i < m_children.size(); ++i) {
>+        CCLayerImpl* found = m_children[i]->findLayerInSubtree(layerId);
>+        if (found)
>+            return found;
>+    }
>+    return 0;
>+}
>+
> void CCLayerImpl::clearChildList()
> {
>     m_children.clear();
>@@ -197,6 +213,37 @@ void CCLayerImpl::scrollBy(const FloatSize& scroll)
>     noteLayerPropertyChangedForSubtree();
> }
> 
>+CCInputHandlerClient::ScrollStatus CCLayerImpl::tryScroll(const IntPoint& viewportPoint, CCInputHandlerClient::ScrollInputType type) const
>+{
>+    if (shouldScrollOnMainThread()) {
>+        TRACE_EVENT("tryScroll Failed shouldScrollOnMainThread", this, 0);
>+        return CCInputHandlerClient::ScrollFailed;
>+    }
>+
>+    if (!screenSpaceTransform().isInvertible()) {
>+        TRACE_EVENT("tryScroll Failed nonInvertibleTransform", this, 0);
>+        return CCInputHandlerClient::ScrollIgnored;
>+    }
>+
>+    IntPoint contentPoint(screenSpaceTransform().inverse().mapPoint(viewportPoint));
>+    if (nonFastScrollableRegion().contains(contentPoint)) {
>+        TRACE_EVENT("tryScroll Failed nonFastScrollableRegion", this, 0);
>+        return CCInputHandlerClient::ScrollFailed;
>+    }
>+
>+    if (type == CCInputHandlerClient::Wheel && haveWheelEventHandlers()) {
>+        TRACE_EVENT("tryScroll Failed wheelEventHandlers", this, 0);
>+        return CCInputHandlerClient::ScrollFailed;
>+    }
>+
>+    if (!scrollable()) {
>+        TRACE_EVENT("tryScroll Ignored not scrollable", this, 0);
>+        return CCInputHandlerClient::ScrollIgnored;
>+    }
>+
>+    return CCInputHandlerClient::ScrollStarted;
>+}
>+
> const IntRect CCLayerImpl::getDrawRect() const
> {
>     // Form the matrix used by the shader to map the corners of the layer's
>diff --git a/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.h b/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.h
>index 6cb6df03c29eae6087e0f4a9ee941c32b9950892..04b5b05dc863b4bdec5d4b196cce76c8cea872d7 100644
>--- a/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.h
>+++ b/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.h
>@@ -33,6 +33,7 @@
> #include "Region.h"
> #include "TextStream.h"
> #include "TransformationMatrix.h"
>+#include "cc/CCInputHandler.h"
> #include "cc/CCLayerAnimationController.h"
> #include "cc/CCRenderSurface.h"
> #include "cc/CCSharedQuadState.h"
>@@ -72,6 +73,10 @@ public:
>     void removeFromParent();
>     void removeAllChildren();
> 
>+    // Returns a layer with the given id if one exists in the subtree starting
>+    // from this layer (including mask and replica layers).
>+    CCLayerImpl* findLayerInSubtree(int layerId);
>+
>     void setMaskLayer(PassOwnPtr<CCLayerImpl>);
>     CCLayerImpl* maskLayer() const { return m_maskLayer.get(); }
> 
>@@ -198,6 +203,8 @@ public:
>     const Region& nonFastScrollableRegion() const { return m_nonFastScrollableRegion; }
>     void setNonFastScrollableRegion(const Region& region) { m_nonFastScrollableRegion = region; }
> 
>+    CCInputHandlerClient::ScrollStatus tryScroll(const IntPoint& viewportPoint, CCInputHandlerClient::ScrollInputType) const;
>+
>     const IntRect& visibleLayerRect() const { return m_visibleLayerRect; }
>     void setVisibleLayerRect(const IntRect& visibleLayerRect) { m_visibleLayerRect = visibleLayerRect; }
> 
>diff --git a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp b/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp
>index 576fc2b3190a2d630957598175c43eef4e788c27..854559658aa9cd3cd57c7ef7f09feed78f5a3196 100644
>--- a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp
>+++ b/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp
>@@ -611,15 +611,56 @@ void CCLayerTreeHost::clearPendingUpdate()
>     m_updateList.clear();
> }
> 
>+static LayerChromium* findLayerById(LayerChromium* layer, int id)
>+{
>+    if (!layer)
>+        return 0;
>+
>+    if (layer->id() == id)
>+        return layer;
>+
>+    for (size_t i = 0; i < layer->children().size(); ++i) {
>+        LayerChromium* found = findLayerById(layer->children()[i].get(), id);
>+        if (found)
>+            return found;
>+    }
>+
>+    return 0;
>+}
>+
>+static LayerChromium* findFirstScrollableLayer(LayerChromium* layer)
>+{
>+    if (!layer)
>+        return 0;
>+
>+    if (layer->scrollable())
>+        return layer;
>+
>+    for (size_t i = 0; i < layer->children().size(); ++i) {
>+        LayerChromium* found = findFirstScrollableLayer(layer->children()[i].get());
>+        if (found)
>+            return found;
>+    }
>+
>+    return 0;
>+}
>+
> void CCLayerTreeHost::applyScrollAndScale(const CCScrollAndScaleSet& info)
> {
>-    // FIXME: pushing scroll offsets to non-root layers not implemented
>-    if (!info.scrolls.size())
>-        return;
>+    LayerChromium* rootScrollLayer = findFirstScrollableLayer(m_rootLayer.get());
>+    IntSize rootScrollDelta;
> 
>-    ASSERT(info.scrolls.size() == 1);
>-    IntSize scrollDelta = info.scrolls[0].scrollDelta;
>-    m_client->applyScrollAndScale(scrollDelta, info.pageScaleDelta);
>+    for (size_t i = 0; i < info.scrolls.size(); ++i) {
>+        LayerChromium* layer = findLayerById(m_rootLayer.get(), info.scrolls[i].layerId);
>+        if (!layer)
>+            continue;
>+        if (layer == rootScrollLayer)
>+            rootScrollDelta += info.scrolls[i].scrollDelta;
>+        else
>+            layer->scrollBy(info.scrolls[i].scrollDelta);
>+    }
>+    if (!rootScrollDelta.isZero() || info.pageScaleDelta != 1)
>+        m_client->applyScrollAndScale(rootScrollDelta, info.pageScaleDelta);
> }
> 
> void CCLayerTreeHost::startRateLimiter(GraphicsContext3D* context)
>diff --git a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp b/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp
>index e7d3a81c457ad5907b93583b9759348ede86259d..cf46333f420c618a9816574788ba8468d714ba73 100644
>--- a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp
>+++ b/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp
>@@ -104,7 +104,8 @@ CCLayerTreeHostImpl::CCLayerTreeHostImpl(const CCSettings& settings, CCLayerTree
>     : m_client(client)
>     , m_sourceFrameNumber(-1)
>     , m_frameNumber(0)
>-    , m_scrollLayerImpl(0)
>+    , m_rootScrollLayerImpl(0)
>+    , m_currentlyScrollingLayerImpl(0)
>     , m_settings(settings)
>     , m_visible(true)
>     , m_pageScale(1)
>@@ -162,10 +163,10 @@ void CCLayerTreeHostImpl::animate(double monotonicTime, double wallClockTime)
> 
> void CCLayerTreeHostImpl::startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, double startTime, double duration)
> {
>-    if (!m_scrollLayerImpl)
>+    if (!m_rootScrollLayerImpl)
>         return;
> 
>-    IntSize scrollTotal = flooredIntSize(m_scrollLayerImpl->scrollPosition() + m_scrollLayerImpl->scrollDelta());
>+    IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
>     scrollTotal.scale(m_pageScaleDelta);
>     float scaleTotal = m_pageScale * m_pageScaleDelta;
>     IntSize scaledContentSize = contentSize();
>@@ -364,9 +365,26 @@ IntSize CCLayerTreeHostImpl::contentSize() const
> {
>     // TODO(aelias): Hardcoding the first child here is weird. Think of
>     // a cleaner way to get the contentBounds on the Impl side.
>-    if (!m_scrollLayerImpl || m_scrollLayerImpl->children().isEmpty())
>+    if (!m_rootScrollLayerImpl || m_rootScrollLayerImpl->children().isEmpty())
>         return IntSize();
>-    return m_scrollLayerImpl->children()[0]->contentBounds();
>+    return m_rootScrollLayerImpl->children()[0]->contentBounds();
>+}
>+
>+void CCLayerTreeHostImpl::calculateVisibleLayers(CCLayerTreeHostImpl::FrameData& frame, CCLayerGeometryList& visibleLayers)
>+{
>+    typedef CCLayerIterator<CCLayerImpl, CCLayerList, CCRenderSurface, CCLayerIteratorActions::FrontToBack> CCLayerIteratorType;
>+    CCLayerIteratorType end = CCLayerIteratorType::end(&frame.renderSurfaceLayerList);
>+    for (CCLayerIteratorType it = CCLayerIteratorType::begin(&frame.renderSurfaceLayerList); it != end; ++it) {
>+        CCLayerImpl* layerImpl = (*it);
>+        if (!layerImpl->screenSpaceTransform().isInvertible())
>+            continue;
>+        struct LayerGeometry layerGeometry = {
>+            layerImpl->id(),
>+            layerImpl->screenSpaceTransform(),
>+            layerImpl->visibleLayerRect(),
>+        };
>+        visibleLayers.append(layerGeometry);
>+    }
> }
> 
> bool CCLayerTreeHostImpl::prepareToDraw(FrameData& frame)
>@@ -375,6 +393,7 @@ bool CCLayerTreeHostImpl::prepareToDraw(FrameData& frame)
> 
>     frame.renderPasses.clear();
>     frame.renderSurfaceLayerList.clear();
>+    m_visibleLayers.clear();
> 
>     if (!rootLayer())
>         return false;
>@@ -382,6 +401,8 @@ bool CCLayerTreeHostImpl::prepareToDraw(FrameData& frame)
>     if (!calculateRenderPasses(frame.renderPasses, frame.renderSurfaceLayerList))
>         return false;
> 
>+    calculateVisibleLayers(frame, m_visibleLayers);
>+
>     // If we return true, then we expect drawLayers() to be called before this function is called again.
>     return true;
> }
>@@ -456,7 +477,7 @@ void CCLayerTreeHostImpl::readback(void* pixels, const IntRect& rect)
>     m_layerRenderer->getFramebufferPixels(pixels, rect);
> }
> 
>-static CCLayerImpl* findScrollLayer(CCLayerImpl* layer)
>+static CCLayerImpl* findRootScrollLayer(CCLayerImpl* layer)
> {
>     if (!layer)
>         return 0;
>@@ -465,7 +486,7 @@ static CCLayerImpl* findScrollLayer(CCLayerImpl* layer)
>         return layer;
> 
>     for (size_t i = 0; i < layer->children().size(); ++i) {
>-        CCLayerImpl* found = findScrollLayer(layer->children()[i].get());
>+        CCLayerImpl* found = findRootScrollLayer(layer->children()[i].get());
>         if (found)
>             return found;
>     }
>@@ -473,12 +494,32 @@ static CCLayerImpl* findScrollLayer(CCLayerImpl* layer)
>     return 0;
> }
> 
>+// 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 CCLayerImpl* findScrollLayerForContentLayer(CCLayerImpl* layerImpl)
>+{
>+    if (!layerImpl)
>+        return 0;
>+
>+    if (layerImpl->scrollable())
>+        return layerImpl;
>+
>+    if (layerImpl->drawsContent() && layerImpl->parent() && layerImpl->parent()->scrollable())
>+        return layerImpl->parent();
>+
>+    return 0;
>+}
>+
> void CCLayerTreeHostImpl::setRootLayer(PassOwnPtr<CCLayerImpl> layer)
> {
>     m_rootLayerImpl = layer;
>+    m_rootScrollLayerImpl = findRootScrollLayer(m_rootLayerImpl.get());
> 
>-    // FIXME: Currently, this only finds the first scrollable layer.
>-    m_scrollLayerImpl = findScrollLayer(m_rootLayerImpl.get());
>+    if (m_currentlyScrollingLayerImpl) {
>+        if (!m_rootLayerImpl || !m_rootLayerImpl->findLayerInSubtree(m_currentlyScrollingLayerImpl->id()))
>+            m_currentlyScrollingLayerImpl = 0;
>+    }
> }
> 
> void CCLayerTreeHostImpl::setVisible(bool visible)
>@@ -527,6 +568,34 @@ void CCLayerTreeHostImpl::setViewportSize(const IntSize& viewportSize)
>         m_layerRenderer->viewportChanged();
> }
> 
>+static void adjustScrollsForPageScaleChange(CCLayerImpl* layerImpl, float pageScaleChange)
>+{
>+    if (!layerImpl)
>+        return;
>+
>+    if (layerImpl->scrollable()) {
>+        // We need to convert impl-side scroll deltas to pageScale space.
>+        FloatSize scrollDelta = layerImpl->scrollDelta();
>+        scrollDelta.scale(pageScaleChange);
>+        layerImpl->setScrollDelta(scrollDelta);
>+    }
>+
>+    for (size_t i = 0; i < layerImpl->children().size(); ++i)
>+        adjustScrollsForPageScaleChange(layerImpl->children()[i].get(), pageScaleChange);
>+}
>+
>+static void applyPageScaleDeltaToScrollLayers(CCLayerImpl* layerImpl, float pageScaleDelta)
>+{
>+    if (!layerImpl)
>+        return;
>+
>+    if (layerImpl->scrollable())
>+        layerImpl->setPageScaleDelta(pageScaleDelta);
>+
>+    for (size_t i = 0; i < layerImpl->children().size(); ++i)
>+        applyPageScaleDeltaToScrollLayers(layerImpl->children()[i].get(), pageScaleDelta);
>+}
>+
> void CCLayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScale, float minPageScale, float maxPageScale)
> {
>     if (!pageScale)
>@@ -541,25 +610,13 @@ void CCLayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScale, float min
>     float pageScaleChange = pageScale / m_pageScale;
>     m_pageScale = pageScale;
> 
>-    adjustScrollsForPageScaleChange(pageScaleChange);
>+    if (pageScaleChange != 1)
>+        adjustScrollsForPageScaleChange(m_rootScrollLayerImpl, pageScaleChange);
> 
>     // Clamp delta to limits and refresh display matrix.
>     setPageScaleDelta(m_pageScaleDelta / m_sentPageScaleDelta);
>     m_sentPageScaleDelta = 1;
>-    applyPageScaleDeltaToScrollLayer();
>-}
>-
>-void CCLayerTreeHostImpl::adjustScrollsForPageScaleChange(float pageScaleChange)
>-{
>-    if (pageScaleChange == 1)
>-        return;
>-
>-    // We also need to convert impl-side scroll deltas to pageScale space.
>-    if (m_scrollLayerImpl) {
>-        FloatSize scrollDelta = m_scrollLayerImpl->scrollDelta();
>-        scrollDelta.scale(pageScaleChange);
>-        m_scrollLayerImpl->setScrollDelta(scrollDelta);
>-    }
>+    applyPageScaleDeltaToScrollLayers(m_rootScrollLayerImpl, m_pageScaleDelta);
> }
> 
> void CCLayerTreeHostImpl::setPageScaleDelta(float delta)
>@@ -577,22 +634,16 @@ void CCLayerTreeHostImpl::setPageScaleDelta(float delta)
>     m_pageScaleDelta = delta;
> 
>     updateMaxScrollPosition();
>-    applyPageScaleDeltaToScrollLayer();
>-}
>-
>-void CCLayerTreeHostImpl::applyPageScaleDeltaToScrollLayer()
>-{
>-    if (m_scrollLayerImpl)
>-        m_scrollLayerImpl->setPageScaleDelta(m_pageScaleDelta);
>+    applyPageScaleDeltaToScrollLayers(m_rootScrollLayerImpl, m_pageScaleDelta);
> }
> 
> void CCLayerTreeHostImpl::updateMaxScrollPosition()
> {
>-    if (!m_scrollLayerImpl || !m_scrollLayerImpl->children().size())
>+    if (!m_rootScrollLayerImpl || !m_rootScrollLayerImpl->children().size())
>         return;
> 
>     FloatSize viewBounds = m_viewportSize;
>-    if (CCLayerImpl* clipLayer = m_scrollLayerImpl->parent()) {
>+    if (CCLayerImpl* clipLayer = m_rootScrollLayerImpl->parent()) {
>         if (clipLayer->masksToBounds())
>             viewBounds = clipLayer->bounds();
>     }
>@@ -603,9 +654,7 @@ void CCLayerTreeHostImpl::updateMaxScrollPosition()
>     // having a vertical scrollbar but no horizontal overflow.
>     maxScroll.clampNegativeToZero();
> 
>-    m_scrollLayerImpl->setMaxScrollPosition(maxScroll);
>-
>-    // TODO(aelias): Also update sublayers.
>+    m_rootScrollLayerImpl->setMaxScrollPosition(maxScroll);
> }
> 
> void CCLayerTreeHostImpl::setNeedsRedraw()
>@@ -615,44 +664,84 @@ void CCLayerTreeHostImpl::setNeedsRedraw()
> 
> CCInputHandlerClient::ScrollStatus CCLayerTreeHostImpl::scrollBegin(const IntPoint& viewportPoint, CCInputHandlerClient::ScrollInputType type)
> {
>-    // TODO: Check for scrollable sublayers.
>-    if (!m_scrollLayerImpl || !m_scrollLayerImpl->scrollable()) {
>-        TRACE_EVENT("scrollBegin Ignored no scrollable", this, 0);
>+    m_currentlyScrollingLayerImpl = 0;
>+
>+
>+    if (!m_rootLayerImpl)
>         return ScrollIgnored;
>-    }
> 
>-    if (m_scrollLayerImpl->shouldScrollOnMainThread()) {
>-        TRACE_EVENT("scrollBegin Failed shouldScrollOnMainThread", this, 0);
>-        return ScrollFailed;
>+    // First find out which layer was hit by walking the saved list of visible layers.
>+    CCLayerImpl* layerImpl = 0;
>+    for (size_t i = 0; i < m_visibleLayers.size(); ++i) {
>+        LayerGeometry& geometry = m_visibleLayers[i];
>+        IntPoint contentPoint(geometry.screenSpaceTransform.inverse().mapPoint(viewportPoint));
>+        if (geometry.visibleLayerRect.contains(contentPoint)) {
>+            layerImpl = m_rootLayerImpl->findLayerInSubtree(geometry.layerId);
>+            break;
>+        }
>     }
> 
>-    IntPoint scrollLayerContentPoint(m_scrollLayerImpl->screenSpaceTransform().inverse().mapPoint(viewportPoint));
>-    if (m_scrollLayerImpl->nonFastScrollableRegion().contains(scrollLayerContentPoint)) {
>-        TRACE_EVENT("scrollBegin Failed nonFastScrollableRegion", this, 0);
>-        return ScrollFailed;
>-    }
>+    // Walk up the hierarchy and look for a scrollable layer.
>+    CCLayerImpl* potentiallyScrollingLayerImpl = 0;
>+    for (; layerImpl; layerImpl = layerImpl->parent()) {
>+        // The content layer can also block attempts to scroll outside the main thread.
>+        if (layerImpl->tryScroll(viewportPoint, type) == ScrollFailed)
>+            return ScrollFailed;
>+
>+        CCLayerImpl* scrollLayerImpl = findScrollLayerForContentLayer(layerImpl);
>+        if (!scrollLayerImpl)
>+            continue;
>+
>+        ScrollStatus status = scrollLayerImpl->tryScroll(viewportPoint, type);
>+
>+        // If any layer wants to divert the scroll event to the main thread, abort.
>+        if (status == ScrollFailed)
>+            return ScrollFailed;
> 
>-    if (type == CCInputHandlerClient::Wheel && m_scrollLayerImpl->haveWheelEventHandlers()) {
>-        TRACE_EVENT("scrollBegin Failed wheelEventHandlers", this, 0);
>-        return ScrollFailed;
>+        if (status == ScrollStarted && !potentiallyScrollingLayerImpl)
>+            potentiallyScrollingLayerImpl = scrollLayerImpl;
>     }
> 
>-    return ScrollStarted;
>+    if (potentiallyScrollingLayerImpl) {
>+        m_currentlyScrollingLayerImpl = potentiallyScrollingLayerImpl;
>+        return ScrollStarted;
>+    }
>+    return ScrollIgnored;
> }
> 
> void CCLayerTreeHostImpl::scrollBy(const IntSize& scrollDelta)
> {
>     TRACE_EVENT("CCLayerTreeHostImpl::scrollBy", this, 0);
>-    if (!m_scrollLayerImpl)
>+    if (!m_currentlyScrollingLayerImpl)
>         return;
> 
>-    m_scrollLayerImpl->scrollBy(scrollDelta);
>-    m_client->setNeedsCommitOnImplThread();
>-    m_client->setNeedsRedrawOnImplThread();
>+    FloatSize pendingDelta(scrollDelta);
>+    pendingDelta.scale(1 / m_pageScaleDelta);
>+
>+    for (CCLayerImpl* layerImpl = m_currentlyScrollingLayerImpl; layerImpl && !pendingDelta.isZero(); layerImpl = layerImpl->parent()) {
>+        if (!layerImpl->scrollable())
>+            continue;
>+        FloatSize previousDelta(layerImpl->scrollDelta());
>+        layerImpl->scrollBy(pendingDelta);
>+        // Reset the pending scroll delta to zero if the layer was able to move along the requested
>+        // axis. This is to ensure it is possible to scroll exactly to the beginning or end of a
>+        // scroll area regardless of the scroll step. For diagonal scrolls this also avoids applying
>+        // the scroll on one axis to multiple layers.
>+        if (previousDelta.width() != layerImpl->scrollDelta().width())
>+            pendingDelta.setWidth(0);
>+        if (previousDelta.height() != layerImpl->scrollDelta().height())
>+            pendingDelta.setHeight(0);
>+    }
>+
>+    if (pendingDelta != scrollDelta) {
>+        m_client->setNeedsCommitOnImplThread();
>+        m_client->setNeedsRedrawOnImplThread();
>+    }
> }
> 
> void CCLayerTreeHostImpl::scrollEnd()
> {
>+    m_currentlyScrollingLayerImpl = 0;
> }
> 
> void CCLayerTreeHostImpl::pinchGestureBegin()
>@@ -666,7 +755,7 @@ void CCLayerTreeHostImpl::pinchGestureUpdate(float magnifyDelta,
> {
>     TRACE_EVENT("CCLayerTreeHostImpl::pinchGestureUpdate", this, 0);
> 
>-    if (!m_scrollLayerImpl)
>+    if (!m_rootScrollLayerImpl)
>         return;
> 
>     if (m_previousPinchAnchor == IntPoint::zero())
>@@ -681,7 +770,7 @@ void CCLayerTreeHostImpl::pinchGestureUpdate(float magnifyDelta,
> 
>     m_previousPinchAnchor = anchor;
> 
>-    m_scrollLayerImpl->scrollBy(roundedIntSize(move));
>+    m_rootScrollLayerImpl->scrollBy(roundedIntSize(move));
>     m_client->setNeedsCommitOnImplThread();
>     m_client->setNeedsRedrawOnImplThread();
> }
>@@ -703,7 +792,7 @@ void CCLayerTreeHostImpl::computeDoubleTapZoomDeltas(CCScrollAndScaleSet* scroll
> 
> void CCLayerTreeHostImpl::computePinchZoomDeltas(CCScrollAndScaleSet* scrollInfo)
> {
>-    if (!m_scrollLayerImpl)
>+    if (!m_rootScrollLayerImpl)
>         return;
> 
>     // Only send fake scroll/zoom deltas if we're pinch zooming out by a
>@@ -715,7 +804,7 @@ void CCLayerTreeHostImpl::computePinchZoomDeltas(CCScrollAndScaleSet* scrollInfo
> 
>     // Compute where the scroll offset/page scale would be if fully pinch-zoomed
>     // out from the anchor point.
>-    IntSize scrollBegin = flooredIntSize(m_scrollLayerImpl->scrollPosition() + m_scrollLayerImpl->scrollDelta());
>+    IntSize scrollBegin = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
>     scrollBegin.scale(m_pageScaleDelta);
>     float scaleBegin = m_pageScale * m_pageScaleDelta;
>     float pageScaleDeltaToSend = m_minPageScale / m_pageScale;
>@@ -734,21 +823,41 @@ void CCLayerTreeHostImpl::computePinchZoomDeltas(CCScrollAndScaleSet* scrollInfo
> 
> void CCLayerTreeHostImpl::makeScrollAndScaleSet(CCScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale)
> {
>-    if (!m_scrollLayerImpl)
>+    if (!m_rootScrollLayerImpl)
>         return;
> 
>     CCLayerTreeHostCommon::ScrollUpdateInfo scroll;
>-    scroll.layerId = m_scrollLayerImpl->id();
>-    scroll.scrollDelta = scrollOffset - toSize(m_scrollLayerImpl->scrollPosition());
>+    scroll.layerId = m_rootScrollLayerImpl->id();
>+    scroll.scrollDelta = scrollOffset - toSize(m_rootScrollLayerImpl->scrollPosition());
>     scrollInfo->scrolls.append(scroll);
>-    m_scrollLayerImpl->setSentScrollDelta(scroll.scrollDelta);
>+    m_rootScrollLayerImpl->setSentScrollDelta(scroll.scrollDelta);
>     m_sentPageScaleDelta = scrollInfo->pageScaleDelta = pageScale / m_pageScale;
> }
> 
>+static void collectScrollDeltas(CCScrollAndScaleSet* scrollInfo, CCLayerImpl* layerImpl)
>+{
>+    if (!layerImpl)
>+        return;
>+
>+    if (!layerImpl->scrollDelta().isZero()) {
>+        IntSize scrollDelta = flooredIntSize(layerImpl->scrollDelta());
>+        CCLayerTreeHostCommon::ScrollUpdateInfo scroll;
>+        scroll.layerId = layerImpl->id();
>+        scroll.scrollDelta = scrollDelta;
>+        scrollInfo->scrolls.append(scroll);
>+        layerImpl->setSentScrollDelta(scrollDelta);
>+    }
>+
>+    for (size_t i = 0; i < layerImpl->children().size(); ++i)
>+        collectScrollDeltas(scrollInfo, layerImpl->children()[i].get());
>+}
>+
> PassOwnPtr<CCScrollAndScaleSet> CCLayerTreeHostImpl::processScrollDeltas()
> {
>     OwnPtr<CCScrollAndScaleSet> scrollInfo = adoptPtr(new CCScrollAndScaleSet());
>-    bool didMove = m_scrollLayerImpl && (!m_scrollLayerImpl->scrollDelta().isZero() || m_pageScaleDelta != 1.0f);
>+    collectScrollDeltas(scrollInfo.get(), m_rootLayerImpl.get());
>+
>+    bool didMove = scrollInfo->scrolls.size() || m_pageScaleDelta != 1;
>     if (!didMove || m_pinchGestureActive || m_pageScaleAnimation) {
>         m_sentPageScaleDelta = scrollInfo->pageScaleDelta = 1;
>         if (m_pinchGestureActive)
>@@ -760,14 +869,6 @@ PassOwnPtr<CCScrollAndScaleSet> CCLayerTreeHostImpl::processScrollDeltas()
> 
>     m_sentPageScaleDelta = scrollInfo->pageScaleDelta = m_pageScaleDelta;
> 
>-    // FIXME: track scrolls from layers other than the root
>-    CCLayerTreeHostCommon::ScrollUpdateInfo scroll;
>-    scroll.layerId = m_scrollLayerImpl->id();
>-    scroll.scrollDelta = flooredIntSize(m_scrollLayerImpl->scrollDelta());
>-    scrollInfo->scrolls.append(scroll);
>-
>-    m_scrollLayerImpl->setSentScrollDelta(scroll.scrollDelta);
>-
>     return scrollInfo.release();
> }
> 
>@@ -785,12 +886,12 @@ void CCLayerTreeHostImpl::animatePageScale(double monotonicTime)
>     if (!m_pageScaleAnimation)
>         return;
> 
>-    IntSize scrollTotal = flooredIntSize(m_scrollLayerImpl->scrollPosition() + m_scrollLayerImpl->scrollDelta());
>+    IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
> 
>     setPageScaleDelta(m_pageScaleAnimation->pageScaleAtTime(monotonicTime) / m_pageScale);
>     IntSize nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime);
>     nextScroll.scale(1 / m_pageScaleDelta);
>-    m_scrollLayerImpl->scrollBy(nextScroll - scrollTotal);
>+    m_rootScrollLayerImpl->scrollBy(nextScroll - scrollTotal);
>     m_client->setNeedsRedrawOnImplThread();
> 
>     if (m_pageScaleAnimation->isAnimationCompleteAtTime(monotonicTime)) {
>diff --git a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h b/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h
>index a859fec5c203dbd2b46b3ceccf221fd691cb3d66..e21c21580f2df8bbdc24edbc60bcc1c45ed8ce33 100644
>--- a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h
>+++ b/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h
>@@ -121,7 +121,7 @@ public:
>     void setRootLayer(PassOwnPtr<CCLayerImpl>);
>     PassOwnPtr<CCLayerImpl> releaseRootLayer() { return m_rootLayerImpl.release(); }
> 
>-    CCLayerImpl* scrollLayer() const { return m_scrollLayerImpl; }
>+    CCLayerImpl* rootScrollLayer() const { return m_rootScrollLayerImpl; }
> 
>     bool visible() const { return m_visible; }
>     void setVisible(bool);
>@@ -162,8 +162,6 @@ private:
>     void makeScrollAndScaleSet(CCScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale);
> 
>     void setPageScaleDelta(float);
>-    void applyPageScaleDeltaToScrollLayer();
>-    void adjustScrollsForPageScaleChange(float);
>     void updateMaxScrollPosition();
>     void trackDamageForAllSurfaces(CCLayerImpl* rootDrawLayer, const CCLayerList& renderSurfaceLayerList);
>     // Returns false if the frame should not be displayed.
>@@ -172,9 +170,18 @@ private:
>     IntSize contentSize() const;
>     void sendDidLoseContextRecursive(CCLayerImpl*);
> 
>+    struct LayerGeometry {
>+        int layerId;
>+        TransformationMatrix screenSpaceTransform;
>+        IntRect visibleLayerRect;
>+    };
>+    typedef Vector<LayerGeometry> CCLayerGeometryList;
>+    static void calculateVisibleLayers(CCLayerTreeHostImpl::FrameData&, CCLayerGeometryList&);
>+
>     OwnPtr<LayerRendererChromium> m_layerRenderer;
>     OwnPtr<CCLayerImpl> m_rootLayerImpl;
>-    CCLayerImpl* m_scrollLayerImpl;
>+    CCLayerImpl* m_rootScrollLayerImpl;
>+    CCLayerImpl* m_currentlyScrollingLayerImpl;
>     CCSettings m_settings;
>     IntSize m_viewportSize;
>     bool m_visible;
>@@ -197,6 +204,10 @@ private:
> 
>     CCLayerSorter m_layerSorter;
> 
>+    // List of visible layers in the most recent frame in front-to-back order.
>+    // Used for input event hit testing.
>+    CCLayerGeometryList m_visibleLayers;
>+
>     FloatRect m_rootDamageRect;
> };
> 
>diff --git a/Source/WebKit/chromium/src/WebContentLayerImpl.cpp b/Source/WebKit/chromium/src/WebContentLayerImpl.cpp
>index 4f64d5471e396650f7ca75e9e1625c66d72f11b6..9d613a3aca991c995de39748724c71fcba942e97 100644
>--- a/Source/WebKit/chromium/src/WebContentLayerImpl.cpp
>+++ b/Source/WebKit/chromium/src/WebContentLayerImpl.cpp
>@@ -72,4 +72,8 @@ void WebContentLayerImpl::paintContents(GraphicsContext& gc, const IntRect& clip
>     m_contentClient->paintContents(canvas, WebRect(clip));
> }
> 
>+void WebContentLayerImpl::didScroll(const WebCore::IntSize&)
>+{
>+}
>+
> } // namespace WebKit
>diff --git a/Source/WebKit/chromium/src/WebContentLayerImpl.h b/Source/WebKit/chromium/src/WebContentLayerImpl.h
>index 51f344f7caf1271126ac7b4268ed5461214219d8..1ba884c9b357ebf387edff349f656eafa66ae1ec 100644
>--- a/Source/WebKit/chromium/src/WebContentLayerImpl.h
>+++ b/Source/WebKit/chromium/src/WebContentLayerImpl.h
>@@ -44,6 +44,7 @@ protected:
> 
>     // ContentLayerDelegate implementation.
>     virtual void paintContents(WebCore::GraphicsContext&, const WebCore::IntRect& clip);
>+    virtual void didScroll(const WebCore::IntSize&);
> 
>     WebContentLayerClient* m_contentClient;
>     bool m_drawsContent;
>diff --git a/Source/WebKit/chromium/tests/CCLayerImplTest.cpp b/Source/WebKit/chromium/tests/CCLayerImplTest.cpp
>index 8a9f35dc8a7b89c0c94bd7537c68464fa78a6bb8..b8afb2e5522bd009b8b08082a3e1529fedb8f31a 100644
>--- a/Source/WebKit/chromium/tests/CCLayerImplTest.cpp
>+++ b/Source/WebKit/chromium/tests/CCLayerImplTest.cpp
>@@ -162,4 +162,28 @@ TEST(CCLayerImplTest, verifyLayerChangesAreTrackedProperly)
>     EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->setMaxScrollPosition(arbitraryIntSize));
> }
> 
>+TEST(CCLayerImplTest, verifySubtreeSearch)
>+{
>+    // The constructor on this will fake that we are on the correct thread.
>+    DebugScopedSetImplThread setImplThread;
>+
>+    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
>+    OwnPtr<CCLayerImpl> child = CCLayerImpl::create(2);
>+    OwnPtr<CCLayerImpl> grandChild = CCLayerImpl::create(3);
>+    OwnPtr<CCLayerImpl> maskLayer = CCLayerImpl::create(4);
>+    OwnPtr<CCLayerImpl> replicaLayer = CCLayerImpl::create(5);
>+
>+    grandChild->setReplicaLayer(replicaLayer.release());
>+    child->addChild(grandChild.release());
>+    child->setMaskLayer(maskLayer.release());
>+    root->addChild(child.release());
>+
>+    EXPECT_EQ(1, root->findLayerInSubtree(1)->id());
>+    EXPECT_EQ(2, root->findLayerInSubtree(2)->id());
>+    EXPECT_EQ(3, root->findLayerInSubtree(3)->id());
>+    EXPECT_EQ(4, root->findLayerInSubtree(4)->id());
>+    EXPECT_EQ(5, root->findLayerInSubtree(5)->id());
>+    EXPECT_EQ(0, root->findLayerInSubtree(6));
>+}
>+
> } // namespace
>diff --git a/Source/WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp b/Source/WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp
>index 7009c8c3e93ca6cc02d455257ef1309cedff65be..0cbc2f3b587d998556a06a3201073b8d47f9e677 100644
>--- a/Source/WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp
>+++ b/Source/WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp
>@@ -95,6 +95,25 @@ public:
>         m_hostImpl->setRootLayer(root.release());
>     }
> 
>+    static PassOwnPtr<CCLayerImpl> createScrollableLayer(int id, const FloatPoint& position, const IntSize& size)
>+    {
>+        OwnPtr<CCLayerImpl> layer = CCLayerImpl::create(id);
>+        layer->setScrollable(true);
>+        layer->setDrawsContent(true);
>+        layer->setPosition(position);
>+        layer->setBounds(size);
>+        layer->setMaxScrollPosition(IntSize(size.width() * 2, size.height() * 2));
>+        return layer.release();
>+    }
>+
>+    void initializeLayerRendererAndDrawFrame()
>+    {
>+        m_hostImpl->initializeLayerRenderer(createContext());
>+        CCLayerTreeHostImpl::FrameData frame;
>+        EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
>+        m_hostImpl->drawLayers(frame);
>+    }
>+
> protected:
>     PassRefPtr<GraphicsContext3D> createContext()
>     {
>@@ -178,10 +197,12 @@ TEST_F(CCLayerTreeHostImplTest, scrollRootCallsCommitAndRedraw)
> {
>     {
>         OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
>+        root->setVisibleLayerRect(IntRect(0, 0, 100, 100));
>         root->setScrollable(true);
>         root->setScrollPosition(IntPoint(0, 0));
>         root->setMaxScrollPosition(IntSize(100, 100));
>         m_hostImpl->setRootLayer(root.release());
>+        initializeLayerRendererAndDrawFrame();
>     }
> 
>     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
>@@ -195,10 +216,12 @@ TEST_F(CCLayerTreeHostImplTest, wheelEventHandlers)
> {
>     {
>         OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
>+        root->setVisibleLayerRect(IntRect(0, 0, 100, 100));
>         root->setScrollable(true);
>         root->setScrollPosition(IntPoint(0, 0));
>         root->setMaxScrollPosition(IntSize(100, 100));
>         m_hostImpl->setRootLayer(root.release());
>+        initializeLayerRendererAndDrawFrame();
>     }
>     CCLayerImpl* root = m_hostImpl->rootLayer();
> 
>@@ -213,11 +236,14 @@ TEST_F(CCLayerTreeHostImplTest, wheelEventHandlers)
> TEST_F(CCLayerTreeHostImplTest, shouldScrollOnMainThread)
> {
>     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
>+    root->setVisibleLayerRect(IntRect(0, 0, 100, 100));
>     root->setScrollable(true);
>     root->setScrollPosition(IntPoint(0, 0));
>     root->setMaxScrollPosition(IntSize(100, 100));
>     root->setShouldScrollOnMainThread(true);
>     m_hostImpl->setRootLayer(root.release());
>+    initializeLayerRendererAndDrawFrame();
>+
>     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollFailed);
>     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Gesture), CCInputHandlerClient::ScrollFailed);
> }
>@@ -225,11 +251,14 @@ TEST_F(CCLayerTreeHostImplTest, shouldScrollOnMainThread)
> TEST_F(CCLayerTreeHostImplTest, nonFastScrollableRegionBasic)
> {
>     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
>+    root->setVisibleLayerRect(IntRect(0, 0, 100, 100));
>     root->setScrollable(true);
>     root->setScrollPosition(IntPoint(0, 0));
>     root->setMaxScrollPosition(IntSize(100, 100));
>     root->setNonFastScrollableRegion(IntRect(0, 0, 50, 50));
>     m_hostImpl->setRootLayer(root.release());
>+    initializeLayerRendererAndDrawFrame();
>+
>     // All scroll types inside the non-fast scrollable region should fail.
>     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(25, 25), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollFailed);
>     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(25, 25), CCInputHandlerClient::Gesture), CCInputHandlerClient::ScrollFailed);
>@@ -245,18 +274,15 @@ TEST_F(CCLayerTreeHostImplTest, nonFastScrollableRegionBasic)
> 
> TEST_F(CCLayerTreeHostImplTest, nonFastScrollableRegionWithOffset)
> {
>-    m_hostImpl->initializeLayerRenderer(createContext());
>-
>     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
>+    root->setVisibleLayerRect(IntRect(0, 0, 100, 100));
>     root->setScrollable(true);
>     root->setScrollPosition(IntPoint(0, 0));
>     root->setMaxScrollPosition(IntSize(100, 100));
>     root->setNonFastScrollableRegion(IntRect(0, 0, 50, 50));
>     root->setPosition(FloatPoint(-25, 0));
>     m_hostImpl->setRootLayer(root.release());
>-    CCLayerTreeHostImpl::FrameData frame;
>-    EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
>-    m_hostImpl->drawLayers(frame); // Update draw transforms so we can correctly map points into layer space.
>+    initializeLayerRendererAndDrawFrame();
> 
>     // This point would fall into the non-fast scrollable region except that we've moved the layer down by 25 pixels.
>     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(40, 10), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
>@@ -271,8 +297,9 @@ TEST_F(CCLayerTreeHostImplTest, pinchGesture)
> {
>     setupScrollAndContentsLayers(IntSize(100, 100));
>     m_hostImpl->setViewportSize(IntSize(50, 50));
>+    initializeLayerRendererAndDrawFrame();
> 
>-    CCLayerImpl* scrollLayer = m_hostImpl->scrollLayer();
>+    CCLayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
>     ASSERT(scrollLayer);
> 
>     const float minPageScale = 0.5, maxPageScale = 4;
>@@ -351,8 +378,9 @@ TEST_F(CCLayerTreeHostImplTest, pageScaleAnimation)
> {
>     setupScrollAndContentsLayers(IntSize(100, 100));
>     m_hostImpl->setViewportSize(IntSize(50, 50));
>+    initializeLayerRendererAndDrawFrame();
> 
>-    CCLayerImpl* scrollLayer = m_hostImpl->scrollLayer();
>+    CCLayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
>     ASSERT(scrollLayer);
> 
>     const float minPageScale = 0.5, maxPageScale = 4;
>@@ -559,6 +587,269 @@ TEST_F(CCLayerTreeHostImplTest, prepareToDrawFailsWhenAnimationUsesCheckerboard)
>     m_hostImpl->drawLayers(frame);
> }
> 
>+TEST_F(CCLayerTreeHostImplTest, scrollRootIgnored)
>+{
>+    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
>+    root->setScrollable(false);
>+    m_hostImpl->setRootLayer(root.release());
>+    initializeLayerRendererAndDrawFrame();
>+
>+    // Scroll event is ignored because layer is not scrollable.
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollIgnored);
>+    EXPECT_FALSE(m_didRequestRedraw);
>+    EXPECT_FALSE(m_didRequestCommit);
>+}
>+
>+TEST_F(CCLayerTreeHostImplTest, scrollNonCompositedRoot)
>+{
>+    // Test the configuration where a non-composited root layer is embedded in a
>+    // scrollable outer layer.
>+    IntSize surfaceSize(10, 10);
>+
>+    OwnPtr<CCLayerImpl> contentLayer = CCLayerImpl::create(1);
>+    contentLayer->setIsNonCompositedContent(true);
>+    contentLayer->setDrawsContent(true);
>+    contentLayer->setPosition(IntPoint(5, 5));
>+    contentLayer->setBounds(surfaceSize);
>+    contentLayer->setContentBounds(IntSize(surfaceSize.width() * 2, surfaceSize.height() * 2));
>+
>+    OwnPtr<CCLayerImpl> scrollLayer = CCLayerImpl::create(0);
>+    scrollLayer->setScrollable(true);
>+    scrollLayer->addChild(contentLayer.release());
>+
>+    m_hostImpl->setRootLayer(scrollLayer.release());
>+    m_hostImpl->setViewportSize(surfaceSize);
>+    initializeLayerRendererAndDrawFrame();
>+
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
>+    m_hostImpl->scrollBy(IntSize(0, 10));
>+    m_hostImpl->scrollEnd();
>+    EXPECT_TRUE(m_didRequestRedraw);
>+    EXPECT_TRUE(m_didRequestCommit);
>+}
>+
>+TEST_F(CCLayerTreeHostImplTest, scrollChildCallsCommitAndRedraw)
>+{
>+    IntSize surfaceSize(10, 10);
>+    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
>+    root->addChild(createScrollableLayer(1, FloatPoint(5, 5), surfaceSize));
>+    m_hostImpl->setRootLayer(root.release());
>+    m_hostImpl->setViewportSize(surfaceSize);
>+    initializeLayerRendererAndDrawFrame();
>+
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
>+    m_hostImpl->scrollBy(IntSize(0, 10));
>+    m_hostImpl->scrollEnd();
>+    EXPECT_TRUE(m_didRequestRedraw);
>+    EXPECT_TRUE(m_didRequestCommit);
>+}
>+
>+TEST_F(CCLayerTreeHostImplTest, scrollMissesChild)
>+{
>+    IntSize surfaceSize(10, 10);
>+    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
>+    root->addChild(createScrollableLayer(1, FloatPoint(5, 5), surfaceSize));
>+    m_hostImpl->setRootLayer(root.release());
>+    m_hostImpl->setViewportSize(surfaceSize);
>+    initializeLayerRendererAndDrawFrame();
>+
>+    // Scroll event is ignored because the input coordinate is outside the layer boundaries.
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(15, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollIgnored);
>+    EXPECT_FALSE(m_didRequestRedraw);
>+    EXPECT_FALSE(m_didRequestCommit);
>+}
>+
>+TEST_F(CCLayerTreeHostImplTest, scrollMissesBackfacingChild)
>+{
>+    IntSize surfaceSize(10, 10);
>+    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
>+    OwnPtr<CCLayerImpl> child = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
>+    m_hostImpl->setViewportSize(surfaceSize);
>+
>+    TransformationMatrix matrix;
>+    matrix.rotate3d(180, 0, 0);
>+    child->setTransform(matrix);
>+    child->setDoubleSided(false);
>+
>+    root->addChild(child.release());
>+    m_hostImpl->setRootLayer(root.release());
>+    initializeLayerRendererAndDrawFrame();
>+
>+    // Scroll event is ignored because the hit layer is not facing the viewer.
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollIgnored);
>+    EXPECT_FALSE(m_didRequestRedraw);
>+    EXPECT_FALSE(m_didRequestCommit);
>+}
>+
>+TEST_F(CCLayerTreeHostImplTest, scrollBlockedByContentLayer)
>+{
>+    IntSize surfaceSize(10, 10);
>+    OwnPtr<CCLayerImpl> contentLayer = createScrollableLayer(0, FloatPoint(5, 5), surfaceSize);
>+    contentLayer->setShouldScrollOnMainThread(true);
>+    contentLayer->setScrollable(false);
>+
>+    OwnPtr<CCLayerImpl> scrollLayer = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
>+    scrollLayer->addChild(contentLayer.release());
>+
>+    m_hostImpl->setRootLayer(scrollLayer.release());
>+    m_hostImpl->setViewportSize(surfaceSize);
>+    initializeLayerRendererAndDrawFrame();
>+
>+    // Scrolling fails because the content layer is asking to be scrolled on the main thread.
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollFailed);
>+}
>+
>+TEST_F(CCLayerTreeHostImplTest, scrollRootAndChangePageScaleOnMainThread)
>+{
>+    IntSize surfaceSize(10, 10);
>+    float pageScale = 2;
>+    OwnPtr<CCLayerImpl> root = createScrollableLayer(0, FloatPoint(5, 5), surfaceSize);
>+    m_hostImpl->setRootLayer(root.release());
>+    m_hostImpl->setViewportSize(surfaceSize);
>+    initializeLayerRendererAndDrawFrame();
>+
>+    IntSize scrollDelta(0, 10);
>+    IntSize expectedScrollDelta(scrollDelta);
>+    IntSize expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollPosition());
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
>+    m_hostImpl->scrollBy(scrollDelta);
>+    m_hostImpl->scrollEnd();
>+
>+    // Set new page scale from main thread.
>+    m_hostImpl->setPageScaleFactorAndLimits(pageScale, pageScale, pageScale);
>+
>+    // The scale should apply to the scroll delta.
>+    expectedScrollDelta.scale(pageScale);
>+    OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
>+    expectContains(*scrollInfo.get(), 0, expectedScrollDelta);
>+
>+    // The scroll range should also have been updated.
>+    EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), expectedMaxScroll);
>+
>+    // The page scale delta remains constant because the impl thread did not scale.
>+    EXPECT_EQ(m_hostImpl->rootLayer()->pageScaleDelta(), 1);
>+}
>+
>+TEST_F(CCLayerTreeHostImplTest, scrollRootAndChangePageScaleOnImplThread)
>+{
>+    IntSize surfaceSize(10, 10);
>+    float pageScale = 2;
>+    OwnPtr<CCLayerImpl> root = createScrollableLayer(0, FloatPoint(5, 5), surfaceSize);
>+    m_hostImpl->setRootLayer(root.release());
>+    m_hostImpl->setViewportSize(surfaceSize);
>+    m_hostImpl->setPageScaleFactorAndLimits(1, 1, pageScale);
>+    initializeLayerRendererAndDrawFrame();
>+
>+    IntSize scrollDelta(0, 10);
>+    IntSize expectedScrollDelta(scrollDelta);
>+    IntSize expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollPosition());
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
>+    m_hostImpl->scrollBy(scrollDelta);
>+    m_hostImpl->scrollEnd();
>+
>+    // Set new page scale on impl thread by pinching.
>+    m_hostImpl->pinchGestureBegin();
>+    m_hostImpl->pinchGestureUpdate(pageScale, IntPoint());
>+    m_hostImpl->pinchGestureEnd();
>+
>+    // The scroll delta is not scaled because the main thread did not scale.
>+    OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
>+    expectContains(*scrollInfo.get(), 0, expectedScrollDelta);
>+
>+    // The scroll range should also have been updated.
>+    EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), expectedMaxScroll);
>+
>+    // The page scale delta should match the new scale on the impl side.
>+    EXPECT_EQ(m_hostImpl->rootLayer()->pageScaleDelta(), pageScale);
>+}
>+
>+TEST_F(CCLayerTreeHostImplTest, scrollChildAndChangePageScaleOnMainThread)
>+{
>+    IntSize surfaceSize(10, 10);
>+    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
>+    // Also mark the root scrollable so it becomes the root scroll layer.
>+    root->setScrollable(true);
>+    root->addChild(createScrollableLayer(1, FloatPoint(5, 5), surfaceSize));
>+    m_hostImpl->setRootLayer(root.release());
>+    m_hostImpl->setViewportSize(surfaceSize);
>+    initializeLayerRendererAndDrawFrame();
>+
>+    CCLayerImpl* child = m_hostImpl->rootLayer()->children()[0].get();
>+
>+    IntSize scrollDelta(0, 10);
>+    IntSize expectedScrollDelta(scrollDelta);
>+    IntSize expectedMaxScroll(child->maxScrollPosition());
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
>+    m_hostImpl->scrollBy(scrollDelta);
>+    m_hostImpl->scrollEnd();
>+
>+    float pageScale = 2;
>+    m_hostImpl->setPageScaleFactorAndLimits(pageScale, 1, pageScale);
>+
>+    // The scale should apply to the scroll delta.
>+    expectedScrollDelta.scale(pageScale);
>+    OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
>+    expectContains(*scrollInfo.get(), 1, expectedScrollDelta);
>+
>+    // The scroll range should not have changed.
>+    EXPECT_EQ(child->maxScrollPosition(), expectedMaxScroll);
>+
>+    // The page scale delta remains constant because the impl thread did not scale.
>+    EXPECT_EQ(child->pageScaleDelta(), 1);
>+}
>+
>+TEST_F(CCLayerTreeHostImplTest, scrollChildBeyondLimit)
>+{
>+    // Scroll a child layer beyond its maximum scroll range and make sure the
>+    // parent layer is scrolled on the axis on which the child was unable to
>+    // scroll.
>+    IntSize surfaceSize(10, 10);
>+    OwnPtr<CCLayerImpl> root = createScrollableLayer(0, FloatPoint(5, 5), surfaceSize);
>+
>+    OwnPtr<CCLayerImpl> grandChild = createScrollableLayer(2, FloatPoint(5, 5), surfaceSize);
>+    grandChild->setScrollPosition(IntPoint(0, 5));
>+
>+    OwnPtr<CCLayerImpl> child = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
>+    child->setScrollPosition(IntPoint(3, 0));
>+    child->addChild(grandChild.release());
>+
>+    root->addChild(child.release());
>+    m_hostImpl->setRootLayer(root.release());
>+    m_hostImpl->setViewportSize(surfaceSize);
>+    initializeLayerRendererAndDrawFrame();
>+    {
>+        IntSize scrollDelta(-3, -7);
>+        EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
>+        m_hostImpl->scrollBy(scrollDelta);
>+        m_hostImpl->scrollEnd();
>+
>+        OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
>+
>+        // The grand child should have scrolled up to its limit.
>+        CCLayerImpl* child = m_hostImpl->rootLayer()->children()[0].get();
>+        CCLayerImpl* grandChild = child->children()[0].get();
>+        expectContains(*scrollInfo.get(), grandChild->id(), IntSize(0, -5));
>+
>+        // The child should have only scrolled on the other axis.
>+        expectContains(*scrollInfo.get(), child->id(), IntSize(-3, 0));
>+    }
>+}
>+
>+TEST_F(CCLayerTreeHostImplTest, scrollBeforeRedraw)
>+{
>+    IntSize surfaceSize(10, 10);
>+    m_hostImpl->setRootLayer(createScrollableLayer(0, FloatPoint(5, 5), surfaceSize));
>+    m_hostImpl->setViewportSize(surfaceSize);
>+
>+    // Draw one frame and then immediately rebuild the layer tree to mimic a tree synchronization.
>+    initializeLayerRendererAndDrawFrame();
>+    m_hostImpl->releaseRootLayer();
>+    m_hostImpl->setRootLayer(createScrollableLayer(0, FloatPoint(5, 5), surfaceSize));
>+
>+    // Scrolling should still work even though we did not draw yet.
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
>+}
>+
> class BlendStateTrackerContext: public FakeWebGraphicsContext3D {
> public:
>     BlendStateTrackerContext() : m_blend(false) { }
>diff --git a/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp b/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp
>index a74e4ca455c6d4663449c7fa38205b76b1dcffe8..51c7c71890de9f437533adfd6f5450666eaef227 100644
>--- a/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp
>+++ b/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp
>@@ -1378,6 +1378,7 @@ public:
>     }
> 
>     virtual bool preserves3D() { return false; }
>+    virtual void didScroll(const IntSize&) { }
> 
> private:
>     CCLayerTreeHostTest* m_test;
>@@ -1527,7 +1528,8 @@ class MockContentLayerDelegate : public ContentLayerDelegate {
> public:
>     bool drawsContent() const { return true; }
>     MOCK_CONST_METHOD0(preserves3D, bool());
>-    void paintContents(GraphicsContext&, const IntRect&) { }
>+    virtual void paintContents(GraphicsContext&, const IntRect&) { }
>+    virtual void didScroll(const IntSize&) { }
>     void notifySyncRequired() { }
> };
> 
>@@ -2295,4 +2297,70 @@ TEST_F(CCLayerTreeHostTestFractionalScroll, runMultiThread)
>     runTestThreaded();
> }
> 
>+class CCLayerTreeHostTestScrollChildLayer : public CCLayerTreeHostTest {
>+public:
>+    CCLayerTreeHostTestScrollChildLayer()
>+        : m_scrollAmount(2, 1)
>+    {
>+    }
>+
>+    virtual void beginTest()
>+    {
>+        m_layerTreeHost->setViewportSize(IntSize(10, 10));
>+        m_rootScrollLayer = ContentLayerChromium::create(&m_mockDelegate);
>+        m_rootScrollLayer->setBounds(IntSize(10, 10));
>+        m_rootScrollLayer->setIsDrawable(true);
>+        m_rootScrollLayer->setScrollable(true);
>+        m_rootScrollLayer->setMaxScrollPosition(IntSize(100, 100));
>+        m_layerTreeHost->rootLayer()->addChild(m_rootScrollLayer);
>+        m_childLayer = ContentLayerChromium::create(&m_mockDelegate);
>+        m_childLayer->setBounds(IntSize(50, 50));
>+        m_childLayer->setIsDrawable(true);
>+        m_childLayer->setScrollable(true);
>+        m_childLayer->setMaxScrollPosition(IntSize(100, 100));
>+        m_rootScrollLayer->addChild(m_childLayer);
>+        postSetNeedsCommitToMainThread();
>+    }
>+
>+    virtual void applyScrollAndScale(const IntSize& scrollDelta, float)
>+    {
>+        IntPoint position = m_rootScrollLayer->scrollPosition();
>+        m_rootScrollLayer->setScrollPosition(position + scrollDelta);
>+    }
>+
>+    virtual void beginCommitOnCCThread(CCLayerTreeHostImpl* impl)
>+    {
>+        EXPECT_EQ(m_rootScrollLayer->scrollPosition(), IntPoint());
>+        if (!m_layerTreeHost->frameNumber())
>+            EXPECT_EQ(m_childLayer->scrollPosition(), IntPoint());
>+        else
>+            EXPECT_EQ(m_childLayer->scrollPosition(), IntPoint() + m_scrollAmount);
>+    }
>+
>+    virtual void drawLayersOnCCThread(CCLayerTreeHostImpl* impl)
>+    {
>+        if (impl->frameNumber() == 1) {
>+            EXPECT_EQ(impl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
>+            impl->scrollBy(m_scrollAmount);
>+            impl->scrollEnd();
>+        } else if (impl->frameNumber() == 2)
>+            endTest();
>+    }
>+
>+    virtual void afterTest()
>+    {
>+    }
>+
>+private:
>+    const IntSize m_scrollAmount;
>+    MockContentLayerDelegate m_mockDelegate;
>+    RefPtr<LayerChromium> m_childLayer;
>+    RefPtr<LayerChromium> m_rootScrollLayer;
>+};
>+
>+TEST_F(CCLayerTreeHostTestScrollChildLayer, runMultiThread)
>+{
>+    runTest(true);
>+}
>+
> } // namespace

Actions: View | Formatted Diff | Diff

Attachments on bug 73350: 117024 | 117245 | 117425 | 117426 | 118602 | 119032 | 119036 | 119050 | 119065 | 119285 | 119683 | 119898 | 120063 | 120067 | 121696 | 121861 | 122041 | 122229 | 124395 | 125653 | 126307 | 127318 | 134303 | 134541 | 134627 | 136690 | 137869 | 137917 | 146640 | 146873 | 147383 | 147607 | 147615 | 147654 | 147700 | 147779