Changeset 116142 in webkit


Ignore:
Timestamp:
May 4, 2012 12:25:58 PM (12 years ago)
Author:
commit-queue@webkit.org
Message:

[chromium] Revert compositor layer scrolling
​https://bugs.webkit.org/show_bug.cgi?id=85644

Patch by Sami Kyostila <​skyostil@chromium.org> on 2012-05-04
Reviewed by Steve Block.

Source/WebCore:

This patch reverts the following commits because they were found to
trigger crashes. See discussion at ​http://code.google.com/p/chromium/issues/detail?id=124393.

[chromium] Allow scrolling non-root layers in the compositor thread
​http://trac.webkit.org/changeset/114651

[chromium] Don't crash when scrolling empty layer tree
​http://trac.webkit.org/changeset/114761

[chromium] Don't keep pointers to released layer tree
​http://trac.webkit.org/changeset/115080

  • platform/graphics/chromium/ContentLayerChromium.cpp:
  • platform/graphics/chromium/ContentLayerChromium.h:

(ContentLayerChromium):

  • platform/graphics/chromium/GraphicsLayerChromium.h:

(GraphicsLayerChromium):

  • platform/graphics/chromium/LayerChromium.cpp:

(WebCore::LayerChromium::pushPropertiesTo):

  • platform/graphics/chromium/LayerChromium.h:

(LayerChromium):

  • platform/graphics/chromium/cc/CCLayerImpl.cpp:
  • platform/graphics/chromium/cc/CCLayerImpl.h:
  • platform/graphics/chromium/cc/CCLayerTreeHost.cpp:

(WebCore::CCLayerTreeHost::applyScrollAndScale):

  • platform/graphics/chromium/cc/CCLayerTreeHostCommon.h:

(CCLayerTreeHostCommon):

  • platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:

(WebCore::CCLayerTreeHostImpl::CCLayerTreeHostImpl):
(WebCore::CCLayerTreeHostImpl::startPageScaleAnimation):
(WebCore::CCLayerTreeHostImpl::calculateRenderSurfaceLayerList):
(WebCore::CCLayerTreeHostImpl::contentSize):
(WebCore::CCLayerTreeHostImpl::prepareToDraw):
(WebCore::findScrollLayer):
(WebCore::CCLayerTreeHostImpl::setRootLayer):
(WebCore::CCLayerTreeHostImpl::setPageScaleFactorAndLimits):
(WebCore):
(WebCore::CCLayerTreeHostImpl::adjustScrollsForPageScaleChange):
(WebCore::CCLayerTreeHostImpl::setPageScaleDelta):
(WebCore::CCLayerTreeHostImpl::applyPageScaleDeltaToScrollLayer):
(WebCore::CCLayerTreeHostImpl::updateMaxScrollPosition):
(WebCore::CCLayerTreeHostImpl::scrollBegin):
(WebCore::CCLayerTreeHostImpl::scrollBy):
(WebCore::CCLayerTreeHostImpl::scrollEnd):
(WebCore::CCLayerTreeHostImpl::pinchGestureUpdate):
(WebCore::CCLayerTreeHostImpl::computePinchZoomDeltas):
(WebCore::CCLayerTreeHostImpl::makeScrollAndScaleSet):
(WebCore::CCLayerTreeHostImpl::processScrollDeltas):
(WebCore::CCLayerTreeHostImpl::animatePageScale):

  • platform/graphics/chromium/cc/CCLayerTreeHostImpl.h:

(WebCore::CCLayerTreeHostImpl::releaseRootLayer):
(WebCore::CCLayerTreeHostImpl::scrollLayer):
(CCLayerTreeHostImpl):

Source/WebKit/chromium:

  • src/WebContentLayerImpl.cpp:
  • src/WebContentLayerImpl.h:

(WebContentLayerImpl):

  • tests/CCLayerTreeHostCommonTest.cpp:
  • tests/CCLayerTreeHostImplTest.cpp:

(WebKitTests::TEST_F):

  • tests/CCLayerTreeHostTest.cpp:

(WTF::MockContentLayerDelegate::paintContents):

Location:
trunk/Source
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r116131 r116142  
     12012-05-04  Sami Kyostila  <skyostil@chromium.org>
     2
     3        [chromium] Revert compositor layer scrolling
     4        https://bugs.webkit.org/show_bug.cgi?id=85644
     5
     6        Reviewed by Steve Block.
     7
     8        This patch reverts the following commits because they were found to
     9        trigger crashes. See discussion at http://code.google.com/p/chromium/issues/detail?id=124393.
     10
     11            [chromium] Allow scrolling non-root layers in the compositor thread
     12            http://trac.webkit.org/changeset/114651
     13
     14            [chromium] Don't crash when scrolling empty layer tree
     15            http://trac.webkit.org/changeset/114761
     16
     17            [chromium] Don't keep pointers to released layer tree
     18            http://trac.webkit.org/changeset/115080
     19
     20        * platform/graphics/chromium/ContentLayerChromium.cpp:
     21        * platform/graphics/chromium/ContentLayerChromium.h:
     22        (ContentLayerChromium):
     23        * platform/graphics/chromium/GraphicsLayerChromium.h:
     24        (GraphicsLayerChromium):
     25        * platform/graphics/chromium/LayerChromium.cpp:
     26        (WebCore::LayerChromium::pushPropertiesTo):
     27        * platform/graphics/chromium/LayerChromium.h:
     28        (LayerChromium):
     29        * platform/graphics/chromium/cc/CCLayerImpl.cpp:
     30        * platform/graphics/chromium/cc/CCLayerImpl.h:
     31        * platform/graphics/chromium/cc/CCLayerTreeHost.cpp:
     32        (WebCore::CCLayerTreeHost::applyScrollAndScale):
     33        * platform/graphics/chromium/cc/CCLayerTreeHostCommon.h:
     34        (CCLayerTreeHostCommon):
     35        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:
     36        (WebCore::CCLayerTreeHostImpl::CCLayerTreeHostImpl):
     37        (WebCore::CCLayerTreeHostImpl::startPageScaleAnimation):
     38        (WebCore::CCLayerTreeHostImpl::calculateRenderSurfaceLayerList):
     39        (WebCore::CCLayerTreeHostImpl::contentSize):
     40        (WebCore::CCLayerTreeHostImpl::prepareToDraw):
     41        (WebCore::findScrollLayer):
     42        (WebCore::CCLayerTreeHostImpl::setRootLayer):
     43        (WebCore::CCLayerTreeHostImpl::setPageScaleFactorAndLimits):
     44        (WebCore):
     45        (WebCore::CCLayerTreeHostImpl::adjustScrollsForPageScaleChange):
     46        (WebCore::CCLayerTreeHostImpl::setPageScaleDelta):
     47        (WebCore::CCLayerTreeHostImpl::applyPageScaleDeltaToScrollLayer):
     48        (WebCore::CCLayerTreeHostImpl::updateMaxScrollPosition):
     49        (WebCore::CCLayerTreeHostImpl::scrollBegin):
     50        (WebCore::CCLayerTreeHostImpl::scrollBy):
     51        (WebCore::CCLayerTreeHostImpl::scrollEnd):
     52        (WebCore::CCLayerTreeHostImpl::pinchGestureUpdate):
     53        (WebCore::CCLayerTreeHostImpl::computePinchZoomDeltas):
     54        (WebCore::CCLayerTreeHostImpl::makeScrollAndScaleSet):
     55        (WebCore::CCLayerTreeHostImpl::processScrollDeltas):
     56        (WebCore::CCLayerTreeHostImpl::animatePageScale):
     57        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.h:
     58        (WebCore::CCLayerTreeHostImpl::releaseRootLayer):
     59        (WebCore::CCLayerTreeHostImpl::scrollLayer):
     60        (CCLayerTreeHostImpl):
     61
    1622012-05-04  Ojan Vafai  <ojan@chromium.org>
    263

  • trunk/Source/WebCore/platform/graphics/chromium/ContentLayerChromium.cpp

    r114651 r116142  
    146146}
    147147
    148 void ContentLayerChromium::scrollBy(const IntSize& scrollDelta)
    149 {
    150     setScrollPosition(scrollPosition() + scrollDelta);
    151     if (m_delegate)
    152         m_delegate->didScroll(scrollDelta);
    153 }
    154 
    155148}
    156149#endif // USE(ACCELERATED_COMPOSITING)

  • trunk/Source/WebCore/platform/graphics/chromium/ContentLayerChromium.h

    r114651 r116142  
    4747    virtual ~ContentLayerDelegate() { }
    4848    virtual void paintContents(GraphicsContext&, const IntRect& clip) = 0;
    49     virtual void didScroll(const IntSize&) = 0;
    5049};
    5150
    … …  
    6564    virtual void setOpaque(bool) OVERRIDE;
    6665
    67     virtual void scrollBy(const IntSize&) OVERRIDE;
    68 
    6966protected:
    7067    explicit ContentLayerChromium(ContentLayerDelegate*);

  • trunk/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.h

    r115519 r116142  
    114114    // ContentLayerDelegate implementation.
    115115    virtual void paintContents(GraphicsContext&, const IntRect& clip);
    116     virtual void didScroll(const IntSize&) OVERRIDE { }
    117116
    118117    // CCLayerAnimationDelegate implementation.

  • trunk/Source/WebCore/platform/graphics/chromium/LayerChromium.cpp

    r115519 r116142  
    382382}
    383383
    384 void LayerChromium::setMaxScrollPosition(const IntSize& maxScrollPosition)
    385 {
    386     if (m_maxScrollPosition == maxScrollPosition)
    387         return;
    388     m_maxScrollPosition = maxScrollPosition;
    389     setNeedsCommit();
    390 }
    391 
    392384void LayerChromium::setScrollable(bool scrollable)
    393385{
    … …  
    510502    layer->setPreserves3D(preserves3D());
    511503    layer->setScrollPosition(m_scrollPosition);
    512     layer->setMaxScrollPosition(m_maxScrollPosition);
    513504    layer->setSublayerTransform(m_sublayerTransform);
    514505    if (!transformIsAnimating())

  • trunk/Source/WebCore/platform/graphics/chromium/LayerChromium.h

    r115519 r116142  
    142142    const IntPoint& scrollPosition() const { return m_scrollPosition; }
    143143
    144     void setMaxScrollPosition(const IntSize&);
    145     const IntSize& maxScrollPosition() const { return m_maxScrollPosition; }
    146 
    147144    void setScrollable(bool);
    148     bool scrollable() const { return m_scrollable; }
    149145    void setShouldScrollOnMainThread(bool);
    150146    void setHaveWheelEventHandlers(bool);
    … …  
    152148    void setNonFastScrollableRegion(const Region&);
    153149    void setNonFastScrollableRegionChanged() { m_nonFastScrollableRegionChanged = true; }
    154     virtual void scrollBy(const IntSize&) { }
    155150
    156151    void setDrawCheckerboardForMissingTiles(bool);
    … …  
    308303    IntRect m_visibleLayerRect;
    309304    IntPoint m_scrollPosition;
    310     IntSize m_maxScrollPosition;
    311305    bool m_scrollable;
    312306    bool m_shouldScrollOnMainThread;

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.cpp

    r115278 r116142  
    184184}
    185185
    186 CCInputHandlerClient::ScrollStatus CCLayerImpl::tryScroll(const IntPoint& viewportPoint, CCInputHandlerClient::ScrollInputType type) const
    187 {
    188     if (shouldScrollOnMainThread()) {
    189         TRACE_EVENT("tryScroll Failed shouldScrollOnMainThread", this, 0);
    190         return CCInputHandlerClient::ScrollFailed;
    191     }
    192 
    193     if (!screenSpaceTransform().isInvertible()) {
    194         TRACE_EVENT("tryScroll Failed nonInvertibleTransform", this, 0);
    195         return CCInputHandlerClient::ScrollIgnored;
    196     }
    197 
    198     IntPoint contentPoint(screenSpaceTransform().inverse().mapPoint(viewportPoint));
    199     if (nonFastScrollableRegion().contains(contentPoint)) {
    200         TRACE_EVENT("tryScroll Failed nonFastScrollableRegion", this, 0);
    201         return CCInputHandlerClient::ScrollFailed;
    202     }
    203 
    204     if (type == CCInputHandlerClient::Wheel && haveWheelEventHandlers()) {
    205         TRACE_EVENT("tryScroll Failed wheelEventHandlers", this, 0);
    206         return CCInputHandlerClient::ScrollFailed;
    207     }
    208 
    209     if (!scrollable()) {
    210         TRACE_EVENT("tryScroll Ignored not scrollable", this, 0);
    211         return CCInputHandlerClient::ScrollIgnored;
    212     }
    213 
    214     return CCInputHandlerClient::ScrollStarted;
    215 }
    216 
    217186const IntRect CCLayerImpl::getDrawRect() const
    218187{

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.h

    r115405 r116142  
    3434#include "TextStream.h"
    3535#include "TransformationMatrix.h"
    36 #include "cc/CCInputHandler.h"
    3736#include "cc/CCLayerAnimationController.h"
    3837#include "cc/CCRenderSurface.h"
    … …  
    201200    void setDrawCheckerboardForMissingTiles(bool checkerboard) { m_drawCheckerboardForMissingTiles = checkerboard; }
    202201    bool drawCheckerboardForMissingTiles() const { return m_drawCheckerboardForMissingTiles; }
    203 
    204     CCInputHandlerClient::ScrollStatus tryScroll(const IntPoint& viewportPoint, CCInputHandlerClient::ScrollInputType) const;
    205202
    206203    const IntRect& visibleLayerRect() const { return m_visibleLayerRect; }

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp

    r115944 r116142  
    589589}
    590590
    591 static LayerChromium* findFirstScrollableLayer(LayerChromium* layer)
    592 {
    593     if (!layer)
    594         return 0;
    595 
    596     if (layer->scrollable())
    597         return layer;
    598 
    599     for (size_t i = 0; i < layer->children().size(); ++i) {
    600         LayerChromium* found = findFirstScrollableLayer(layer->children()[i].get());
    601         if (found)
    602             return found;
    603     }
    604 
    605     return 0;
    606 }
    607 
    608591void CCLayerTreeHost::applyScrollAndScale(const CCScrollAndScaleSet& info)
    609592{
    610     if (!m_rootLayer)
    611         return;
    612 
    613     LayerChromium* rootScrollLayer = findFirstScrollableLayer(m_rootLayer.get());
    614     IntSize rootScrollDelta;
    615 
    616     for (size_t i = 0; i < info.scrolls.size(); ++i) {
    617         LayerChromium* layer = CCLayerTreeHostCommon::findLayerInSubtree(m_rootLayer.get(), info.scrolls[i].layerId);
    618         if (!layer)
    619             continue;
    620         if (layer == rootScrollLayer)
    621             rootScrollDelta += info.scrolls[i].scrollDelta;
    622         else
    623             layer->scrollBy(info.scrolls[i].scrollDelta);
    624     }
    625     if (!rootScrollDelta.isZero() || info.pageScaleDelta != 1)
    626         m_client->applyScrollAndScale(rootScrollDelta, info.pageScaleDelta);
     593    // FIXME: pushing scroll offsets to non-root layers not implemented
     594    if (!info.scrolls.size())
     595        return;
     596
     597    ASSERT(info.scrolls.size() == 1);
     598    IntSize scrollDelta = info.scrolls[0].scrollDelta;
     599    m_client->applyScrollAndScale(scrollDelta, info.pageScaleDelta);
    627600}
    628601

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostCommon.h

    r114651 r116142  
    4747    template<typename LayerType> static bool renderSurfaceContributesToTarget(LayerType*, int targetSurfaceLayerID);
    4848
    49     // Returns a layer with the given id if one exists in the subtree starting
    50     // from the given root layer (including mask and replica layers).
    51     template<typename LayerType> static LayerType* findLayerInSubtree(LayerType* rootLayer, int layerId);
    52 
    5349    struct ScrollUpdateInfo {
    5450        int layerId;
    … …  
    7672}
    7773
    78 template<typename LayerType>
    79 LayerType* CCLayerTreeHostCommon::findLayerInSubtree(LayerType* rootLayer, int layerId)
    80 {
    81     if (rootLayer->id() == layerId)
    82         return rootLayer;
    83 
    84     if (rootLayer->maskLayer() && rootLayer->maskLayer()->id() == layerId)
    85         return rootLayer->maskLayer();
    86 
    87     if (rootLayer->replicaLayer() && rootLayer->replicaLayer()->id() == layerId)
    88         return rootLayer->replicaLayer();
    89 
    90     for (size_t i = 0; i < rootLayer->children().size(); ++i) {
    91         if (LayerType* found = findLayerInSubtree(rootLayer->children()[i].get(), layerId))
    92             return found;
    93     }
    94     return 0;
    95 }
    96 
    9774} // namespace WebCore
    9875

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp

    r115944 r116142  
    109109    , m_sourceFrameNumber(-1)
    110110    , m_frameNumber(0)
    111     , m_rootScrollLayerImpl(0)
    112     , m_currentlyScrollingLayerImpl(0)
    113     , m_scrollingLayerIdFromPreviousTree(-1)
     111    , m_scrollLayerImpl(0)
    114112    , m_settings(settings)
    115113    , m_visible(true)
    … …  
    173171void CCLayerTreeHostImpl::startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, double startTime, double duration)
    174172{
    175     if (!m_rootScrollLayerImpl)
    176         return;
    177 
    178     IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
     173    if (!m_scrollLayerImpl)
     174        return;
     175
     176    IntSize scrollTotal = flooredIntSize(m_scrollLayerImpl->scrollPosition() + m_scrollLayerImpl->scrollDelta());
    179177    scrollTotal.scale(m_pageScaleDelta);
    180178    float scaleTotal = m_pageScale * m_pageScaleDelta;
    … …  
    246244{
    247245    ASSERT(renderSurfaceLayerList.isEmpty());
    248     ASSERT(m_rootLayerImpl);
    249246
    250247    renderSurfaceLayerList.append(m_rootLayerImpl.get());
    … …  
    374371    // TODO(aelias): Hardcoding the first child here is weird. Think of
    375372    // a cleaner way to get the contentBounds on the Impl side.
    376     if (!m_rootScrollLayerImpl || m_rootScrollLayerImpl->children().isEmpty())
     373    if (!m_scrollLayerImpl || m_scrollLayerImpl->children().isEmpty())
    377374        return IntSize();
    378     return m_rootScrollLayerImpl->children()[0]->contentBounds();
     375    return m_scrollLayerImpl->children()[0]->contentBounds();
    379376}
    380377
    … …  
    385382    frame.renderPasses.clear();
    386383    frame.renderSurfaceLayerList.clear();
    387     m_mostRecentRenderSurfaceLayerList.clear();
    388384
    389385    if (!m_rootLayerImpl)
    … …  
    396392    }
    397393
    398     m_mostRecentRenderSurfaceLayerList = frame.renderSurfaceLayerList;
    399 
    400394    // If we return true, then we expect drawLayers() to be called before this function is called again.
    401395    return true;
    … …  
    495489}
    496490
    497 static CCLayerImpl* findRootScrollLayer(CCLayerImpl* layer)
     491static CCLayerImpl* findScrollLayer(CCLayerImpl* layer)
    498492{
    499493    if (!layer)
    … …  
    504498
    505499    for (size_t i = 0; i < layer->children().size(); ++i) {
    506         CCLayerImpl* found = findRootScrollLayer(layer->children()[i].get());
     500        CCLayerImpl* found = findScrollLayer(layer->children()[i].get());
    507501        if (found)
    508502            return found;
    … …  
    512506}
    513507
    514 // Content layers can be either directly scrollable or contained in an outer
    515 // scrolling layer which applies the scroll transform. Given a content layer,
    516 // this function returns the associated scroll layer if any.
    517 static CCLayerImpl* findScrollLayerForContentLayer(CCLayerImpl* layerImpl)
    518 {
    519     if (!layerImpl)
    520         return 0;
    521 
    522     if (layerImpl->scrollable())
    523         return layerImpl;
    524 
    525     if (layerImpl->drawsContent() && layerImpl->parent() && layerImpl->parent()->scrollable())
    526         return layerImpl->parent();
    527 
    528     return 0;
    529 }
    530 
    531508void CCLayerTreeHostImpl::setRootLayer(PassOwnPtr<CCLayerImpl> layer)
    532509{
    533510    m_rootLayerImpl = layer;
    534     m_rootScrollLayerImpl = findRootScrollLayer(m_rootLayerImpl.get());
    535     m_currentlyScrollingLayerImpl = 0;
    536 
    537     if (m_rootLayerImpl && m_scrollingLayerIdFromPreviousTree != -1)
    538         m_currentlyScrollingLayerImpl = CCLayerTreeHostCommon::findLayerInSubtree(m_rootLayerImpl.get(), m_scrollingLayerIdFromPreviousTree);
    539 
    540     m_scrollingLayerIdFromPreviousTree = -1;
    541 }
    542 
    543 PassOwnPtr<CCLayerImpl> CCLayerTreeHostImpl::releaseRootLayer()
    544 {
    545     m_scrollingLayerIdFromPreviousTree = m_currentlyScrollingLayerImpl ? m_currentlyScrollingLayerImpl->id() : -1;
    546     m_currentlyScrollingLayerImpl = 0;
    547 
    548     m_mostRecentRenderSurfaceLayerList.clear();
    549     return m_rootLayerImpl.release();
     511
     512    // FIXME: Currently, this only finds the first scrollable layer.
     513    m_scrollLayerImpl = findScrollLayer(m_rootLayerImpl.get());
    550514}
    551515
    … …  
    598562}
    599563
    600 static void adjustScrollsForPageScaleChange(CCLayerImpl* layerImpl, float pageScaleChange)
    601 {
    602     if (!layerImpl)
    603         return;
    604 
    605     if (layerImpl->scrollable()) {
    606         // We need to convert impl-side scroll deltas to pageScale space.
    607         FloatSize scrollDelta = layerImpl->scrollDelta();
    608         scrollDelta.scale(pageScaleChange);
    609         layerImpl->setScrollDelta(scrollDelta);
    610     }
    611 
    612     for (size_t i = 0; i < layerImpl->children().size(); ++i)
    613         adjustScrollsForPageScaleChange(layerImpl->children()[i].get(), pageScaleChange);
    614 }
    615 
    616 static void applyPageScaleDeltaToScrollLayers(CCLayerImpl* layerImpl, float pageScaleDelta)
    617 {
    618     if (!layerImpl)
    619         return;
    620 
    621     if (layerImpl->scrollable())
    622         layerImpl->setPageScaleDelta(pageScaleDelta);
    623 
    624     for (size_t i = 0; i < layerImpl->children().size(); ++i)
    625         applyPageScaleDeltaToScrollLayers(layerImpl->children()[i].get(), pageScaleDelta);
    626 }
    627 
    628564void CCLayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScale, float minPageScale, float maxPageScale)
    629565{
    … …  
    640576    m_pageScale = pageScale;
    641577
    642     if (pageScaleChange != 1)
    643         adjustScrollsForPageScaleChange(m_rootScrollLayerImpl, pageScaleChange);
     578    adjustScrollsForPageScaleChange(pageScaleChange);
    644579
    645580    // Clamp delta to limits and refresh display matrix.
    646581    setPageScaleDelta(m_pageScaleDelta / m_sentPageScaleDelta);
    647582    m_sentPageScaleDelta = 1;
    648     applyPageScaleDeltaToScrollLayers(m_rootScrollLayerImpl, m_pageScaleDelta);
     583    applyPageScaleDeltaToScrollLayer();
     584}
     585
     586void CCLayerTreeHostImpl::adjustScrollsForPageScaleChange(float pageScaleChange)
     587{
     588    if (pageScaleChange == 1)
     589        return;
     590
     591    // We also need to convert impl-side scroll deltas to pageScale space.
     592    if (m_scrollLayerImpl) {
     593        FloatSize scrollDelta = m_scrollLayerImpl->scrollDelta();
     594        scrollDelta.scale(pageScaleChange);
     595        m_scrollLayerImpl->setScrollDelta(scrollDelta);
     596    }
    649597}
    650598
    … …  
    664612
    665613    updateMaxScrollPosition();
    666     applyPageScaleDeltaToScrollLayers(m_rootScrollLayerImpl, m_pageScaleDelta);
     614    applyPageScaleDeltaToScrollLayer();
     615}
     616
     617void CCLayerTreeHostImpl::applyPageScaleDeltaToScrollLayer()
     618{
     619    if (m_scrollLayerImpl)
     620        m_scrollLayerImpl->setPageScaleDelta(m_pageScaleDelta);
    667621}
    668622
    669623void CCLayerTreeHostImpl::updateMaxScrollPosition()
    670624{
    671     if (!m_rootScrollLayerImpl || !m_rootScrollLayerImpl->children().size())
     625    if (!m_scrollLayerImpl || !m_scrollLayerImpl->children().size())
    672626        return;
    673627
    674628    FloatSize viewBounds = m_viewportSize;
    675     if (CCLayerImpl* clipLayer = m_rootScrollLayerImpl->parent()) {
     629    if (CCLayerImpl* clipLayer = m_scrollLayerImpl->parent()) {
    676630        if (clipLayer->masksToBounds())
    677631            viewBounds = clipLayer->bounds();
    … …  
    684638    maxScroll.clampNegativeToZero();
    685639
    686     m_rootScrollLayerImpl->setMaxScrollPosition(maxScroll);
     640    m_scrollLayerImpl->setMaxScrollPosition(maxScroll);
     641
     642    // TODO(aelias): Also update sublayers.
    687643}
    688644
    … …  
    692648}
    693649
    694 bool CCLayerTreeHostImpl::ensureMostRecentRenderSurfaceLayerList()
    695 {
    696     if (m_mostRecentRenderSurfaceLayerList.size())
    697         return true;
    698 
    699     if (!m_rootLayerImpl)
    700         return false;
    701 
    702     // If we are called after setRootLayer() but before prepareToDraw(), we need
    703     // to recalculate the visible layers. This prevents being unable to scroll
    704     // during part of a commit.
    705     calculateRenderSurfaceLayerList(m_mostRecentRenderSurfaceLayerList);
    706 
    707     return m_mostRecentRenderSurfaceLayerList.size();
    708 }
    709 
    710650CCInputHandlerClient::ScrollStatus CCLayerTreeHostImpl::scrollBegin(const IntPoint& viewportPoint, CCInputHandlerClient::ScrollInputType type)
    711651{
    712     TRACE_EVENT("CCLayerTreeHostImpl::scrollBegin", this, 0);
    713 
    714     scrollEnd();
    715 
    716     if (!ensureMostRecentRenderSurfaceLayerList())
     652    // TODO: Check for scrollable sublayers.
     653    if (!m_scrollLayerImpl || !m_scrollLayerImpl->scrollable()) {
     654        TRACE_EVENT("scrollBegin Ignored no scrollable", this, 0);
    717655        return ScrollIgnored;
    718 
    719     // First find out which layer was hit by walking the saved list of visible layers from the most recent frame.
    720     CCLayerImpl* layerImpl = 0;
    721     typedef CCLayerIterator<CCLayerImpl, CCLayerList, CCRenderSurface, CCLayerIteratorActions::FrontToBack> CCLayerIteratorType;
    722     CCLayerIteratorType end = CCLayerIteratorType::end(&m_mostRecentRenderSurfaceLayerList);
    723     for (CCLayerIteratorType it = CCLayerIteratorType::begin(&m_mostRecentRenderSurfaceLayerList); it != end; ++it) {
    724         CCLayerImpl* renderSurfaceLayerImpl = (*it);
    725         if (!renderSurfaceLayerImpl->screenSpaceTransform().isInvertible())
    726             continue;
    727         IntPoint contentPoint(renderSurfaceLayerImpl->screenSpaceTransform().inverse().mapPoint(viewportPoint));
    728         if (!renderSurfaceLayerImpl->visibleLayerRect().contains(contentPoint))
    729             continue;
    730         layerImpl = renderSurfaceLayerImpl;
    731         break;
    732     }
    733 
    734     // Walk up the hierarchy and look for a scrollable layer.
    735     CCLayerImpl* potentiallyScrollingLayerImpl = 0;
    736     for (; layerImpl; layerImpl = layerImpl->parent()) {
    737         // The content layer can also block attempts to scroll outside the main thread.
    738         if (layerImpl->tryScroll(viewportPoint, type) == ScrollFailed)
    739             return ScrollFailed;
    740 
    741         CCLayerImpl* scrollLayerImpl = findScrollLayerForContentLayer(layerImpl);
    742         if (!scrollLayerImpl)
    743             continue;
    744 
    745         ScrollStatus status = scrollLayerImpl->tryScroll(viewportPoint, type);
    746 
    747         // If any layer wants to divert the scroll event to the main thread, abort.
    748         if (status == ScrollFailed)
    749             return ScrollFailed;
    750 
    751         if (status == ScrollStarted && !potentiallyScrollingLayerImpl)
    752             potentiallyScrollingLayerImpl = scrollLayerImpl;
    753     }
    754 
    755     if (potentiallyScrollingLayerImpl) {
    756         m_currentlyScrollingLayerImpl = potentiallyScrollingLayerImpl;
    757         return ScrollStarted;
    758     }
    759     return ScrollIgnored;
     656    }
     657
     658    if (m_scrollLayerImpl->shouldScrollOnMainThread()) {
     659        TRACE_EVENT("scrollBegin Failed shouldScrollOnMainThread", this, 0);
     660        return ScrollFailed;
     661    }
     662
     663    IntPoint scrollLayerContentPoint(m_scrollLayerImpl->screenSpaceTransform().inverse().mapPoint(viewportPoint));
     664    if (m_scrollLayerImpl->nonFastScrollableRegion().contains(scrollLayerContentPoint)) {
     665        TRACE_EVENT("scrollBegin Failed nonFastScrollableRegion", this, 0);
     666        return ScrollFailed;
     667    }
     668
     669    if (type == CCInputHandlerClient::Wheel && m_scrollLayerImpl->haveWheelEventHandlers()) {
     670        TRACE_EVENT("scrollBegin Failed wheelEventHandlers", this, 0);
     671        return ScrollFailed;
     672    }
     673
     674    return ScrollStarted;
    760675}
    761676
    … …  
    763678{
    764679    TRACE_EVENT("CCLayerTreeHostImpl::scrollBy", this, 0);
    765     if (!m_currentlyScrollingLayerImpl)
    766         return;
    767 
    768     FloatSize pendingDelta(scrollDelta);
    769     pendingDelta.scale(1 / m_pageScaleDelta);
    770 
    771     for (CCLayerImpl* layerImpl = m_currentlyScrollingLayerImpl; layerImpl && !pendingDelta.isZero(); layerImpl = layerImpl->parent()) {
    772         if (!layerImpl->scrollable())
    773             continue;
    774         FloatSize previousDelta(layerImpl->scrollDelta());
    775         layerImpl->scrollBy(pendingDelta);
    776         // Reset the pending scroll delta to zero if the layer was able to move along the requested
    777         // axis. This is to ensure it is possible to scroll exactly to the beginning or end of a
    778         // scroll area regardless of the scroll step. For diagonal scrolls this also avoids applying
    779         // the scroll on one axis to multiple layers.
    780         if (previousDelta.width() != layerImpl->scrollDelta().width())
    781             pendingDelta.setWidth(0);
    782         if (previousDelta.height() != layerImpl->scrollDelta().height())
    783             pendingDelta.setHeight(0);
    784     }
    785 
    786     if (pendingDelta != scrollDelta) {
    787         m_client->setNeedsCommitOnImplThread();
    788         m_client->setNeedsRedrawOnImplThread();
    789     }
     680    if (!m_scrollLayerImpl)
     681        return;
     682
     683    m_scrollLayerImpl->scrollBy(scrollDelta);
     684    m_client->setNeedsCommitOnImplThread();
     685    m_client->setNeedsRedrawOnImplThread();
    790686}
    791687
    792688void CCLayerTreeHostImpl::scrollEnd()
    793689{
    794     m_currentlyScrollingLayerImpl = 0;
    795     m_scrollingLayerIdFromPreviousTree = -1;
    796690}
    797691
    … …  
    807701    TRACE_EVENT("CCLayerTreeHostImpl::pinchGestureUpdate", this, 0);
    808702
    809     if (!m_rootScrollLayerImpl)
     703    if (!m_scrollLayerImpl)
    810704        return;
    811705
    … …  
    822716    m_previousPinchAnchor = anchor;
    823717
    824     m_rootScrollLayerImpl->scrollBy(roundedIntSize(move));
     718    m_scrollLayerImpl->scrollBy(roundedIntSize(move));
    825719    m_client->setNeedsCommitOnImplThread();
    826720    m_client->setNeedsRedrawOnImplThread();
    … …  
    844738void CCLayerTreeHostImpl::computePinchZoomDeltas(CCScrollAndScaleSet* scrollInfo)
    845739{
    846     if (!m_rootScrollLayerImpl)
     740    if (!m_scrollLayerImpl)
    847741        return;
    848742
    … …  
    856750    // Compute where the scroll offset/page scale would be if fully pinch-zoomed
    857751    // out from the anchor point.
    858     IntSize scrollBegin = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
     752    IntSize scrollBegin = flooredIntSize(m_scrollLayerImpl->scrollPosition() + m_scrollLayerImpl->scrollDelta());
    859753    scrollBegin.scale(m_pageScaleDelta);
    860754    float scaleBegin = m_pageScale * m_pageScaleDelta;
    … …  
    875769void CCLayerTreeHostImpl::makeScrollAndScaleSet(CCScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale)
    876770{
    877     if (!m_rootScrollLayerImpl)
     771    if (!m_scrollLayerImpl)
    878772        return;
    879773
    880774    CCLayerTreeHostCommon::ScrollUpdateInfo scroll;
    881     scroll.layerId = m_rootScrollLayerImpl->id();
    882     scroll.scrollDelta = scrollOffset - toSize(m_rootScrollLayerImpl->scrollPosition());
     775    scroll.layerId = m_scrollLayerImpl->id();
     776    scroll.scrollDelta = scrollOffset - toSize(m_scrollLayerImpl->scrollPosition());
    883777    scrollInfo->scrolls.append(scroll);
    884     m_rootScrollLayerImpl->setSentScrollDelta(scroll.scrollDelta);
     778    m_scrollLayerImpl->setSentScrollDelta(scroll.scrollDelta);
    885779    m_sentPageScaleDelta = scrollInfo->pageScaleDelta = pageScale / m_pageScale;
    886780}
    887781
    888 static void collectScrollDeltas(CCScrollAndScaleSet* scrollInfo, CCLayerImpl* layerImpl)
    889 {
    890     if (!layerImpl)
    891         return;
    892 
    893     if (!layerImpl->scrollDelta().isZero()) {
    894         IntSize scrollDelta = flooredIntSize(layerImpl->scrollDelta());
    895         CCLayerTreeHostCommon::ScrollUpdateInfo scroll;
    896         scroll.layerId = layerImpl->id();
    897         scroll.scrollDelta = scrollDelta;
    898         scrollInfo->scrolls.append(scroll);
    899         layerImpl->setSentScrollDelta(scrollDelta);
    900     }
    901 
    902     for (size_t i = 0; i < layerImpl->children().size(); ++i)
    903         collectScrollDeltas(scrollInfo, layerImpl->children()[i].get());
    904 }
    905 
    906782PassOwnPtr<CCScrollAndScaleSet> CCLayerTreeHostImpl::processScrollDeltas()
    907783{
    908784    OwnPtr<CCScrollAndScaleSet> scrollInfo = adoptPtr(new CCScrollAndScaleSet());
    909     collectScrollDeltas(scrollInfo.get(), m_rootLayerImpl.get());
    910 
    911     bool didMove = scrollInfo->scrolls.size() || m_pageScaleDelta != 1;
     785    bool didMove = m_scrollLayerImpl && (!m_scrollLayerImpl->scrollDelta().isZero() || m_pageScaleDelta != 1.0f);
    912786    if (!didMove || m_pinchGestureActive || m_pageScaleAnimation) {
    913787        m_sentPageScaleDelta = scrollInfo->pageScaleDelta = 1;
    … …  
    921795    m_sentPageScaleDelta = scrollInfo->pageScaleDelta = m_pageScaleDelta;
    922796
     797    // FIXME: track scrolls from layers other than the root
     798    CCLayerTreeHostCommon::ScrollUpdateInfo scroll;
     799    scroll.layerId = m_scrollLayerImpl->id();
     800    scroll.scrollDelta = flooredIntSize(m_scrollLayerImpl->scrollDelta());
     801    scrollInfo->scrolls.append(scroll);
     802
     803    m_scrollLayerImpl->setSentScrollDelta(scroll.scrollDelta);
     804
    923805    return scrollInfo.release();
    924806}
    … …  
    935817void CCLayerTreeHostImpl::animatePageScale(double monotonicTime)
    936818{
    937     if (!m_pageScaleAnimation || !m_rootScrollLayerImpl)
    938         return;
    939 
    940     IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
     819    if (!m_pageScaleAnimation || !m_scrollLayerImpl)
     820        return;
     821
     822    IntSize scrollTotal = flooredIntSize(m_scrollLayerImpl->scrollPosition() + m_scrollLayerImpl->scrollDelta());
    941823
    942824    setPageScaleDelta(m_pageScaleAnimation->pageScaleAtTime(monotonicTime) / m_pageScale);
    943825    IntSize nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime);
    944826    nextScroll.scale(1 / m_pageScaleDelta);
    945     m_rootScrollLayerImpl->scrollBy(nextScroll - scrollTotal);
     827    m_scrollLayerImpl->scrollBy(nextScroll - scrollTotal);
    946828    m_client->setNeedsRedrawOnImplThread();
    947829

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h

    r115881 r116142  
    134134
    135135    void setRootLayer(PassOwnPtr<CCLayerImpl>);
    136     PassOwnPtr<CCLayerImpl> releaseRootLayer();
     136    PassOwnPtr<CCLayerImpl> releaseRootLayer() { return m_rootLayerImpl.release(); }
    137137    CCLayerImpl* rootLayer() { return m_rootLayerImpl.get(); }
    138138
    139     CCLayerImpl* rootScrollLayer() const { return m_rootScrollLayerImpl; }
     139    CCLayerImpl* scrollLayer() const { return m_scrollLayerImpl; }
    140140
    141141    bool visible() const { return m_visible; }
    … …  
    184184
    185185    void setPageScaleDelta(float);
     186    void applyPageScaleDeltaToScrollLayer();
     187    void adjustScrollsForPageScaleChange(float);
    186188    void updateMaxScrollPosition();
    187189    void trackDamageForAllSurfaces(CCLayerImpl* rootDrawLayer, const CCLayerList& renderSurfaceLayerList);
    … …  
    196198    void sendDidLoseContextRecursive(CCLayerImpl*);
    197199    void clearRenderSurfacesOnCCLayerImplRecursive(CCLayerImpl*);
    198     bool ensureMostRecentRenderSurfaceLayerList();
    199200
    200201    void dumpRenderSurfaces(TextStream&, int indent, const CCLayerImpl*) const;
    … …  
    202203    OwnPtr<LayerRendererChromium> m_layerRenderer;
    203204    OwnPtr<CCLayerImpl> m_rootLayerImpl;
    204     CCLayerImpl* m_rootScrollLayerImpl;
    205     CCLayerImpl* m_currentlyScrollingLayerImpl;
    206     int m_scrollingLayerIdFromPreviousTree;
     205    CCLayerImpl* m_scrollLayerImpl;
    207206    CCSettings m_settings;
    208207    IntSize m_viewportSize;
    … …  
    231230    CCLayerSorter m_layerSorter;
    232231
    233     // List of visible layers in the most recent frame. Used for input event hit testing.
    234     CCLayerList m_mostRecentRenderSurfaceLayerList;
    235 
    236232    FloatRect m_rootDamageRect;
    237233

  • trunk/Source/WebKit/chromium/ChangeLog

    r116127 r116142  
     12012-05-04  Sami Kyostila  <skyostil@chromium.org>
     2
     3        [chromium] Revert compositor layer scrolling
     4        https://bugs.webkit.org/show_bug.cgi?id=85644
     5
     6        Reviewed by Steve Block.
     7
     8        * src/WebContentLayerImpl.cpp:
     9        * src/WebContentLayerImpl.h:
     10        (WebContentLayerImpl):
     11        * tests/CCLayerTreeHostCommonTest.cpp:
     12        * tests/CCLayerTreeHostImplTest.cpp:
     13        (WebKitTests::TEST_F):
     14        * tests/CCLayerTreeHostTest.cpp:
     15        (WTF::MockContentLayerDelegate::paintContents):
     16
    1172012-05-04  Tommy Widenflycht  <tommyw@google.com>
    218

  • trunk/Source/WebKit/chromium/src/WebContentLayerImpl.cpp

    r114651 r116142  
    7373}
    7474
    75 void WebContentLayerImpl::didScroll(const WebCore::IntSize&)
    76 {
    77 }
    78 
    7975} // namespace WebKit

  • trunk/Source/WebKit/chromium/src/WebContentLayerImpl.h

    r114651 r116142  
    4545    // ContentLayerDelegate implementation.
    4646    virtual void paintContents(WebCore::GraphicsContext&, const WebCore::IntRect& clip);
    47     virtual void didScroll(const WebCore::IntSize&);
    4847
    4948    WebContentLayerClient* m_contentClient;

  • trunk/Source/WebKit/chromium/tests/CCLayerTreeHostCommonTest.cpp

    r114651 r116142  
    13261326}
    13271327
    1328 TEST(CCLayerTreeHostCommonTest, verifySubtreeSearch)
    1329 {
    1330     RefPtr<LayerChromium> root = LayerChromium::create();
    1331     RefPtr<LayerChromium> child = LayerChromium::create();
    1332     RefPtr<LayerChromium> grandChild = LayerChromium::create();
    1333     RefPtr<LayerChromium> maskLayer = LayerChromium::create();
    1334     RefPtr<LayerChromium> replicaLayer = LayerChromium::create();
    1335 
    1336     grandChild->setReplicaLayer(replicaLayer.get());
    1337     child->addChild(grandChild.get());
    1338     child->setMaskLayer(maskLayer.get());
    1339     root->addChild(child.get());
    1340 
    1341     int nonexistentId = -1;
    1342     EXPECT_EQ(root, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), root->id()));
    1343     EXPECT_EQ(child, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), child->id()));
    1344     EXPECT_EQ(grandChild, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), grandChild->id()));
    1345     EXPECT_EQ(maskLayer, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), maskLayer->id()));
    1346     EXPECT_EQ(replicaLayer, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), replicaLayer->id()));
    1347     EXPECT_EQ(0, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), nonexistentId));
    1348 }
    1349 
    13501328// FIXME:
    13511329// continue working on https://bugs.webkit.org/show_bug.cgi?id=68942

  • trunk/Source/WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp

    r115944 r116142  
    105105    }
    106106
    107     static PassOwnPtr<CCLayerImpl> createScrollableLayer(int id, const FloatPoint& position, const IntSize& size)
    108     {
    109         OwnPtr<CCLayerImpl> layer = CCLayerImpl::create(id);
    110         layer->setScrollable(true);
    111         layer->setDrawsContent(true);
    112         layer->setPosition(position);
    113         layer->setBounds(size);
    114         layer->setMaxScrollPosition(IntSize(size.width() * 2, size.height() * 2));
    115         return layer.release();
    116     }
    117 
    118     void initializeLayerRendererAndDrawFrame()
    119     {
    120         m_hostImpl->initializeLayerRenderer(createContext());
    121         CCLayerTreeHostImpl::FrameData frame;
    122         EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
    123         m_hostImpl->drawLayers(frame);
    124         m_hostImpl->didDrawAllLayers(frame);
    125     }
    126 
    127107protected:
    128108    PassRefPtr<GraphicsContext3D> createContext()
    … …  
    208188    {
    209189        OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
    210         root->setVisibleLayerRect(IntRect(0, 0, 100, 100));
    211190        root->setScrollable(true);
    212191        root->setScrollPosition(IntPoint(0, 0));
    213192        root->setMaxScrollPosition(IntSize(100, 100));
    214193        m_hostImpl->setRootLayer(root.release());
    215         initializeLayerRendererAndDrawFrame();
    216194    }
    217195
    … …  
    223201}
    224202
    225 TEST_F(CCLayerTreeHostImplTest, scrollWithoutRootLayer)
    226 {
    227     // We should not crash when trying to scroll an empty layer tree.
    228     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollIgnored);
    229 }
    230 
    231 TEST_F(CCLayerTreeHostImplTest, replaceTreeWhileScrolling)
    232 {
    233     int layerId = 7;
    234     {
    235         OwnPtr<CCLayerImpl> root = CCLayerImpl::create(layerId);
    236         root->setVisibleLayerRect(IntRect(0, 0, 100, 100));
    237         root->setScrollable(true);
    238         root->setMaxScrollPosition(IntSize(100, 100));
    239         m_hostImpl->setRootLayer(root.release());
    240         initializeLayerRendererAndDrawFrame();
    241     }
    242 
    243     // We should not crash if the tree is replaced while we are scrolling.
    244     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
    245     m_hostImpl->releaseRootLayer();
    246 
    247     {
    248         OwnPtr<CCLayerImpl> root = CCLayerImpl::create(layerId);
    249         root->setVisibleLayerRect(IntRect(0, 0, 100, 100));
    250         root->setScrollable(true);
    251         root->setMaxScrollPosition(IntSize(100, 100));
    252         m_hostImpl->setRootLayer(root.release());
    253     }
    254 
    255     // We should still be scrolling, because the scrolled layer also exists in the new tree.
    256     IntSize scrollDelta(0, 10);
    257     m_hostImpl->scrollBy(scrollDelta);
    258     m_hostImpl->scrollEnd();
    259     OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
    260     expectContains(*scrollInfo, layerId, scrollDelta);
    261 }
    262 
    263203TEST_F(CCLayerTreeHostImplTest, wheelEventHandlers)
    264204{
    265205    {
    266206        OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
    267         root->setVisibleLayerRect(IntRect(0, 0, 100, 100));
    268207        root->setScrollable(true);
    269208        root->setScrollPosition(IntPoint(0, 0));
    270209        root->setMaxScrollPosition(IntSize(100, 100));
    271210        m_hostImpl->setRootLayer(root.release());
    272         initializeLayerRendererAndDrawFrame();
    273211    }
    274212    CCLayerImpl* root = m_hostImpl->rootLayer();
    … …  
    285223{
    286224    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
    287     root->setVisibleLayerRect(IntRect(0, 0, 100, 100));
    288225    root->setScrollable(true);
    289226    root->setScrollPosition(IntPoint(0, 0));
    … …  
    291228    root->setShouldScrollOnMainThread(true);
    292229    m_hostImpl->setRootLayer(root.release());
    293     initializeLayerRendererAndDrawFrame();
    294 
    295230    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollFailed);
    296231    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Gesture), CCInputHandlerClient::ScrollFailed);
    … …  
    300235{
    301236    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
    302     root->setVisibleLayerRect(IntRect(0, 0, 100, 100));
    303237    root->setScrollable(true);
    304238    root->setScrollPosition(IntPoint(0, 0));
    … …  
    306240    root->setNonFastScrollableRegion(IntRect(0, 0, 50, 50));
    307241    m_hostImpl->setRootLayer(root.release());
    308     initializeLayerRendererAndDrawFrame();
    309 
    310242    // All scroll types inside the non-fast scrollable region should fail.
    311243    EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(25, 25), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollFailed);
    … …  
    323255TEST_F(CCLayerTreeHostImplTest, nonFastScrollableRegionWithOffset)
    324256{
     257    m_hostImpl->initializeLayerRenderer(createContext());
     258
    325259    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
    326     root->setBounds(IntSize(1, 1));
    327     root->setVisibleLayerRect(IntRect(0, 0, 100, 100));
    328260    root->setScrollable(true);
    329261    root->setScrollPosition(IntPoint(0, 0));
    … …  
    332264    root->setPosition(FloatPoint(-25, 0));
    333265    m_hostImpl->setRootLayer(root.release());
    334     initializeLayerRendererAndDrawFrame();
     266    CCLayerTreeHostImpl::FrameData frame;
     267    EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     268    m_hostImpl->drawLayers(frame); // Update draw transforms so we can correctly map points into layer space.
    335269
    336270    // This point would fall into the non-fast scrollable region except that we've moved the layer down by 25 pixels.
    … …  
    347281    setupScrollAndContentsLayers(IntSize(100, 100));
    348282    m_hostImpl->setViewportSize(IntSize(50, 50));
    349     initializeLayerRendererAndDrawFrame();
    350 
    351     CCLayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
     283
     284    CCLayerImpl* scrollLayer = m_hostImpl->scrollLayer();
    352285    ASSERT(scrollLayer);
    353286
    … …  
    428361    setupScrollAndContentsLayers(IntSize(100, 100));
    429362    m_hostImpl->setViewportSize(IntSize(50, 50));
    430     initializeLayerRendererAndDrawFrame();
    431 
    432     CCLayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
     363
     364    CCLayerImpl* scrollLayer = m_hostImpl->scrollLayer();
    433365    ASSERT(scrollLayer);
    434366
    … …  
    644576    m_hostImpl->drawLayers(frame);
    645577    m_hostImpl->didDrawAllLayers(frame);
    646 }
    647 
    648 TEST_F(CCLayerTreeHostImplTest, scrollRootIgnored)
    649 {
    650     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
    651     root->setScrollable(false);
    652     m_hostImpl->setRootLayer(root.release());
    653     initializeLayerRendererAndDrawFrame();
    654 
    655     // Scroll event is ignored because layer is not scrollable.
    656     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollIgnored);
    657     EXPECT_FALSE(m_didRequestRedraw);
    658     EXPECT_FALSE(m_didRequestCommit);
    659 }
    660 
    661 TEST_F(CCLayerTreeHostImplTest, scrollNonCompositedRoot)
    662 {
    663     // Test the configuration where a non-composited root layer is embedded in a
    664     // scrollable outer layer.
    665     IntSize surfaceSize(10, 10);
    666 
    667     OwnPtr<CCLayerImpl> contentLayer = CCLayerImpl::create(1);
    668     contentLayer->setIsNonCompositedContent(true);
    669     contentLayer->setDrawsContent(true);
    670     contentLayer->setPosition(IntPoint(5, 5));
    671     contentLayer->setBounds(surfaceSize);
    672     contentLayer->setContentBounds(IntSize(surfaceSize.width() * 2, surfaceSize.height() * 2));
    673 
    674     OwnPtr<CCLayerImpl> scrollLayer = CCLayerImpl::create(0);
    675     scrollLayer->setScrollable(true);
    676     scrollLayer->addChild(contentLayer.release());
    677 
    678     m_hostImpl->setRootLayer(scrollLayer.release());
    679     m_hostImpl->setViewportSize(surfaceSize);
    680     initializeLayerRendererAndDrawFrame();
    681 
    682     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
    683     m_hostImpl->scrollBy(IntSize(0, 10));
    684     m_hostImpl->scrollEnd();
    685     EXPECT_TRUE(m_didRequestRedraw);
    686     EXPECT_TRUE(m_didRequestCommit);
    687 }
    688 
    689 TEST_F(CCLayerTreeHostImplTest, scrollChildCallsCommitAndRedraw)
    690 {
    691     IntSize surfaceSize(10, 10);
    692     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
    693     root->addChild(createScrollableLayer(1, FloatPoint(5, 5), surfaceSize));
    694     m_hostImpl->setRootLayer(root.release());
    695     m_hostImpl->setViewportSize(surfaceSize);
    696     initializeLayerRendererAndDrawFrame();
    697 
    698     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
    699     m_hostImpl->scrollBy(IntSize(0, 10));
    700     m_hostImpl->scrollEnd();
    701     EXPECT_TRUE(m_didRequestRedraw);
    702     EXPECT_TRUE(m_didRequestCommit);
    703 }
    704 
    705 TEST_F(CCLayerTreeHostImplTest, scrollMissesChild)
    706 {
    707     IntSize surfaceSize(10, 10);
    708     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
    709     root->addChild(createScrollableLayer(1, FloatPoint(5, 5), surfaceSize));
    710     m_hostImpl->setRootLayer(root.release());
    711     m_hostImpl->setViewportSize(surfaceSize);
    712     initializeLayerRendererAndDrawFrame();
    713 
    714     // Scroll event is ignored because the input coordinate is outside the layer boundaries.
    715     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(15, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollIgnored);
    716     EXPECT_FALSE(m_didRequestRedraw);
    717     EXPECT_FALSE(m_didRequestCommit);
    718 }
    719 
    720 TEST_F(CCLayerTreeHostImplTest, scrollMissesBackfacingChild)
    721 {
    722     IntSize surfaceSize(10, 10);
    723     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
    724     OwnPtr<CCLayerImpl> child = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
    725     m_hostImpl->setViewportSize(surfaceSize);
    726 
    727     TransformationMatrix matrix;
    728     matrix.rotate3d(180, 0, 0);
    729     child->setTransform(matrix);
    730     child->setDoubleSided(false);
    731 
    732     root->addChild(child.release());
    733     m_hostImpl->setRootLayer(root.release());
    734     initializeLayerRendererAndDrawFrame();
    735 
    736     // Scroll event is ignored because the scrollable layer is not facing the viewer and there is
    737     // nothing scrollable behind it.
    738     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollIgnored);
    739     EXPECT_FALSE(m_didRequestRedraw);
    740     EXPECT_FALSE(m_didRequestCommit);
    741 }
    742 
    743 TEST_F(CCLayerTreeHostImplTest, scrollBlockedByContentLayer)
    744 {
    745     IntSize surfaceSize(10, 10);
    746     OwnPtr<CCLayerImpl> contentLayer = createScrollableLayer(0, FloatPoint(5, 5), surfaceSize);
    747     contentLayer->setShouldScrollOnMainThread(true);
    748     contentLayer->setScrollable(false);
    749 
    750     OwnPtr<CCLayerImpl> scrollLayer = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
    751     scrollLayer->addChild(contentLayer.release());
    752 
    753     m_hostImpl->setRootLayer(scrollLayer.release());
    754     m_hostImpl->setViewportSize(surfaceSize);
    755     initializeLayerRendererAndDrawFrame();
    756 
    757     // Scrolling fails because the content layer is asking to be scrolled on the main thread.
    758     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollFailed);
    759 }
    760 
    761 TEST_F(CCLayerTreeHostImplTest, scrollRootAndChangePageScaleOnMainThread)
    762 {
    763     IntSize surfaceSize(10, 10);
    764     float pageScale = 2;
    765     OwnPtr<CCLayerImpl> root = createScrollableLayer(0, FloatPoint(5, 5), surfaceSize);
    766     m_hostImpl->setRootLayer(root.release());
    767     m_hostImpl->setViewportSize(surfaceSize);
    768     initializeLayerRendererAndDrawFrame();
    769 
    770     IntSize scrollDelta(0, 10);
    771     IntSize expectedScrollDelta(scrollDelta);
    772     IntSize expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollPosition());
    773     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
    774     m_hostImpl->scrollBy(scrollDelta);
    775     m_hostImpl->scrollEnd();
    776 
    777     // Set new page scale from main thread.
    778     m_hostImpl->setPageScaleFactorAndLimits(pageScale, pageScale, pageScale);
    779 
    780     // The scale should apply to the scroll delta.
    781     expectedScrollDelta.scale(pageScale);
    782     OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
    783     expectContains(*scrollInfo.get(), 0, expectedScrollDelta);
    784 
    785     // The scroll range should also have been updated.
    786     EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), expectedMaxScroll);
    787 
    788     // The page scale delta remains constant because the impl thread did not scale.
    789     EXPECT_EQ(m_hostImpl->rootLayer()->pageScaleDelta(), 1);
    790 }
    791 
    792 TEST_F(CCLayerTreeHostImplTest, scrollRootAndChangePageScaleOnImplThread)
    793 {
    794     IntSize surfaceSize(10, 10);
    795     float pageScale = 2;
    796     OwnPtr<CCLayerImpl> root = createScrollableLayer(0, FloatPoint(5, 5), surfaceSize);
    797     m_hostImpl->setRootLayer(root.release());
    798     m_hostImpl->setViewportSize(surfaceSize);
    799     m_hostImpl->setPageScaleFactorAndLimits(1, 1, pageScale);
    800     initializeLayerRendererAndDrawFrame();
    801 
    802     IntSize scrollDelta(0, 10);
    803     IntSize expectedScrollDelta(scrollDelta);
    804     IntSize expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollPosition());
    805     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
    806     m_hostImpl->scrollBy(scrollDelta);
    807     m_hostImpl->scrollEnd();
    808 
    809     // Set new page scale on impl thread by pinching.
    810     m_hostImpl->pinchGestureBegin();
    811     m_hostImpl->pinchGestureUpdate(pageScale, IntPoint());
    812     m_hostImpl->pinchGestureEnd();
    813 
    814     // The scroll delta is not scaled because the main thread did not scale.
    815     OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
    816     expectContains(*scrollInfo.get(), 0, expectedScrollDelta);
    817 
    818     // The scroll range should also have been updated.
    819     EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), expectedMaxScroll);
    820 
    821     // The page scale delta should match the new scale on the impl side.
    822     EXPECT_EQ(m_hostImpl->rootLayer()->pageScaleDelta(), pageScale);
    823 }
    824 
    825 TEST_F(CCLayerTreeHostImplTest, scrollChildAndChangePageScaleOnMainThread)
    826 {
    827     IntSize surfaceSize(10, 10);
    828     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
    829     // Also mark the root scrollable so it becomes the root scroll layer.
    830     root->setScrollable(true);
    831     root->addChild(createScrollableLayer(1, FloatPoint(5, 5), surfaceSize));
    832     m_hostImpl->setRootLayer(root.release());
    833     m_hostImpl->setViewportSize(surfaceSize);
    834     initializeLayerRendererAndDrawFrame();
    835 
    836     CCLayerImpl* child = m_hostImpl->rootLayer()->children()[0].get();
    837 
    838     IntSize scrollDelta(0, 10);
    839     IntSize expectedScrollDelta(scrollDelta);
    840     IntSize expectedMaxScroll(child->maxScrollPosition());
    841     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
    842     m_hostImpl->scrollBy(scrollDelta);
    843     m_hostImpl->scrollEnd();
    844 
    845     float pageScale = 2;
    846     m_hostImpl->setPageScaleFactorAndLimits(pageScale, 1, pageScale);
    847 
    848     // The scale should apply to the scroll delta.
    849     expectedScrollDelta.scale(pageScale);
    850     OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
    851     expectContains(*scrollInfo.get(), 1, expectedScrollDelta);
    852 
    853     // The scroll range should not have changed.
    854     EXPECT_EQ(child->maxScrollPosition(), expectedMaxScroll);
    855 
    856     // The page scale delta remains constant because the impl thread did not scale.
    857     EXPECT_EQ(child->pageScaleDelta(), 1);
    858 }
    859 
    860 TEST_F(CCLayerTreeHostImplTest, scrollChildBeyondLimit)
    861 {
    862     // Scroll a child layer beyond its maximum scroll range and make sure the
    863     // parent layer is scrolled on the axis on which the child was unable to
    864     // scroll.
    865     IntSize surfaceSize(10, 10);
    866     OwnPtr<CCLayerImpl> root = createScrollableLayer(0, FloatPoint(5, 5), surfaceSize);
    867 
    868     OwnPtr<CCLayerImpl> grandChild = createScrollableLayer(2, FloatPoint(5, 5), surfaceSize);
    869     grandChild->setScrollPosition(IntPoint(0, 5));
    870 
    871     OwnPtr<CCLayerImpl> child = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
    872     child->setScrollPosition(IntPoint(3, 0));
    873     child->addChild(grandChild.release());
    874 
    875     root->addChild(child.release());
    876     m_hostImpl->setRootLayer(root.release());
    877     m_hostImpl->setViewportSize(surfaceSize);
    878     initializeLayerRendererAndDrawFrame();
    879     {
    880         IntSize scrollDelta(-3, -7);
    881         EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
    882         m_hostImpl->scrollBy(scrollDelta);
    883         m_hostImpl->scrollEnd();
    884 
    885         OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
    886 
    887         // The grand child should have scrolled up to its limit.
    888         CCLayerImpl* child = m_hostImpl->rootLayer()->children()[0].get();
    889         CCLayerImpl* grandChild = child->children()[0].get();
    890         expectContains(*scrollInfo.get(), grandChild->id(), IntSize(0, -5));
    891 
    892         // The child should have only scrolled on the other axis.
    893         expectContains(*scrollInfo.get(), child->id(), IntSize(-3, 0));
    894     }
    895 }
    896 
    897 TEST_F(CCLayerTreeHostImplTest, scrollBeforeRedraw)
    898 {
    899     IntSize surfaceSize(10, 10);
    900     m_hostImpl->setRootLayer(createScrollableLayer(0, FloatPoint(5, 5), surfaceSize));
    901     m_hostImpl->setViewportSize(surfaceSize);
    902 
    903     // Draw one frame and then immediately rebuild the layer tree to mimic a tree synchronization.
    904     initializeLayerRendererAndDrawFrame();
    905     m_hostImpl->releaseRootLayer();
    906     m_hostImpl->setRootLayer(createScrollableLayer(0, FloatPoint(5, 5), surfaceSize));
    907 
    908     // Scrolling should still work even though we did not draw yet.
    909     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
    910578}
    911579

  • trunk/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp

    r115944 r116142  
    15511551
    15521552    virtual bool preserves3D() { return false; }
    1553     virtual void didScroll(const IntSize&) { }
    15541553
    15551554private:
    … …  
    16861685    bool drawsContent() const { return true; }
    16871686    MOCK_CONST_METHOD0(preserves3D, bool());
    1688     virtual void paintContents(GraphicsContext&, const IntRect&) { }
    1689     virtual void didScroll(const IntSize&) { }
     1687    void paintContents(GraphicsContext&, const IntRect&) { }
    16901688    void notifySyncRequired() { }
    16911689};
    … …  
    24492447}
    24502448
    2451 class CCLayerTreeHostTestScrollChildLayer : public CCLayerTreeHostTest {
    2452 public:
    2453     CCLayerTreeHostTestScrollChildLayer()
    2454         : m_scrollAmount(2, 1)
    2455     {
    2456     }
    2457 
    2458     virtual void beginTest()
    2459     {
    2460         m_layerTreeHost->setViewportSize(IntSize(10, 10));
    2461         m_rootScrollLayer = ContentLayerChromium::create(&m_mockDelegate);
    2462         m_rootScrollLayer->setBounds(IntSize(10, 10));
    2463         m_rootScrollLayer->setIsDrawable(true);
    2464         m_rootScrollLayer->setScrollable(true);
    2465         m_rootScrollLayer->setMaxScrollPosition(IntSize(100, 100));
    2466         m_layerTreeHost->rootLayer()->addChild(m_rootScrollLayer);
    2467         m_childLayer = ContentLayerChromium::create(&m_mockDelegate);
    2468         m_childLayer->setBounds(IntSize(50, 50));
    2469         m_childLayer->setIsDrawable(true);
    2470         m_childLayer->setScrollable(true);
    2471         m_childLayer->setMaxScrollPosition(IntSize(100, 100));
    2472         m_rootScrollLayer->addChild(m_childLayer);
    2473         postSetNeedsCommitToMainThread();
    2474     }
    2475 
    2476     virtual void applyScrollAndScale(const IntSize& scrollDelta, float)
    2477     {
    2478         IntPoint position = m_rootScrollLayer->scrollPosition();
    2479         m_rootScrollLayer->setScrollPosition(position + scrollDelta);
    2480     }
    2481 
    2482     virtual void beginCommitOnCCThread(CCLayerTreeHostImpl* impl)
    2483     {
    2484         EXPECT_EQ(m_rootScrollLayer->scrollPosition(), IntPoint());
    2485         if (!m_layerTreeHost->frameNumber())
    2486             EXPECT_EQ(m_childLayer->scrollPosition(), IntPoint());
    2487         else
    2488             EXPECT_EQ(m_childLayer->scrollPosition(), IntPoint() + m_scrollAmount);
    2489     }
    2490 
    2491     virtual void drawLayersOnCCThread(CCLayerTreeHostImpl* impl)
    2492     {
    2493         if (impl->frameNumber() == 1) {
    2494             EXPECT_EQ(impl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
    2495             impl->scrollBy(m_scrollAmount);
    2496             impl->scrollEnd();
    2497         } else if (impl->frameNumber() == 2)
    2498             endTest();
    2499     }
    2500 
    2501     virtual void afterTest()
    2502     {
    2503     }
    2504 
    2505 private:
    2506     const IntSize m_scrollAmount;
    2507     MockContentLayerDelegate m_mockDelegate;
    2508     RefPtr<LayerChromium> m_childLayer;
    2509     RefPtr<LayerChromium> m_rootScrollLayer;
    2510 };
    2511 
    2512 TEST_F(CCLayerTreeHostTestScrollChildLayer, runMultiThread)
    2513 {
    2514     runTest(true);
    2515 }
    2516 
    25172449} // namespace
Note: See TracChangeset for help on using the changeset viewer.