Attachment 124395 Details for Bug 73350 – Patch

[patch] Patch

bug-73350-20120128002805.patch (text/plain), 51.12 KB, created by Sami Kyostila on 2012-01-27 16:28:07 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Sami Kyostila

Created: 2012-01-27 16:28:07 PST

Size: 51.12 KB

patch

obsolete

>Subversion Revision: 106131
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 35a6dd38c34fbf30240064bb5dae39ccfee7e7c9..51ef2891b702f7cca3cbb5cb853bc6bd5d73a8f9 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,50 @@
>+2011-12-09  Sami Kyostila  <skyostil@chromium.org>
>+
>+        [chromium] Implement layer scrolling in the compositor thread
>+        https://bugs.webkit.org/show_bug.cgi?id=73350
>+
>+        This patch enables scrolling child layers in the compositor thread.
>+        Scroll deltas are accumulated for each scrolled CCLayerImpl and
>+        synchronized to the WebViewImpl in 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.
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * platform/graphics/chromium/LayerChromium.cpp:
>+        (WebCore::LayerChromium::pushPropertiesTo):
>+        * platform/graphics/chromium/LayerChromium.h:
>+        (WebCore::LayerChromium::maxScrollPosition):
>+        (WebCore::LayerChromium::setMaxScrollPosition):
>+        * platform/graphics/chromium/cc/CCLayerImpl.cpp:
>+        (WebCore::CCLayerImpl::CCLayerImpl):
>+        (WebCore::CCLayerImpl::isInsideScrollableRegion):
>+        (WebCore::CCLayerImpl::scrollBy):
>+        * platform/graphics/chromium/cc/CCLayerImpl.h:
>+        (WebCore::CCLayerImpl::pageScaleDelta):
>+        (WebCore::CCLayerImpl::sentScrollDelta):
>+        (WebCore::CCLayerImpl::setSentScrollDelta):
>+        * platform/graphics/chromium/cc/CCLayerTreeHost.cpp:
>+        (WebCore::CCLayerTreeHost::setRootLayer):
>+        (WebCore::findScrollLayer):
>+        (WebCore::CCLayerTreeHost::applyScrollAndScale):
>+        * platform/graphics/chromium/cc/CCLayerTreeHost.h:
>+        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:
>+        (WebCore::CCLayerTreeHostImpl::setRootLayer):
>+        (WebCore::CCLayerTreeHostImpl::adjustScrollsForPageScaleChange):
>+        (WebCore::CCLayerTreeHostImpl::updateMaxScrollPosition):
>+        (WebCore::CCLayerTreeHostImpl::windowToLayerContentPoint):
>+        (WebCore::CCLayerTreeHostImpl::isInsideScrollableRegion):
>+        (WebCore::CCLayerTreeHostImpl::beginScrollingInnermostLayerAtPoint):
>+        (WebCore::CCLayerTreeHostImpl::scrollBegin):
>+        (WebCore::layerCanBeScrolled):
>+        (WebCore::CCLayerTreeHostImpl::scrollBy):
>+        (WebCore::CCLayerTreeHostImpl::pinchGestureBegin):
>+        (WebCore::CCLayerTreeHostImpl::pinchGestureUpdate):
>+        (WebCore::CCLayerTreeHostImpl::pinchGestureEnd):
>+        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.h:
>+
> 2012-01-27  Abhishek Arya  <inferno@chromium.org>
> 
>         Crash in DocumentLoader::detachFromFrame.
>diff --git a/Source/WebKit/chromium/ChangeLog b/Source/WebKit/chromium/ChangeLog
>index 95e214297295cb716a2680940d42876c83021f7a..4c92242aca26d5d13e8a3f6b96a015e6aeab028a 100644
>--- a/Source/WebKit/chromium/ChangeLog
>+++ b/Source/WebKit/chromium/ChangeLog
>@@ -1,3 +1,57 @@
>+2011-12-09  Sami Kyostila  <skyostil@chromium.org>
>+
>+        [chromium] Implement layer scrolling in the compositor thread
>+        https://bugs.webkit.org/show_bug.cgi?id=73350
>+
>+        This patch enables scrolling child layers in the compositor thread.
>+        Scroll deltas are accumulated for each scrolled CCLayerImpl and
>+        synchronized to the WebViewImpl in 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.
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * public/platform/WebLayerTreeViewClient.h:
>+        * src/ChromeClientImpl.cpp:
>+        (WebKit::ChromeClientImpl::addOrUpdateScrollingLayer):
>+        (WebKit::ChromeClientImpl::removeScrollingLayer):
>+        * src/ChromeClientImpl.h:
>+        * src/WebLayerTreeViewImpl.cpp:
>+        (WebKit::WebLayerTreeViewImpl::applyRootLayerScrollAndScale):
>+        (WebKit::WebLayerTreeViewImpl::applyLayerScroll):
>+        * src/WebLayerTreeViewImpl.h:
>+        * src/WebViewImpl.cpp:
>+        (WebKit::WebViewImpl::addOrUpdateScrollingLayer):
>+        (WebKit::WebViewImpl::removeScrollingLayer):
>+        (WebKit::WebViewImpl::applyLayerScroll):
>+        (WebKit::WebViewImpl::applyRootLayerScrollAndScale):
>+        * src/WebViewImpl.h:
>+        * tests/CCLayerImplTest.cpp:
>+        (WebCore::TEST):
>+        * tests/CCLayerTreeHostImplTest.cpp:
>+        (WebKit::TEST_F):
>+        * tests/CCLayerTreeHostTest.cpp:
>+        (WTF::TestHooks::applyRootLayerScrollAndScale):
>+        (WTF::TestHooks::applyLayerScroll):
>+        (WTF::MockLayerTreeHostClient::applyRootLayerScrollAndScale):
>+        (WTF::MockLayerTreeHostClient::applyLayerScroll):
>+        (WTF::CCLayerTreeHostTestScrollSimple::applyRootLayerScrollAndScale):
>+        (WTF::CCLayerTreeHostTestScrollMultipleRedraw::applyRootLayerScrollAndScale):
>+        (WTF::CCLayerTreeHostTestScrollBase::beginTest):
>+        (WTF::CCLayerTreeHostTestScrollBase::applyRootLayerScrollAndScale):
>+        (WTF::CCLayerTreeHostTestScrollBase::applyLayerScroll):
>+        (WTF::CCLayerTreeHostTestScrollBase::afterTest):
>+        (WTF::CCLayerTreeHostTestScrollBase::applyScrollToChildLayer):
>+        (WTF::CCLayerTreeHostTestScrollChildLayer::CCLayerTreeHostTestScrollChildLayer):
>+        (WTF::CCLayerTreeHostTestScrollChildLayer::beginCommitOnCCThread):
>+        (WTF::CCLayerTreeHostTestScrollChildLayer::drawLayersOnCCThread):
>+        (WTF::TEST_F):
>+        (WTF::CCLayerTreeHostTestScrollChildLayerBeyondLimit::CCLayerTreeHostTestScrollChildLayerBeyondLimit):
>+        (WTF::CCLayerTreeHostTestScrollChildLayerBeyondLimit::beginTest):
>+        (WTF::CCLayerTreeHostTestScrollChildLayerBeyondLimit::beginCommitOnCCThread):
>+        (WTF::CCLayerTreeHostTestScrollChildLayerBeyondLimit::drawLayersOnCCThread):
>+
> 2012-01-26  Kent Tamura  <tkent@chromium.org>
> 
>         [Chromium] Cleanup of WebPopupMenuImpl
>diff --git a/Source/WebCore/platform/graphics/chromium/ContentLayerChromium.cpp b/Source/WebCore/platform/graphics/chromium/ContentLayerChromium.cpp
>index 529fce0364a82855aa406397156e0fbb4e3a950e..60236f46bded7089d0267933c04a7038ccfc3047 100644
>--- a/Source/WebCore/platform/graphics/chromium/ContentLayerChromium.cpp
>+++ b/Source/WebCore/platform/graphics/chromium/ContentLayerChromium.cpp
>@@ -142,5 +142,12 @@ void ContentLayerChromium::setOpaque(bool opaque)
>         m_textureUpdater->setOpaque(opaque);
> }
> 
>+void ContentLayerChromium::scrollBy(const IntSize& scrollDelta)
>+{
>+    setScrollPosition(scrollPosition() + scrollDelta);
>+    if (m_delegate)
>+        m_delegate->scrollBy(scrollDelta);
>+}
>+
> }
> #endif // USE(ACCELERATED_COMPOSITING)
>diff --git a/Source/WebCore/platform/graphics/chromium/ContentLayerChromium.h b/Source/WebCore/platform/graphics/chromium/ContentLayerChromium.h
>index 426679cafabb7394c02e7901be332d7bcb5e081a..36fffebdeef207943060d49247e1112a1b0d887c 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 scrollBy(const IntSize&) = 0;
> };
> 
> // A Layer that requires a GraphicsContext to render its contents.
>@@ -63,6 +64,8 @@ public:
> 
>     virtual void setOpaque(bool);
> 
>+    void scrollBy(const IntSize&);
>+
> protected:
>     explicit ContentLayerChromium(ContentLayerDelegate*);
> 
>diff --git a/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.cpp b/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.cpp
>index 31a5118ffd03d18248d07e51e24aeed32afe970e..8a7a639be906902b5e48d9f23f9acb079146a1d0 100644
>--- a/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.cpp
>+++ b/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.cpp
>@@ -53,6 +53,7 @@
> #include "ImageLayerChromium.h"
> #include "LayerChromium.h"
> #include "PlatformString.h"
>+#include "ScrollableArea.h"
> #include "SystemTime.h"
> 
> #include <wtf/CurrentTime.h>
>@@ -70,6 +71,7 @@ PassOwnPtr<GraphicsLayer> GraphicsLayer::create(GraphicsLayerClient* client)
> 
> GraphicsLayerChromium::GraphicsLayerChromium(GraphicsLayerClient* client)
>     : GraphicsLayer(client)
>+    , m_scrollableArea(0)
>     , m_contentsLayerPurpose(NoContentsLayer)
>     , m_contentsLayerHasBackgroundColor(false)
>     , m_inSetChildren(false)
>@@ -676,6 +678,13 @@ void GraphicsLayerChromium::paintContents(GraphicsContext& context, const IntRec
>     paintGraphicsLayerContents(context, clip);
> }
> 
>+void GraphicsLayerChromium::scrollBy(const IntSize& scrollDelta)
>+{
>+    if (!m_scrollableArea)
>+        return;
>+    m_scrollableArea->scrollToOffsetWithoutAnimation(m_scrollableArea->scrollPosition() + scrollDelta);
>+}
>+
> } // namespace WebCore
> 
> #endif // USE(ACCELERATED_COMPOSITING)
>diff --git a/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.h b/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.h
>index 39b367b9d3f0e2f83a320f902b54062fb931e866..41828d3e1cd24850d77a347b1aca3e07675491f9 100644
>--- a/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.h
>+++ b/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.h
>@@ -41,6 +41,7 @@
> namespace WebCore {
> 
> class LayerChromium;
>+class ScrollableArea;
> 
> class GraphicsLayerChromium : public GraphicsLayer, public ContentLayerDelegate {
> public:
>@@ -100,6 +101,10 @@ public:
> 
>     // ContentLayerDelegate implementation.
>     virtual void paintContents(GraphicsContext&, const IntRect& clip);
>+    virtual void scrollBy(const IntSize& scrollDelta);
>+
>+    ScrollableArea* scrollableArea() const { return m_scrollableArea; }
>+    void setScrollableArea(ScrollableArea* scrollableArea) { m_scrollableArea = scrollableArea; }
> 
>     // Exposed for tests.
>     LayerChromium* contentsLayer() const { return m_contentsLayer.get(); }
>@@ -135,6 +140,8 @@ private:
>     RefPtr<LayerChromium> m_transformLayer;
>     RefPtr<LayerChromium> m_contentsLayer;
> 
>+    ScrollableArea* m_scrollableArea;
>+
>     enum ContentsLayerPurpose {
>         NoContentsLayer = 0,
>         ContentsLayerForImage,
>diff --git a/Source/WebCore/platform/graphics/chromium/LayerChromium.cpp b/Source/WebCore/platform/graphics/chromium/LayerChromium.cpp
>index 4a92751f7308224903f04d9575d9027dc81d17aa..e5cedba8a1dc8da9f2ff8e52cbbb0ec4b866d687 100644
>--- a/Source/WebCore/platform/graphics/chromium/LayerChromium.cpp
>+++ b/Source/WebCore/platform/graphics/chromium/LayerChromium.cpp
>@@ -360,6 +360,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)
>@@ -427,6 +435,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);
>     layer->setTransform(m_transform);
>     layer->setUpdateRect(m_updateRect);
>diff --git a/Source/WebCore/platform/graphics/chromium/LayerChromium.h b/Source/WebCore/platform/graphics/chromium/LayerChromium.h
>index 685de0c034b97e0310ecae947e1dd159794b6dd4..1588da6c052fe26604075dea4baefa5f7aca727b 100644
>--- a/Source/WebCore/platform/graphics/chromium/LayerChromium.h
>+++ b/Source/WebCore/platform/graphics/chromium/LayerChromium.h
>@@ -125,6 +125,9 @@ 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; }
> 
>@@ -248,6 +251,7 @@ private:
>     IntSize m_bounds;
>     IntRect m_visibleLayerRect;
>     IntPoint m_scrollPosition;
>+    IntSize m_maxScrollPosition;
>     bool m_scrollable;
>     FloatPoint m_position;
>     FloatPoint m_anchorPoint;
>diff --git a/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.cpp b/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.cpp
>index 86de00d2cae84a19b0e325092303ea3bfecd7dd4..8569473ebcea4cb27d87ddfc3779114be270ca24 100644
>--- a/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.cpp
>+++ b/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.cpp
>@@ -95,6 +95,15 @@ void CCLayerImpl::removeAllChildren()
>         m_children[0]->removeFromParent();
> }
> 
>+bool CCLayerImpl::isLayerInDescendants(int layerId) const
>+{
>+    for (size_t i = 0; i < m_children.size(); ++i) {
>+        if (m_children[i]->id() == layerId || m_children[i]->isLayerInDescendants(layerId))
>+            return true;
>+    }
>+    return false;
>+}
>+
> void CCLayerImpl::clearChildList()
> {
>     m_children.clear();
>@@ -179,9 +188,9 @@ void CCLayerImpl::bindContentsTexture(LayerRendererChromium*)
>     ASSERT_NOT_REACHED();
> }
> 
>-void CCLayerImpl::scrollBy(const IntSize& scroll)
>+void CCLayerImpl::scrollBy(const FloatSize& scroll)
> {
>-    IntSize newDelta = m_scrollDelta + scroll;
>+    FloatSize newDelta = m_scrollDelta + scroll;
>     IntSize minDelta = -toSize(m_scrollPosition);
>     IntSize maxDelta = m_maxScrollPosition - toSize(m_scrollPosition);
>     // Clamp newDelta so that position + delta stays within scroll bounds.
>@@ -488,7 +497,7 @@ void CCLayerImpl::setScrollPosition(const IntPoint& scrollPosition)
>     noteLayerPropertyChangedForSubtree();
> }
> 
>-void CCLayerImpl::setScrollDelta(const IntSize& scrollDelta)
>+void CCLayerImpl::setScrollDelta(const FloatSize& scrollDelta)
> {
>     if (m_scrollDelta == scrollDelta)
>         return;
>diff --git a/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.h b/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.h
>index 00e0adf8a51fdec04a9f425f0457aa3388cea3aa..ef1b07fc1f47224a6de54634665d1a9bd450315b 100644
>--- a/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.h
>+++ b/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.h
>@@ -58,6 +58,7 @@ public:
>     void addChild(PassRefPtr<CCLayerImpl>);
>     void removeFromParent();
>     void removeAllChildren();
>+    bool isLayerInDescendants(int layerId) const;
> 
>     void setMaskLayer(PassRefPtr<CCLayerImpl>);
>     CCLayerImpl* maskLayer() const { return m_maskLayer.get(); }
>@@ -161,16 +162,16 @@ public:
>     const IntSize& maxScrollPosition() const {return m_maxScrollPosition; }
>     void setMaxScrollPosition(const IntSize& maxScrollPosition) { m_maxScrollPosition = maxScrollPosition; }
> 
>-    const IntSize& scrollDelta() const { return m_scrollDelta; }
>-    void setScrollDelta(const IntSize&);
>+    const FloatSize& scrollDelta() const { return m_scrollDelta; }
>+    void setScrollDelta(const FloatSize&);
> 
>     float pageScaleDelta() const { return m_pageScaleDelta; }
>     void setPageScaleDelta(float);
> 
>-    const IntSize& sentScrollDelta() const { return m_sentScrollDelta; }
>-    void setSentScrollDelta(const IntSize& sentScrollDelta) { m_sentScrollDelta = sentScrollDelta; }
>+    const FloatSize& sentScrollDelta() const { return m_sentScrollDelta; }
>+    void setSentScrollDelta(const FloatSize& sentScrollDelta) { m_sentScrollDelta = sentScrollDelta; }
> 
>-    void scrollBy(const IntSize& scroll);
>+    void scrollBy(const FloatSize& scroll);
> 
>     bool scrollable() const { return m_scrollable; }
>     void setScrollable(bool scrollable) { m_scrollable = scrollable; }
>@@ -259,8 +260,8 @@ private:
> 
>     bool m_drawsContent;
> 
>-    IntSize m_scrollDelta;
>-    IntSize m_sentScrollDelta;
>+    FloatSize m_scrollDelta;
>+    FloatSize m_sentScrollDelta;
>     IntSize m_maxScrollPosition;
>     float m_pageScaleDelta;
> 
>diff --git a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp b/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp
>index b9923602bc99ad45d0ab59f13b61cbad8a71a685..e7444a8875de9047656020527637793da06e74ee 100644
>--- a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp
>+++ b/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp
>@@ -479,15 +479,34 @@ 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;
>+}
>+
> void CCLayerTreeHost::applyScrollAndScale(const CCScrollAndScaleSet& info)
> {
>-    // FIXME: pushing scroll offsets to non-root layers not implemented
>-    if (!info.scrolls.size())
>-        return;
>+    if (!info.rootScrollDelta.isZero() || info.pageScaleDelta != 1)
>+        m_client->applyScrollAndScale(info.rootScrollDelta, info.pageScaleDelta);
> 
>-    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 || !layer->scrollable())
>+            continue;
>+        static_cast<ContentLayerChromium*>(layer)->scrollBy(info.scrolls[i].scrollDelta);
>+    }
> }
> 
> void CCLayerTreeHost::startRateLimiter(GraphicsContext3D* context)
>diff --git a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostCommon.h b/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostCommon.h
>index 2e0cbcf2c585e8215d286dee9b61e535180cffad..0d246f53935055a6950486916ac3227ecad45eab 100644
>--- a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostCommon.h
>+++ b/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostCommon.h
>@@ -55,6 +55,7 @@ public:
> 
> struct CCScrollAndScaleSet {
>     Vector<CCLayerTreeHostCommon::ScrollUpdateInfo> scrolls;
>+    IntSize rootScrollDelta;
>     float pageScaleDelta;
> };
> 
>diff --git a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp b/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp
>index 6c2c7426fc0b95001deee8a7094ec9cd8f50c95f..4eee31d7ec12f9760d4cf74ecb909d5eef650b5a 100644
>--- a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp
>+++ b/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp
>@@ -31,6 +31,7 @@
> #include "LayerRendererChromium.h"
> #include "TraceEvent.h"
> #include "cc/CCDamageTracker.h"
>+#include "cc/CCLayerIterator.h"
> #include "cc/CCLayerTreeHost.h"
> #include "cc/CCLayerTreeHostCommon.h"
> #include "cc/CCPageScaleAnimation.h"
>@@ -100,7 +101,7 @@ void CCLayerTreeHostImpl::animate(double frameBeginTimeMs)
>     if (!m_pageScaleAnimation)
>         return;
> 
>-    IntSize scrollTotal = toSize(m_scrollLayerImpl->scrollPosition() + m_scrollLayerImpl->scrollDelta());
>+    IntSize scrollTotal = toSize(m_scrollLayerImpl->scrollPosition() + flooredIntPoint(m_scrollLayerImpl->scrollDelta()));
> 
>     setPageScaleDelta(m_pageScaleAnimation->pageScaleAtTime(frameBeginTimeMs) / m_pageScale);
>     IntSize nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(frameBeginTimeMs);
>@@ -119,7 +120,7 @@ void CCLayerTreeHostImpl::startPageScaleAnimation(const IntSize& targetPosition,
>     if (!m_scrollLayerImpl)
>         return;
> 
>-    IntSize scrollTotal = toSize(m_scrollLayerImpl->scrollPosition() + m_scrollLayerImpl->scrollDelta());
>+    IntSize scrollTotal = toSize(m_scrollLayerImpl->scrollPosition() + flooredIntPoint(m_scrollLayerImpl->scrollDelta()));
>     scrollTotal.scale(m_pageScaleDelta);
>     float scaleTotal = m_pageScale * m_pageScaleDelta;
>     IntSize scaledContentSize = m_scrollLayerImpl->children()[0]->contentBounds();
>@@ -187,9 +188,8 @@ static FloatRect damageInSurfaceSpace(CCLayerImpl* renderSurfaceLayer, const Flo
>     return surfaceDamageRect;
> }
> 
>-void CCLayerTreeHostImpl::calculateRenderPasses(CCRenderPassList& passes)
>+void CCLayerTreeHostImpl::calculateRenderSurfaces(CCLayerList& renderSurfaceLayerList)
> {
>-    CCLayerList renderSurfaceLayerList;
>     renderSurfaceLayerList.append(rootLayer());
> 
>     if (!rootLayer()->renderSurface())
>@@ -199,11 +199,20 @@ void CCLayerTreeHostImpl::calculateRenderPasses(CCRenderPassList& passes)
> 
>     rootLayer()->setClipRect(IntRect(IntPoint(), viewportSize()));
> 
>+    // During testing we may not have an active renderer.
>+    int maxTextureSize = m_layerRenderer ? layerRendererCapabilities().maxTextureSize : 256;
>+
>     {
>         TransformationMatrix identityMatrix;
>         TRACE_EVENT("CCLayerTreeHostImpl::calcDrawEtc", this, 0);
>-        CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(rootLayer(), rootLayer(), identityMatrix, identityMatrix, renderSurfaceLayerList, rootLayer()->renderSurface()->layerList(), &m_layerSorter, layerRendererCapabilities().maxTextureSize);
>+        CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(rootLayer(), rootLayer(), identityMatrix, identityMatrix, renderSurfaceLayerList, rootLayer()->renderSurface()->layerList(), &m_layerSorter, maxTextureSize);
>     }
>+}
>+
>+void CCLayerTreeHostImpl::calculateRenderPasses(CCRenderPassList& passes)
>+{
>+    CCLayerList renderSurfaceLayerList;
>+    calculateRenderSurfaces(renderSurfaceLayerList);
> 
>     if (layerRendererCapabilities().usingPartialSwap)
>         trackDamageForAllSurfaces(rootLayer(), renderSurfaceLayerList);
>@@ -326,9 +335,10 @@ static CCLayerImpl* findScrollLayer(CCLayerImpl* layer)
> void CCLayerTreeHostImpl::setRootLayer(PassRefPtr<CCLayerImpl> layer)
> {
>     m_rootLayerImpl = layer;
>-
>-    // FIXME: Currently, this only finds the first scrollable layer.
>     m_scrollLayerImpl = findScrollLayer(m_rootLayerImpl.get());
>+
>+    if (m_currentlyScrollingLayerImpl && (!m_rootLayerImpl || !m_rootLayerImpl->isLayerInDescendants(m_currentlyScrollingLayerImpl->id())))
>+        m_currentlyScrollingLayerImpl.clear();
> }
> 
> void CCLayerTreeHostImpl::setVisible(bool visible)
>@@ -397,15 +407,13 @@ void CCLayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScale, float min
> 
> void CCLayerTreeHostImpl::adjustScrollsForPageScaleChange(float pageScaleChange)
> {
>-    if (pageScaleChange == 1)
>+    if (!m_scrollLayerImpl || pageScaleChange == 1)
>         return;
> 
>-    // We also need to convert impl-side scroll deltas to pageScale space.
>-    if (m_scrollLayerImpl) {
>-        IntSize scrollDelta = m_scrollLayerImpl->scrollDelta();
>-        scrollDelta.scale(pageScaleChange);
>-        m_scrollLayerImpl->setScrollDelta(scrollDelta);
>-    }
>+    // We also need to convert impl-side scroll delta for the root layer to pageScale space.
>+    FloatSize scrollDelta = m_scrollLayerImpl->scrollDelta();
>+    scrollDelta.scale(pageScaleChange);
>+    m_scrollLayerImpl->setScrollDelta(scrollDelta);
> }
> 
> void CCLayerTreeHostImpl::setPageScaleDelta(float delta)
>@@ -447,9 +455,9 @@ void CCLayerTreeHostImpl::updateMaxScrollPosition()
>     // having a vertical scrollbar but no horizontal overflow.
>     maxScroll.clampNegativeToZero();
> 
>+    // We only need to update the root layer scroll range, since the child
>+    // layers use unscaled scroll coordinates.
>     m_scrollLayerImpl->setMaxScrollPosition(maxScroll);
>-
>-    // TODO(aelias): Also update sublayers.
> }
> 
> void CCLayerTreeHostImpl::setNeedsRedraw()
>@@ -457,28 +465,104 @@ void CCLayerTreeHostImpl::setNeedsRedraw()
>     m_client->setNeedsRedrawOnImplThread();
> }
> 
>-CCInputHandlerClient::ScrollStatus CCLayerTreeHostImpl::scrollBegin(const IntPoint&)
>+bool CCLayerTreeHostImpl::isContentPointWithinLayer(CCLayerImpl* layerImpl, const IntPoint& contentPoint) const
> {
>-    // TODO: Check for scrollable sublayers.
>-    if (!m_scrollLayerImpl || !m_scrollLayerImpl->scrollable())
>-        return ScrollIgnored;
>+    IntRect layerContentRect(layerImpl->visibleLayerRect());
>+    // The visible layer rect is in scaled coordinates, so undo the page scale unless it is the
>+    // non-composited content where the content point is also in scaled coordinates. Note that
>+    // there is no need to undo the page scale delta, because the layer content rect is only
>+    // scaled with the original page scale.
>+    if (!layerImpl->isNonCompositedContent())
>+        layerContentRect.scale(1 / m_pageScale);
>+    return layerContentRect.contains(contentPoint);
>+}
>+
>+CCInputHandlerClient::ScrollStatus CCLayerTreeHostImpl::beginScrollingLayer(CCLayerImpl* layerImpl, const IntPoint& viewportPoint)
>+{
>+    if (!layerImpl)
>+        return CCInputHandlerClient::ScrollFailed;
>+
>+    if (!layerImpl->screenSpaceTransform().isInvertible())
>+        return CCInputHandlerClient::ScrollFailed;
>+
>+    IntPoint contentPoint(layerImpl->screenSpaceTransform().inverse().mapPoint(viewportPoint));
>+    if (layerImpl->drawsContent() && !isContentPointWithinLayer(layerImpl, contentPoint))
>+        return CCInputHandlerClient::ScrollFailed;
>+
>+    if (!layerImpl->scrollable())
>+        return CCInputHandlerClient::ScrollIgnored;
> 
>-    return ScrollStarted;
>+    m_currentlyScrollingLayerImpl = layerImpl;
>+    return CCInputHandlerClient::ScrollStarted;
>+}
>+
>+CCInputHandlerClient::ScrollStatus CCLayerTreeHostImpl::scrollBegin(const IntPoint& viewportPoint)
>+{
>+    m_currentlyScrollingLayerImpl.clear();
>+
>+    if (!rootLayer())
>+        return CCInputHandlerClient::ScrollIgnored;
>+
>+    // Look for a scrollable layer in front to back order.
>+    typedef CCLayerIterator<CCLayerImpl, CCRenderSurface, CCLayerIteratorActions::FrontToBack> CCLayerIteratorType;
>+    CCLayerList renderSurfaceLayerList;
>+    calculateRenderSurfaces(renderSurfaceLayerList);
>+
>+    CCLayerIteratorType end = CCLayerIteratorType::end(&renderSurfaceLayerList);
>+    for (CCLayerIteratorType it = CCLayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) {
>+        CCLayerImpl* layerImpl = *it;
>+        CCInputHandlerClient::ScrollStatus status = beginScrollingLayer(layerImpl, viewportPoint);
>+        if (status != CCInputHandlerClient::ScrollFailed)
>+            return status;
>+    }
>+    return CCInputHandlerClient::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();
>+    IntSize pendingDelta(scrollDelta);
>+    CCLayerImpl* layerImpl = m_currentlyScrollingLayerImpl.get();
>+    while (layerImpl && !pendingDelta.isZero()) {
>+        if (layerImpl->scrollable()) {
>+            FloatSize previousDelta(layerImpl->scrollDelta());
>+            FloatSize scaledPendingDelta(pendingDelta);
>+            // Since scrollDelta is in window coordinates, it already has the page scale applied.
>+            // This matches what the root scroll layer expects, but child layers are scrolled using
>+            // unscaled content coordinates instead, so we have to undo the scaling for them. The
>+            // page scale delta needs to be unapplied with both layer types since the scroll
>+            // coordinates do not respect it.
>+            if (layerImpl == m_scrollLayerImpl) {
>+                scaledPendingDelta.scale(1 / m_pageScaleDelta);
>+                layerImpl->scrollBy(scaledPendingDelta);
>+            } else {
>+                scaledPendingDelta.scale(1 / (m_pageScale * m_pageScaleDelta));
>+                layerImpl->scrollBy(scaledPendingDelta);
>+            }
>+            // 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);
>+        }
>+        layerImpl = layerImpl->parent();
>+    }
>+
>+    if (pendingDelta != scrollDelta) {
>+        m_client->setNeedsCommitOnImplThread();
>+        m_client->setNeedsRedrawOnImplThread();
>+    }
> }
> 
> void CCLayerTreeHostImpl::scrollEnd()
> {
>+    m_currentlyScrollingLayerImpl.clear();
> }
> 
> bool CCLayerTreeHostImpl::haveWheelEventHandlers()
>@@ -521,25 +605,48 @@ void CCLayerTreeHostImpl::pinchGestureEnd()
>     m_client->setNeedsCommitOnImplThread();
> }
> 
>+static bool didScrollSubtree(CCLayerImpl* layerImpl)
>+{
>+    if (!layerImpl->scrollDelta().isZero())
>+        return true;
>+
>+    for (size_t i = 0; i < layerImpl->children().size(); ++i)
>+        if (didScrollSubtree(layerImpl->children()[i].get()))
>+            return true;
>+
>+    return false;
>+}
>+
>+void CCLayerTreeHostImpl::collectScrollDeltas(CCScrollAndScaleSet* scrollInfo, CCLayerImpl* layerImpl) const
>+{
>+    if (!layerImpl->scrollDelta().isZero()) {
>+        IntSize scrollDelta = toSize(flooredIntPoint(layerImpl->scrollDelta()));
>+        if (layerImpl != m_scrollLayerImpl) {
>+            CCLayerTreeHostCommon::ScrollUpdateInfo scroll;
>+            scroll.layerId = layerImpl->id();
>+            scroll.scrollDelta = scrollDelta;
>+            scrollInfo->scrolls.append(scroll);
>+        } else
>+            scrollInfo->rootScrollDelta = scrollDelta;
>+        layerImpl->setSentScrollDelta(layerImpl->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);
>+    bool didMove = m_scrollLayerImpl && (didScrollSubtree(m_scrollLayerImpl.get()) || m_pageScaleDelta != 1);
>     if (!didMove || m_pinchGestureActive || m_pageScaleAnimation) {
>         m_sentPageScaleDelta = scrollInfo->pageScaleDelta = 1;
>         return scrollInfo.release();
>     }
> 
>+    collectScrollDeltas(scrollInfo.get(), m_scrollLayerImpl.get());
>     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 = m_scrollLayerImpl->scrollDelta();
>-    scrollInfo->scrolls.append(scroll);
>-
>-    m_scrollLayerImpl->setSentScrollDelta(scroll.scrollDelta);
>-
>     return scrollInfo.release();
> }
> 
>diff --git a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h b/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h
>index deba6c86b8bc2cfaad44649d22390fdec6f1abe2..c937612902e27b1df7488d10e66faf1ab87b302a 100644
>--- a/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h
>+++ b/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h
>@@ -132,12 +132,17 @@ private:
>     void adjustScrollsForPageScaleChange(float);
>     void updateMaxScrollPosition();
>     void trackDamageForAllSurfaces(CCLayerImpl* rootDrawLayer, const CCLayerList& renderSurfaceLayerList);
>+    void calculateRenderSurfaces(CCLayerList& renderSurfaceLayerList);
>     void calculateRenderPasses(CCRenderPassList&);
>     void optimizeRenderPasses(CCRenderPassList&);
>+    bool isContentPointWithinLayer(CCLayerImpl*, const IntPoint& contentPoint) const;
>+    ScrollStatus beginScrollingLayer(CCLayerImpl*, const IntPoint& viewportPoint);
>+    void collectScrollDeltas(CCScrollAndScaleSet*, CCLayerImpl*) const;
> 
>     OwnPtr<LayerRendererChromium> m_layerRenderer;
>     RefPtr<CCLayerImpl> m_rootLayerImpl;
>     RefPtr<CCLayerImpl> m_scrollLayerImpl;
>+    RefPtr<CCLayerImpl> m_currentlyScrollingLayerImpl;
>     CCSettings m_settings;
>     IntSize m_viewportSize;
>     bool m_visible;
>diff --git a/Source/WebCore/platform/graphics/chromium/cc/CCSingleThreadProxy.cpp b/Source/WebCore/platform/graphics/chromium/cc/CCSingleThreadProxy.cpp
>index 72bec2a71664af43cd64d014d28b84265095b203..a6ca6f702127ec72e96659b0cfc2d7c00bad7697 100644
>--- a/Source/WebCore/platform/graphics/chromium/cc/CCSingleThreadProxy.cpp
>+++ b/Source/WebCore/platform/graphics/chromium/cc/CCSingleThreadProxy.cpp
>@@ -165,6 +165,7 @@ void CCSingleThreadProxy::doCommit()
>         // In the single-threaded case, the scroll deltas should never be
>         // touched on the impl layer tree.
>         OwnPtr<CCScrollAndScaleSet> scrollInfo = m_layerTreeHostImpl->processScrollDeltas();
>+        ASSERT(scrollInfo->rootScrollDelta.isZero());
>         ASSERT(!scrollInfo->scrolls.size());
> #endif
>     }
>diff --git a/Source/WebKit/chromium/src/ChromeClientImpl.cpp b/Source/WebKit/chromium/src/ChromeClientImpl.cpp
>index fb07b4c103fb279a24c4f1678eb5988f32173ba6..92e40f6b34a0d5319f8ea271418ee7147bcd811c 100644
>--- a/Source/WebKit/chromium/src/ChromeClientImpl.cpp
>+++ b/Source/WebKit/chromium/src/ChromeClientImpl.cpp
>@@ -53,6 +53,7 @@
> #include "Geolocation.h"
> #include "GeolocationService.h"
> #include "GraphicsLayer.h"
>+#include "GraphicsLayerChromium.h"
> #include "HTMLNames.h"
> #include "HitTestResult.h"
> #include "Icon.h"
>@@ -868,6 +869,28 @@ bool ChromeClientImpl::paintCustomOverhangArea(GraphicsContext* context, const I
>     return false;
> }
> 
>+void ChromeClientImpl::addOrUpdateScrollingLayer(GraphicsLayer* layer, ScrollableArea* scrollableArea)
>+{
>+    GraphicsLayerChromium* graphicsLayerChromium = static_cast<GraphicsLayerChromium*>(layer);
>+    graphicsLayerChromium->setScrollableArea(scrollableArea);
>+
>+    LayerChromium* layerChromium = layer->platformLayer();
>+    layerChromium->setScrollable(true);
>+    layerChromium->setScrollPosition(scrollableArea->scrollPosition());
>+    layerChromium->setMaxScrollPosition(IntSize(scrollableArea->scrollSize(HorizontalScrollbar), scrollableArea->scrollSize(VerticalScrollbar)));
>+}
>+
>+void ChromeClientImpl::removeScrollingLayer(GraphicsLayer* layer)
>+{
>+    GraphicsLayerChromium* graphicsLayerChromium = static_cast<GraphicsLayerChromium*>(layer);
>+    graphicsLayerChromium->setScrollableArea(0);
>+
>+    LayerChromium* layerChromium = layer->platformLayer();
>+    layerChromium->setScrollable(false);
>+    layerChromium->setScrollPosition(IntPoint());
>+    layerChromium->setMaxScrollPosition(IntSize());
>+}
>+
> // FIXME: Remove ChromeClientImpl::requestGeolocationPermissionForFrame and ChromeClientImpl::cancelGeolocationPermissionRequestForFrame
> // once all ports have moved to client-based geolocation (see https://bugs.webkit.org/show_bug.cgi?id=40373 ).
> // For client-based geolocation, these methods are now implemented as WebGeolocationClient::requestPermission and WebGeolocationClient::cancelPermissionRequest.
>diff --git a/Source/WebKit/chromium/src/ChromeClientImpl.h b/Source/WebKit/chromium/src/ChromeClientImpl.h
>index 8fd2488d9ee6610fe13858b8ec9e5580c7540528..7618520558bacedc8af62d5c7413ce08c6175f9c 100644
>--- a/Source/WebKit/chromium/src/ChromeClientImpl.h
>+++ b/Source/WebKit/chromium/src/ChromeClientImpl.h
>@@ -44,9 +44,11 @@ class ColorChooserClient;
> #endif
> class Element;
> class FileChooser;
>+class GraphicsLayer;
> class PopupContainer;
> class PopupMenuClient;
> class RenderBox;
>+class ScrollableArea;
> class SecurityOrigin;
> struct WindowFeatures;
> }
>@@ -167,6 +169,9 @@ public:
>     virtual void scheduleCompositingLayerSync();
> 
>     virtual CompositingTriggerFlags allowedCompositingTriggers() const;
>+
>+    virtual void addOrUpdateScrollingLayer(WebCore::GraphicsLayer*, WebCore::ScrollableArea*);
>+    virtual void removeScrollingLayer(WebCore::GraphicsLayer*);
> #endif
> 
>     virtual bool supportsFullscreenForNode(const WebCore::Node*);
>diff --git a/Source/WebKit/chromium/src/WebContentLayerImpl.cpp b/Source/WebKit/chromium/src/WebContentLayerImpl.cpp
>index 4f64d5471e396650f7ca75e9e1625c66d72f11b6..349913512e5ad4a3df81652cad78926dc37f5fff 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::scrollBy(const WebCore::IntSize&)
>+{
>+}
>+
> } // namespace WebKit
>diff --git a/Source/WebKit/chromium/src/WebContentLayerImpl.h b/Source/WebKit/chromium/src/WebContentLayerImpl.h
>index 51f344f7caf1271126ac7b4268ed5461214219d8..9d285ae6eef9e4b7619e945a0a0f011d5eb8e4bd 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 scrollBy(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 27728cbef0e3b318793d0ddc10fc37ad60f17d7d..10ec2f4aceb46bc5bf51f3b69380bf13984fc255 100644
>--- a/Source/WebKit/chromium/tests/CCLayerImplTest.cpp
>+++ b/Source/WebKit/chromium/tests/CCLayerImplTest.cpp
>@@ -164,4 +164,22 @@ TEST(CCLayerImplTest, verifyLayerChangesAreTrackedProperly)
>     EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->setMaxScrollPosition(arbitraryIntSize));
> }
> 
>+TEST(CCLayerImplTest, verifyDescendantSearch)
>+{
>+    // The constructor on this will fake that we are on the correct thread.
>+    DebugScopedSetImplThread setImplThread;
>+
>+    RefPtr<CCLayerImpl> root = CCLayerImpl::create(1);
>+    RefPtr<CCLayerImpl> child = CCLayerImpl::create(2);
>+    RefPtr<CCLayerImpl> grandChild = CCLayerImpl::create(3);
>+
>+    root->addChild(child);
>+    child->addChild(grandChild);
>+
>+    EXPECT_FALSE(root->isLayerInDescendants(1));
>+    EXPECT_TRUE(root->isLayerInDescendants(2));
>+    EXPECT_TRUE(root->isLayerInDescendants(3));
>+    EXPECT_FALSE(root->isLayerInDescendants(4));
>+}
>+
> } // namespace
>diff --git a/Source/WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp b/Source/WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp
>index 8683b84b03ca36ffcd84c25db61954f6e2664dc2..7e63cd534c628741618a4cd4c6b57e63e38eb1bf 100644
>--- a/Source/WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp
>+++ b/Source/WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp
>@@ -88,6 +88,17 @@ public:
>         m_hostImpl->setRootLayer(root);
>     }
> 
>+    static PassRefPtr<CCLayerImpl> createScrollableLayer(int id, const FloatPoint& position, const IntSize& size)
>+    {
>+        RefPtr<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;
>+    }
>+
> protected:
>     DebugScopedSetImplThread m_alwaysImplThread;
>     OwnPtr<CCLayerTreeHostImpl> m_hostImpl;
>@@ -140,16 +151,16 @@ TEST_F(CCLayerTreeHostImplTest, scrollDeltaRepeatedScrolls)
>     OwnPtr<CCScrollAndScaleSet> scrollInfo;
> 
>     scrollInfo = m_hostImpl->processScrollDeltas();
>-    ASSERT_EQ(scrollInfo->scrolls.size(), 1u);
>+    ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
>     EXPECT_EQ(root->sentScrollDelta(), scrollDelta);
>-    expectContains(*scrollInfo.get(), root->id(), scrollDelta);
>+    ASSERT_EQ(scrollInfo->rootScrollDelta, scrollDelta);
> 
>     IntSize scrollDelta2(-5, 27);
>     root->scrollBy(scrollDelta2);
>     scrollInfo = m_hostImpl->processScrollDeltas();
>-    ASSERT_EQ(scrollInfo->scrolls.size(), 1u);
>+    ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
>     EXPECT_EQ(root->sentScrollDelta(), scrollDelta + scrollDelta2);
>-    expectContains(*scrollInfo.get(), root->id(), scrollDelta + scrollDelta2);
>+    ASSERT_EQ(scrollInfo->rootScrollDelta, scrollDelta + scrollDelta2);
> 
>     root->scrollBy(IntSize());
>     scrollInfo = m_hostImpl->processScrollDeltas();
>@@ -225,7 +236,7 @@ TEST_F(CCLayerTreeHostImplTest, pinchGesture)
>         EXPECT_EQ(scrollInfo->pageScaleDelta, minPageScale);
> 
>         // Pushed to (0,0) via clamping against contents layer size.
>-        expectContains(*scrollInfo.get(), scrollLayer->id(), IntSize(-50, -50));
>+        EXPECT_EQ(scrollInfo->rootScrollDelta, IntSize(-50, -50));
>     }
> }
> 
>@@ -255,7 +266,7 @@ TEST_F(CCLayerTreeHostImplTest, pageScaleAnimation)
> 
>         OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
>         EXPECT_EQ(scrollInfo->pageScaleDelta, 2);
>-        expectContains(*scrollInfo.get(), scrollLayer->id(), IntSize(-50, -50));
>+        EXPECT_EQ(scrollInfo->rootScrollDelta, IntSize(-50, -50));
>     }
> 
>     // Anchor zoom-out
>@@ -272,10 +283,135 @@ TEST_F(CCLayerTreeHostImplTest, pageScaleAnimation)
>         OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
>         EXPECT_EQ(scrollInfo->pageScaleDelta, minPageScale);
>         // Pushed to (0,0) via clamping against contents layer size.
>-        expectContains(*scrollInfo.get(), scrollLayer->id(), IntSize(-50, -50));
>+        EXPECT_EQ(scrollInfo->rootScrollDelta, IntSize(-50, -50));
>     }
> }
> 
>+TEST_F(CCLayerTreeHostImplTest, scrollRootIgnored)
>+{
>+    RefPtr<CCLayerImpl> root = CCLayerImpl::create(0);
>+    root->setScrollable(false);
>+    m_hostImpl->setRootLayer(root);
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0)), CCInputHandlerClient::ScrollIgnored);
>+    EXPECT_FALSE(m_didRequestRedraw);
>+    EXPECT_FALSE(m_didRequestCommit);
>+}
>+
>+TEST_F(CCLayerTreeHostImplTest, scrollChildCallsCommitAndRedraw)
>+{
>+    IntSize surfaceSize(10, 10);
>+    RefPtr<CCLayerImpl> root = CCLayerImpl::create(0);
>+    root->addChild(createScrollableLayer(1, FloatPoint(5, 5), surfaceSize));
>+    m_hostImpl->setRootLayer(root);
>+    m_hostImpl->setViewportSize(surfaceSize);
>+
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5)), 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);
>+    RefPtr<CCLayerImpl> root = CCLayerImpl::create(0);
>+    root->addChild(createScrollableLayer(1, FloatPoint(5, 5), surfaceSize));
>+    m_hostImpl->setRootLayer(root);
>+    m_hostImpl->setViewportSize(surfaceSize);
>+
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(15, 5)), CCInputHandlerClient::ScrollIgnored);
>+    EXPECT_FALSE(m_didRequestRedraw);
>+    EXPECT_FALSE(m_didRequestCommit);
>+}
>+
>+TEST_F(CCLayerTreeHostImplTest, scrollMissesBackfacingChild)
>+{
>+    IntSize surfaceSize(10, 10);
>+    RefPtr<CCLayerImpl> root = CCLayerImpl::create(0);
>+    RefPtr<CCLayerImpl> child = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
>+    root->addChild(child);
>+    m_hostImpl->setRootLayer(root);
>+    m_hostImpl->setViewportSize(surfaceSize);
>+
>+    TransformationMatrix matrix;
>+    matrix.rotate3d(180, 0, 0);
>+    child->setTransform(matrix);
>+    child->setDoubleSided(false);
>+
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5)), CCInputHandlerClient::ScrollIgnored);
>+    EXPECT_FALSE(m_didRequestRedraw);
>+    EXPECT_FALSE(m_didRequestCommit);
>+}
>+
>+TEST_F(CCLayerTreeHostImplTest, scrollRootAndChangePageScale)
>+{
>+    IntSize surfaceSize(10, 10);
>+    RefPtr<CCLayerImpl> root = CCLayerImpl::create(0);
>+    root->setScrollable(true);
>+    root->setMaxScrollPosition(IntSize(100, 100));
>+    m_hostImpl->setRootLayer(root);
>+    m_hostImpl->setViewportSize(surfaceSize);
>+
>+    IntSize scrollDelta(0, 10);
>+    int pageScale = 2;
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5)), CCInputHandlerClient::ScrollStarted);
>+    m_hostImpl->scrollBy(scrollDelta);
>+    m_hostImpl->setPageScaleFactorAndLimits(pageScale, 1, pageScale);
>+
>+    // The scale should apply to the root scroll delta.
>+    OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
>+    EXPECT_EQ(scrollInfo->rootScrollDelta, IntSize(scrollDelta.width() * pageScale, scrollDelta.height() * pageScale));
>+}
>+
>+TEST_F(CCLayerTreeHostImplTest, scrollChildAndChangePageScale)
>+{
>+    IntSize surfaceSize(10, 10);
>+    RefPtr<CCLayerImpl> root = CCLayerImpl::create(0);
>+    RefPtr<CCLayerImpl> rootScroll = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
>+    RefPtr<CCLayerImpl> child = createScrollableLayer(2, FloatPoint(5, 5), surfaceSize);
>+    root->addChild(rootScroll);
>+    rootScroll->addChild(child);
>+    m_hostImpl->setRootLayer(root);
>+    m_hostImpl->setViewportSize(surfaceSize);
>+
>+    IntSize scrollDelta(0, 10);
>+    int pageScale = 2;
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5)), CCInputHandlerClient::ScrollStarted);
>+    m_hostImpl->scrollBy(scrollDelta);
>+    m_hostImpl->setPageScaleFactorAndLimits(pageScale, 1, pageScale);
>+
>+    // The scale should not apply to the child scroll delta.
>+    OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
>+    expectContains(*scrollInfo.get(), child->id(), scrollDelta);
>+}
>+
>+TEST_F(CCLayerTreeHostImplTest, scrollScaledLayer)
>+{
>+    IntSize surfaceSize(10, 10);
>+    RefPtr<CCLayerImpl> root = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
>+    m_hostImpl->setRootLayer(root);
>+    m_hostImpl->setViewportSize(surfaceSize);
>+
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(15, 15)), CCInputHandlerClient::ScrollIgnored);
>+    m_hostImpl->setPageScaleFactorAndLimits(0.5, 0.5, 0.5);
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(15, 15)), CCInputHandlerClient::ScrollStarted);
>+}
>+
>+TEST_F(CCLayerTreeHostImplTest, scrollScaledNonCompositedLayer)
>+{
>+    IntSize surfaceSize(10, 10);
>+    RefPtr<CCLayerImpl> root = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
>+    root->setIsNonCompositedContent(true);
>+    m_hostImpl->setRootLayer(root);
>+    m_hostImpl->setViewportSize(surfaceSize);
>+
>+    // The page scale should not be removed from non-composited layer bounds.
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(15, 15)), CCInputHandlerClient::ScrollIgnored);
>+    m_hostImpl->setPageScaleFactorAndLimits(0.5, 0.5, 0.5);
>+    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(15, 15)), CCInputHandlerClient::ScrollIgnored);
>+}
>+
> 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 0cb2605e8a6d3d322fceb0fc73aa7afe69492090..e35f156f31423595c63a589f9ab6120320c94881 100644
>--- a/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp
>+++ b/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp
>@@ -989,6 +989,7 @@ public:
>     }
> 
>     virtual bool preserves3D() { return false; }
>+    virtual void scrollBy(const IntSize&) { }
> 
> private:
>     CCLayerTreeHostTest* m_test;
>@@ -1135,7 +1136,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 scrollBy(const IntSize&) { }
>     void notifySyncRequired() { }
> };
> 
>@@ -1228,4 +1230,123 @@ TEST_F(CCLayerTreeHostTestAtomicCommit, runMultiThread)
>     runTest(true);
> }
> 
>+class CCLayerTreeHostTestScrollBase : public CCLayerTreeHostTest {
>+public:
>+    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 afterTest()
>+    {
>+    }
>+
>+protected:
>+    MockContentLayerDelegate m_mockDelegate;
>+    RefPtr<LayerChromium> m_childLayer;
>+    RefPtr<LayerChromium> m_rootScrollLayer;
>+};
>+
>+class CCLayerTreeHostTestScrollChildLayer : public CCLayerTreeHostTestScrollBase {
>+public:
>+    CCLayerTreeHostTestScrollChildLayer()
>+        : m_scrollAmount(2, 1)
>+    {
>+    }
>+
>+    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::ScrollStarted);
>+            impl->scrollBy(m_scrollAmount);
>+            impl->scrollEnd();
>+        } else if (impl->frameNumber() == 2)
>+            endTest();
>+    }
>+private:
>+    const IntSize m_scrollAmount;
>+};
>+
>+TEST_F(CCLayerTreeHostTestScrollChildLayer, runMultiThread)
>+{
>+    runTest(true);
>+}
>+
>+class CCLayerTreeHostTestScrollChildLayerBeyondLimit : public CCLayerTreeHostTestScrollBase {
>+public:
>+    CCLayerTreeHostTestScrollChildLayerBeyondLimit()
>+        : m_initialRootScrollPosition(3, 6)
>+        , m_initialChildScrollPosition(20, 0)
>+        , m_scrollAmount(-25, -5)
>+    {
>+    }
>+
>+    virtual void beginTest()
>+    {
>+        CCLayerTreeHostTestScrollBase::beginTest();
>+        m_rootScrollLayer->setScrollPosition(m_initialRootScrollPosition);
>+        m_childLayer->setScrollPosition(m_initialChildScrollPosition);
>+    }
>+
>+    virtual void beginCommitOnCCThread(CCLayerTreeHostImpl* impl)
>+    {
>+        if (m_layerTreeHost->frameNumber() == 1) {
>+            CCLayerImpl* root = impl->rootLayer();
>+            CCLayerImpl* scrollRoot = root->children()[0].get();
>+            CCLayerImpl* child = scrollRoot->children()[0].get();
>+            EXPECT_EQ(child->scrollPosition(), m_initialChildScrollPosition);
>+            EXPECT_EQ(child->scrollDelta(), IntSize(-20, 0));
>+            EXPECT_EQ(scrollRoot->scrollPosition(), m_initialRootScrollPosition);
>+            EXPECT_EQ(scrollRoot->scrollDelta(), IntSize(0, -5));
>+        }
>+    }
>+
>+    virtual void drawLayersOnCCThread(CCLayerTreeHostImpl* impl)
>+    {
>+        if (impl->frameNumber() == 1) {
>+            EXPECT_EQ(impl->scrollBegin(IntPoint(5, 5)), CCInputHandlerClient::ScrollStarted);
>+            impl->scrollBy(m_scrollAmount);
>+            impl->scrollEnd();
>+        } else if (impl->frameNumber() == 2)
>+            endTest();
>+    }
>+private:
>+    const IntPoint m_initialRootScrollPosition;
>+    const IntPoint m_initialChildScrollPosition;
>+    const IntSize m_scrollAmount;
>+};
>+
>+TEST_F(CCLayerTreeHostTestScrollChildLayerBeyondLimit, 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