⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 99774 in webkit


Ignore:
Timestamp:
Nov 9, 2011, 3:47:45 PM (15 years ago)
Author:
commit-queue@webkit.org
Message:

[chromium] Add draw-time scale delta to compositor thread
​https://bugs.webkit.org/show_bug.cgi?id=71595

Patch by Alexandre Elias <​aelias@google.com> on 2011-11-09
Reviewed by James Robinson.

There are two magnify values:

  1. The WebKit-side pageScale value corresponding to the resolution of the painted content.
  2. The Impl-side-only scaleDelta value representing the additional degree of current magnification, applied as a draw transform. WebKit is never explicitly aware of this value and the only way to change it currently is via pinch events (and in the future, double-tap/etc events). At the end of a pinch zoom, we multiply pageScale * scaleDelta and tell WebKit to use it as the new pageScale.

Scroll offsets and max-extents are maintained in pageScale space.
When the scale changes, we need to take care to convert them to the
new scale and avoid getting them clamped to the extents at the wrong
scale.

I removed maxScrollPosition on the non-impl side because it makes no
sense to precompute it in the presence of an impl-side zoom. Replaced
with a simple 'bool m_scrollable'.

zoomAnimatorTransform is not used because it currently isn't in the
branch, and mostly doesn't behave the way we want anyway (it does most
things in WebKit thread). We will need to unify these later.

Also introduce deviceOrPageScaleFactorChanged() call which invalidates
layers.

Source/WebCore:

No new tests (filed 71529 to remember to do it later).

  • platform/graphics/chromium/GraphicsLayerChromium.cpp:

(WebCore::GraphicsLayerChromium::deviceOrPageScaleFactorChanged):

  • platform/graphics/chromium/GraphicsLayerChromium.h:
  • platform/graphics/chromium/LayerChromium.cpp:

(WebCore::LayerChromium::LayerChromium):
(WebCore::LayerChromium::setBounds):
(WebCore::LayerChromium::pushPropertiesTo):

  • platform/graphics/chromium/LayerChromium.h:

(WebCore::LayerChromium::scrollable):
(WebCore::LayerChromium::setScrollable):
(WebCore::LayerChromium::pageScaleChanged):

  • platform/graphics/chromium/LayerRendererChromium.cpp:

(WebCore::LayerRendererChromium::drawLayersInternal):

  • platform/graphics/chromium/LayerRendererChromium.h:

(WebCore::LayerRendererChromium::setPageMagnifyTransform):

  • platform/graphics/chromium/NonCompositedContentHost.cpp:

(WebCore::NonCompositedContentHost::setViewport):

  • platform/graphics/chromium/NonCompositedContentHost.h:

(WebCore::NonCompositedContentHost::topLevelRootLayer):

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

(WebCore::CCLayerImpl::CCLayerImpl):

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

(WebCore::CCLayerImpl::scrollable):
(WebCore::CCLayerImpl::setScrollable):

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

(WebCore::CCLayerTreeHost::CCLayerTreeHost):
(WebCore::CCLayerTreeHost::finishCommitOnImplThread):
(WebCore::CCLayerTreeHost::setPageScale):
(WebCore::CCLayerTreeHost::setPageScaleFactorLimits):
(WebCore::CCLayerTreeHost::applyScrollAndScale):

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

(WebCore::CCLayerTreeHost::pageScale):

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

(WebCore::CCLayerTreeHostImpl::CCLayerTreeHostImpl):
(WebCore::CCLayerTreeHostImpl::commitComplete):
(WebCore::findScrollLayer):
(WebCore::CCLayerTreeHostImpl::setViewport):
(WebCore::CCLayerTreeHostImpl::setPageScale):
(WebCore::CCLayerTreeHostImpl::setScaleDelta):
(WebCore::CCLayerTreeHostImpl::setPageScaleFactorLimits):
(WebCore::CCLayerTreeHostImpl::updateMaxScrollPosition):
(WebCore::CCLayerTreeHostImpl::pinchGestureBegin):
(WebCore::CCLayerTreeHostImpl::pinchGestureUpdate):
(WebCore::CCLayerTreeHostImpl::pinchGestureEnd):
(WebCore::CCLayerTreeHostImpl::processScrollDeltas):

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

(WebCore::CCLayerTreeHostImpl::pageScale):

  • platform/graphics/chromium/cc/CCScrollController.h:
  • platform/graphics/chromium/cc/CCSingleThreadProxy.cpp:

(WebCore::CCSingleThreadProxy::doCommit):

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

(WebCore::CCThreadProxy::createBeginFrameAndCommitTaskOnImplThread):
(WebCore::CCThreadProxy::beginFrameAndCommit):

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

Source/WebKit/chromium:

  • public/WebLayerTreeViewClient.h:
  • public/WebView.h:
  • src/WebCompositorImpl.cpp:
  • src/WebLayerTreeViewImpl.cpp:

(WebKit::WebLayerTreeViewImpl::applyScrollAndScale):

  • src/WebLayerTreeViewImpl.h:
  • src/WebViewImpl.cpp:

(WebKit::WebViewImpl::enableFixedLayoutMode):
(WebKit::WebViewImpl::setPageScaleFactorLimits):
(WebKit::WebViewImpl::applyScrollAndScale):
(WebKit::WebViewImpl::updateLayerTreeViewport):

  • src/WebViewImpl.h:
  • tests/CCLayerTreeHostImplTest.cpp:

(WebKit::CCLayerTreeHostImplTest::expectContains):
(WebKit::TEST_F):

  • tests/CCLayerTreeHostTest.cpp:

(WTF::TestHooks::applyScrollAndScale):
(WTF::MockLayerTreeHostClient::applyScrollAndScale):
(WTF::CCLayerTreeHostTestScrollSimple::beginTest):
(WTF::CCLayerTreeHostTestScrollSimple::drawLayersOnCCThread):
(WTF::CCLayerTreeHostTestScrollSimple::applyScrollAndScale):
(WTF::CCLayerTreeHostTestScrollMultipleRedraw::beginTest):
(WTF::CCLayerTreeHostTestScrollMultipleRedraw::drawLayersOnCCThread):
(WTF::CCLayerTreeHostTestScrollMultipleRedraw::applyScrollAndScale):

Location:
trunk/Source
Files:
31 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r99766 r99774  
     12011-11-09  Alexandre Elias  <aelias@google.com>
     2
     3        [chromium] Add draw-time scale delta to compositor thread
     4        https://bugs.webkit.org/show_bug.cgi?id=71595
     5
     6        Reviewed by James Robinson.
     7
     8        There are two magnify values:
     9        1. The WebKit-side pageScale value corresponding to the resolution of
     10           the painted content.
     11        2. The Impl-side-only scaleDelta value representing the additional
     12           degree of current magnification, applied as a draw transform.  WebKit
     13           is never explicitly aware of this value and the only way to change it
     14           currently is via pinch events (and in the future, double-tap/etc
     15           events).  At the end of a pinch zoom, we multiply pageScale *
     16           scaleDelta and tell WebKit to use it as the new pageScale.
     17
     18        Scroll offsets and max-extents are maintained in pageScale space.
     19        When the scale changes, we need to take care to convert them to the
     20        new scale and avoid getting them clamped to the extents at the wrong
     21        scale.
     22
     23        I removed maxScrollPosition on the non-impl side because it makes no
     24        sense to precompute it in the presence of an impl-side zoom.  Replaced
     25        with a simple 'bool m_scrollable'.
     26
     27        zoomAnimatorTransform is not used because it currently isn't in the
     28        branch, and mostly doesn't behave the way we want anyway (it does most
     29        things in WebKit thread).  We will need to unify these later.
     30
     31        Also introduce deviceOrPageScaleFactorChanged() call which invalidates
     32        layers.
     33
     34        No new tests (filed 71529 to remember to do it later).
     35
     36        * platform/graphics/chromium/GraphicsLayerChromium.cpp:
     37        (WebCore::GraphicsLayerChromium::deviceOrPageScaleFactorChanged):
     38        * platform/graphics/chromium/GraphicsLayerChromium.h:
     39        * platform/graphics/chromium/LayerChromium.cpp:
     40        (WebCore::LayerChromium::LayerChromium):
     41        (WebCore::LayerChromium::setBounds):
     42        (WebCore::LayerChromium::pushPropertiesTo):
     43        * platform/graphics/chromium/LayerChromium.h:
     44        (WebCore::LayerChromium::scrollable):
     45        (WebCore::LayerChromium::setScrollable):
     46        (WebCore::LayerChromium::pageScaleChanged):
     47        * platform/graphics/chromium/LayerRendererChromium.cpp:
     48        (WebCore::LayerRendererChromium::drawLayersInternal):
     49        * platform/graphics/chromium/LayerRendererChromium.h:
     50        (WebCore::LayerRendererChromium::setPageMagnifyTransform):
     51        * platform/graphics/chromium/NonCompositedContentHost.cpp:
     52        (WebCore::NonCompositedContentHost::setViewport):
     53        * platform/graphics/chromium/NonCompositedContentHost.h:
     54        (WebCore::NonCompositedContentHost::topLevelRootLayer):
     55        * platform/graphics/chromium/cc/CCLayerImpl.cpp:
     56        (WebCore::CCLayerImpl::CCLayerImpl):
     57        * platform/graphics/chromium/cc/CCLayerImpl.h:
     58        (WebCore::CCLayerImpl::scrollable):
     59        (WebCore::CCLayerImpl::setScrollable):
     60        * platform/graphics/chromium/cc/CCLayerTreeHost.cpp:
     61        (WebCore::CCLayerTreeHost::CCLayerTreeHost):
     62        (WebCore::CCLayerTreeHost::finishCommitOnImplThread):
     63        (WebCore::CCLayerTreeHost::setPageScale):
     64        (WebCore::CCLayerTreeHost::setPageScaleFactorLimits):
     65        (WebCore::CCLayerTreeHost::applyScrollAndScale):
     66        * platform/graphics/chromium/cc/CCLayerTreeHost.h:
     67        (WebCore::CCLayerTreeHost::pageScale):
     68        * platform/graphics/chromium/cc/CCLayerTreeHostCommon.h:
     69        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:
     70        (WebCore::CCLayerTreeHostImpl::CCLayerTreeHostImpl):
     71        (WebCore::CCLayerTreeHostImpl::commitComplete):
     72        (WebCore::findScrollLayer):
     73        (WebCore::CCLayerTreeHostImpl::setViewport):
     74        (WebCore::CCLayerTreeHostImpl::setPageScale):
     75        (WebCore::CCLayerTreeHostImpl::setScaleDelta):
     76        (WebCore::CCLayerTreeHostImpl::setPageScaleFactorLimits):
     77        (WebCore::CCLayerTreeHostImpl::updateMaxScrollPosition):
     78        (WebCore::CCLayerTreeHostImpl::pinchGestureBegin):
     79        (WebCore::CCLayerTreeHostImpl::pinchGestureUpdate):
     80        (WebCore::CCLayerTreeHostImpl::pinchGestureEnd):
     81        (WebCore::CCLayerTreeHostImpl::processScrollDeltas):
     82        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.h:
     83        (WebCore::CCLayerTreeHostImpl::pageScale):
     84        * platform/graphics/chromium/cc/CCScrollController.h:
     85        * platform/graphics/chromium/cc/CCSingleThreadProxy.cpp:
     86        (WebCore::CCSingleThreadProxy::doCommit):
     87        * platform/graphics/chromium/cc/CCThreadProxy.cpp:
     88        (WebCore::CCThreadProxy::createBeginFrameAndCommitTaskOnImplThread):
     89        (WebCore::CCThreadProxy::beginFrameAndCommit):
     90        * platform/graphics/chromium/cc/CCThreadProxy.h:
     91
    1922011-11-09  Jay Civelli  <jcivelli@chromium.org>
    293

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

    r98471 r99774  
    671671}
    672672
     673void GraphicsLayerChromium::deviceOrPageScaleFactorChanged()
     674{
     675    if (m_layer)
     676        m_layer->pageScaleChanged();
     677}
     678
    673679bool GraphicsLayerChromium::drawsContent() const
    674680{

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

    r95901 r99774  
    101101    virtual void notifySyncRequired();
    102102
     103    virtual void deviceOrPageScaleFactorChanged();
    103104private:
    104105    void updateOpacityOnLayer();

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

    r99327 r99774  
    5959    , m_layerId(s_nextLayerId++)
    6060    , m_parent(0)
     61    , m_scrollable(false)
    6162    , m_anchorPoint(0.5, 0.5)
    6263    , m_backgroundColor(0, 0, 0, 0)
    … …  
    7374    , m_drawOpacity(0)
    7475    , m_targetRenderSurface(0)
     76    , m_pageScaleDirty(false)
    7577{
    7678}
    … …  
    211213    m_bounds = size;
    212214
    213     if (firstResize)
     215    if (firstResize || m_pageScaleDirty)
    214216        setNeedsDisplay(FloatRect(0, 0, bounds().width(), bounds().height()));
    215217    else
    216218        setNeedsCommit();
     219
     220    m_pageScaleDirty = false;
    217221}
    218222
    … …  
    288292    layer->setIsNonCompositedContent(m_isNonCompositedContent);
    289293    layer->setMasksToBounds(m_masksToBounds);
    290     layer->setMaxScrollPosition(m_maxScrollPosition);
     294    layer->setScrollable(m_scrollable);
    291295    layer->setName(m_name);
    292296    layer->setOpaque(m_opaque);

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

    r99327 r99774  
    132132    void setScrollPosition(const IntPoint& scrollPosition) { m_scrollPosition = scrollPosition; }
    133133
    134     const IntSize& maxScrollPosition() const {return m_maxScrollPosition; }
    135     void setMaxScrollPosition(const IntSize& maxScrollPosition) { m_maxScrollPosition = maxScrollPosition; }
     134    bool scrollable() const { return m_scrollable; }
     135    void setScrollable(bool scrollable) { m_scrollable = true;  setNeedsCommit(); }
    136136
    137137    IntSize scrollDelta() const { return IntSize(); }
    138 
    139     bool scrollable() const { return !maxScrollPosition().isZero(); }
    140138
    141139    bool doubleSided() const { return m_doubleSided; }
    … …  
    165163    virtual void unreserveContentsTexture() { }
    166164    virtual void bindContentsTexture() { }
     165    virtual void pageScaleChanged() { m_pageScaleDirty = true; }
    167166    virtual void protectVisibleTileTextures() { }
    168167
    … …  
    253252    IntRect m_visibleLayerRect;
    254253    IntPoint m_scrollPosition;
    255     IntSize m_maxScrollPosition;
     254    bool m_scrollable;
    256255    FloatPoint m_position;
    257256    FloatPoint m_anchorPoint;
    … …  
    284283
    285284    String m_name;
     285
     286    bool m_pageScaleDirty;
    286287};
    287288

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

    r99327 r99774  
    362362    m_defaultRenderSurface->clearLayerList();
    363363
     364    TransformationMatrix magnifyMatrix(m_pageMagnifyMatrix);
     365    // TODO(aelias): These two transformations are redundant; unify zoomAnimator
     366    // and impl-thread side matrix.
     367    magnifyMatrix.multiply(m_zoomAnimatorTransform);
     368
    364369    {
    365370        TRACE_EVENT("LayerRendererChromium::drawLayersInternal::calcDrawEtc", this, 0);
    366         CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(rootDrawLayer, rootDrawLayer, m_zoomAnimatorTransform, m_zoomAnimatorTransform, renderSurfaceLayerList, m_defaultRenderSurface->layerList(), &m_layerSorter, m_capabilities.maxTextureSize);
     371        CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(rootDrawLayer, rootDrawLayer, magnifyMatrix, magnifyMatrix, renderSurfaceLayerList, m_defaultRenderSurface->layerList(), &m_layerSorter, m_capabilities.maxTextureSize);
    367372    }
    368373

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

    r98313 r99774  
    9999    void viewportChanged();
    100100
     101    void setPageMagnifyTransform(const TransformationMatrix& pageMagnifyMatrix) { m_pageMagnifyMatrix = pageMagnifyMatrix; }
     102
    101103    void drawLayers();
    102104
    … …  
    196198    TransformationMatrix m_projectionMatrix;
    197199    TransformationMatrix m_windowMatrix;
     200    TransformationMatrix m_pageMagnifyMatrix;
    198201
    199202    CCRenderSurface* m_currentRenderSurface;

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

    r99295 r99774  
    7575}
    7676
    77 void NonCompositedContentHost::setViewport(const IntSize& viewportSize, const IntSize& contentsSize, const IntPoint& scrollPosition)
     77void NonCompositedContentHost::setViewport(const IntSize& viewportSize, const IntSize& contentsSize, const IntPoint& scrollPosition, float pageScale)
    7878{
    7979    if (!scrollLayer())
    … …  
    8484    m_viewportSize = viewportSize;
    8585    scrollLayer()->setScrollPosition(scrollPosition);
    86     IntSize maxScroll = contentsSize - viewportSize;
    87     // The viewport may be larger than the contents in some cases, such as
    88     // having a vertical scrollbar but no horizontal overflow.
    89     maxScroll.clampNegativeToZero();
    90 
    91     scrollLayer()->setMaxScrollPosition(maxScroll);
     86    // Due to the possibility of pinch zoom, the noncomposited layer is always
     87    // assumed to be scrollable.
     88    scrollLayer()->setScrollable(true);
    9289    m_graphicsLayer->setSize(contentsSize);
    9390
    9491    if (visibleRectChanged)
    9592        m_graphicsLayer->setNeedsDisplay();
     93
     94    if (m_graphicsLayer->pageScaleFactor() != pageScale)
     95        m_graphicsLayer->deviceOrPageScaleFactorChanged();
    9696}
    9797

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

    r99295 r99774  
    5656    void setBackgroundColor(const Color&);
    5757    void setScrollLayer(GraphicsLayer*);
    58     void setViewport(const IntSize& viewportSize, const IntSize& contentsSize, const IntPoint& scrollPosition);
     58    void setViewport(const IntSize& viewportSize, const IntSize& contentsSize, const IntPoint& scrollPosition, float pageScale);
    5959    void protectVisibleTileTextures();
     60    GraphicsLayer* topLevelRootLayer() const { return m_graphicsLayer.get(); }
    6061
    6162private:

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

    r99327 r99774  
    4343    , m_anchorPoint(0.5, 0.5)
    4444    , m_anchorPointZ(0)
     45    , m_scrollable(false)
    4546    , m_doubleSided(true)
    4647    , m_layerPropertyChanged(false)

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

    r99327 r99774  
    159159
    160160    void scrollBy(const IntSize& scroll);
    161     bool scrollable() const { return !maxScrollPosition().isZero(); }
     161
     162    bool scrollable() const { return m_scrollable; }
     163    void setScrollable(bool scrollable) { m_scrollable = scrollable; }
    162164
    163165    const IntRect& visibleLayerRect() const { return m_visibleLayerRect; }
    … …  
    217219    IntSize m_contentBounds;
    218220    IntPoint m_scrollPosition;
    219     IntSize m_maxScrollPosition;
     221    bool m_scrollable;
    220222    Color m_backgroundColor;
    221223
    … …  
    240242
    241243    IntSize m_scrollDelta;
     244    IntSize m_maxScrollPosition;
    242245
    243246    // Properties owned exclusively by this CCLayerImpl.

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

    r99327 r99774  
    5757    , m_visible(true)
    5858    , m_haveWheelEventHandlers(false)
     59    , m_pageScale(1)
     60    , m_minPageScale(1)
     61    , m_maxPageScale(1)
    5962{
    6063    CCMainThread::initialize();
    … …  
    131134    hostImpl->setZoomAnimatorTransform(m_zoomAnimatorTransform);
    132135    hostImpl->setViewport(viewportSize());
     136    hostImpl->setPageScale(pageScale());
     137    hostImpl->setPageScaleFactorLimits(m_minPageScale, m_maxPageScale);
    133138
    134139    // Synchronize trees, if one exists at all...
    … …  
    222227{
    223228    m_viewportSize = viewportSize;
     229    setNeedsCommit();
     230}
     231
     232void CCLayerTreeHost::setPageScale(float pageScale)
     233{
     234    if (pageScale == m_pageScale)
     235        return;
     236
     237    m_pageScale = pageScale;
     238    setNeedsCommit();
     239}
     240
     241void CCLayerTreeHost::setPageScaleFactorLimits(float minScale, float maxScale)
     242{
     243    if (minScale == m_minPageScale && maxScale == m_maxPageScale)
     244        return;
     245
     246    m_minPageScale = minScale;
     247    m_maxPageScale = maxScale;
    224248    setNeedsCommit();
    225249}
    … …  
    438462}
    439463
    440 void CCLayerTreeHost::applyScrollDeltas(const CCScrollUpdateSet& info)
     464void CCLayerTreeHost::applyScrollAndScale(const CCScrollAndScaleSet& info)
    441465{
    442466    // FIXME: pushing scroll offsets to non-root layers not implemented
    443     if (!info.size())
    444         return;
    445 
    446     ASSERT(info.size() == 1);
    447     IntSize scrollDelta = info[0].scrollDelta;
    448     m_client->applyScrollDelta(scrollDelta);
     467    if (!info.scrolls.size())
     468        return;
     469
     470    ASSERT(info.scrolls.size() == 1);
     471    IntSize scrollDelta = info.scrolls[0].scrollDelta;
     472    m_client->applyScrollAndScale(scrollDelta, info.pageScale);
    449473}
    450474

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

    r99286 r99774  
    5555public:
    5656    virtual void animateAndLayout(double frameBeginTime) = 0;
    57     virtual void applyScrollDelta(const IntSize&) = 0;
     57    virtual void applyScrollAndScale(const IntSize& scrollDelta, float pageScale) = 0;
    5858    virtual PassRefPtr<GraphicsContext3D> createLayerTreeHostContext3D() = 0;
    5959    virtual void didRecreateGraphicsContext(bool success) = 0;
    … …  
    159159
    160160    const IntSize& viewportSize() const { return m_viewportSize; }
     161
     162    void setPageScale(float);
     163    float pageScale() const { return m_pageScale; }
     164
     165    void setPageScaleFactorLimits(float minScale, float maxScale);
     166
    161167    TextureManager* contentsTextureManager() const;
    162168
    … …  
    169175
    170176    void updateCompositorResources(GraphicsContext3D*, CCTextureUpdater&);
    171     void applyScrollDeltas(const CCScrollUpdateSet&);
     177    void applyScrollAndScale(const CCScrollAndScaleSet&);
    172178    void startRateLimiter(GraphicsContext3D*);
    173179    void stopRateLimiter(GraphicsContext3D*);
    … …  
    210216    typedef HashMap<GraphicsContext3D*, RefPtr<RateLimiter> > RateLimiterMap;
    211217    RateLimiterMap m_rateLimiters;
     218
     219    float m_pageScale;
     220    float m_minPageScale, m_maxPageScale;
    212221};
    213222

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

    r99327 r99774  
    5252};
    5353
    54 typedef Vector<CCLayerTreeHostCommon::ScrollUpdateInfo> CCScrollUpdateSet;
     54struct CCScrollAndScaleSet {
     55    Vector<CCLayerTreeHostCommon::ScrollUpdateInfo> scrolls;
     56    float pageScale;
     57};
    5558
    5659template<typename LayerType>

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

    r99286 r99774  
    5151    , m_visible(true)
    5252    , m_haveWheelEventHandlers(false)
     53    , m_pageScale(1)
     54    , m_scaleDelta(1)
     55    , m_minPageScale(0)
     56    , m_maxPageScale(0)
     57    , m_pinchGestureActive(false)
    5358{
    5459    ASSERT(CCProxy::isImplThread());
    … …  
    6974void CCLayerTreeHostImpl::commitComplete()
    7075{
     76    // Recompute max scroll position; must be after layer content bounds are
     77    // updated.
     78    updateMaxScrollPosition();
    7179}
    7280
    … …  
    129137        return 0;
    130138
    131     if (!layer->maxScrollPosition().isZero())
     139    if (layer->scrollable())
    132140        return layer;
    133141
    … …  
    181189void CCLayerTreeHostImpl::setViewport(const IntSize& viewportSize)
    182190{
    183     bool changed = viewportSize != m_viewportSize;
     191    if (viewportSize == m_viewportSize)
     192        return;
     193
    184194    m_viewportSize = viewportSize;
    185     if (changed)
    186         m_layerRenderer->viewportChanged();
     195    updateMaxScrollPosition();
     196    m_layerRenderer->viewportChanged();
     197}
     198
     199void CCLayerTreeHostImpl::setPageScale(float pageScale)
     200{
     201    if (!pageScale || pageScale == m_pageScale)
     202        return;
     203
     204    // Maintain constant the product of m_pageScale * m_scaleDelta.
     205    float scaleChange = pageScale / m_pageScale;
     206    float oldMagnifyScale = m_pageScale * m_scaleDelta;
     207    m_pageScale = pageScale;
     208
     209    setScaleDelta(oldMagnifyScale / pageScale);
     210
     211    // We also need to convert impl-side scroll deltas to pageScale space.
     212    if (m_scrollLayerImpl && m_scrollLayerImpl->scrollable()) {
     213        IntSize scrollDelta = m_scrollLayerImpl->scrollDelta();
     214        scrollDelta.scale(scaleChange);
     215        m_scrollLayerImpl->setScrollDelta(scrollDelta);
     216    }
     217}
     218
     219void CCLayerTreeHostImpl::setScaleDelta(float delta)
     220{
     221    // Clamp to the current min/max limits.
     222    float finalMagnifyScale = m_pageScale * delta;
     223    if (m_minPageScale && finalMagnifyScale < m_minPageScale)
     224        delta = m_minPageScale / m_pageScale;
     225    else if (m_maxPageScale && finalMagnifyScale > m_maxPageScale)
     226        delta = m_maxPageScale / m_pageScale;
     227
     228    if (delta == m_scaleDelta)
     229        return;
     230
     231    m_scaleDelta = delta;
     232
     233    updateMaxScrollPosition();
     234
     235    TransformationMatrix deltaMatrix;
     236    deltaMatrix.scale(m_scaleDelta);
     237    m_layerRenderer->setPageMagnifyTransform(deltaMatrix);
     238}
     239
     240void CCLayerTreeHostImpl::setPageScaleFactorLimits(float minPageScale, float maxPageScale)
     241{
     242    m_minPageScale = minPageScale;
     243    m_maxPageScale = maxPageScale;
     244
     245    // This will clamp m_scaleDelta and apply side effects if clamped.
     246    setScaleDelta(m_scaleDelta);
     247}
     248
     249void CCLayerTreeHostImpl::updateMaxScrollPosition()
     250{
     251    if (!m_scrollLayerImpl || !m_scrollLayerImpl->children().size())
     252        return;
     253
     254    FloatSize viewBounds = m_viewportSize;
     255    viewBounds.scale(1 / m_scaleDelta);
     256
     257    // TODO(aelias): Hardcoding the first child here is weird. Think of
     258    // a cleaner way to get the contentBounds on the Impl side.
     259    IntSize maxScroll = m_scrollLayerImpl->children()[0]->contentBounds() - expandedIntSize(viewBounds);
     260    // The viewport may be larger than the contents in some cases, such as
     261    // having a vertical scrollbar but no horizontal overflow.
     262    maxScroll.clampNegativeToZero();
     263
     264    m_scrollLayerImpl->setMaxScrollPosition(maxScroll);
     265
     266    // TODO(aelias): Also update sublayers.
    187267}
    188268
    … …  
    208288}
    209289
    210 PassOwnPtr<CCScrollUpdateSet> CCLayerTreeHostImpl::processScrollDeltas()
    211 {
    212     OwnPtr<CCScrollUpdateSet> scrollInfo = adoptPtr(new CCScrollUpdateSet());
     290void CCLayerTreeHostImpl::pinchGestureBegin()
     291{
     292    m_pinchGestureActive = true;
     293}
     294
     295void CCLayerTreeHostImpl::pinchGestureUpdate(float magnifyDelta,
     296                                             const IntPoint& anchor)
     297{
     298    TRACE_EVENT("CCLayerTreeHostImpl::pinchGestureUpdate", this, 0);
     299
     300    if (magnifyDelta == 1.0)
     301        return;
     302    if (!m_scrollLayerImpl)
     303        return;
     304
     305    // Keep the center-of-pinch anchor specified by (x, y) in a stable
     306    // position over the course of the magnify.
     307    FloatPoint prevScaleAnchor(anchor.x() / m_scaleDelta, anchor.y() / m_scaleDelta);
     308    setScaleDelta(m_scaleDelta * magnifyDelta);
     309    FloatPoint newScaleAnchor(anchor.x() / m_scaleDelta, anchor.y() / m_scaleDelta);
     310
     311    FloatSize move = prevScaleAnchor - newScaleAnchor;
     312
     313    scrollRootLayer(roundedIntSize(move));
     314
     315    m_client->setNeedsRedrawOnImplThread();
     316}
     317
     318void CCLayerTreeHostImpl::pinchGestureEnd()
     319{
     320    m_pinchGestureActive = false;
     321
     322    m_client->setNeedsCommitOnImplThread();
     323}
     324
     325PassOwnPtr<CCScrollAndScaleSet> CCLayerTreeHostImpl::processScrollDeltas()
     326{
     327    OwnPtr<CCScrollAndScaleSet> scrollInfo = adoptPtr(new CCScrollAndScaleSet());
     328    bool didMove = m_scrollLayerImpl && (!m_scrollLayerImpl->scrollDelta().isZero() || m_scaleDelta != 1.0f);
     329    if (!didMove || m_pinchGestureActive) {
     330        scrollInfo->pageScale = m_pageScale;
     331        return scrollInfo.release();
     332    }
     333
    213334    // FIXME: track scrolls from layers other than the root
    214     if (m_scrollLayerImpl && !m_scrollLayerImpl->scrollDelta().isZero()) {
    215         CCLayerTreeHostCommon::ScrollUpdateInfo info;
    216         info.layerId = m_scrollLayerImpl->id();
    217         info.scrollDelta = m_scrollLayerImpl->scrollDelta();
    218         scrollInfo->append(info);
    219 
    220         m_scrollLayerImpl->setScrollPosition(m_scrollLayerImpl->scrollPosition() + m_scrollLayerImpl->scrollDelta());
    221         m_scrollLayerImpl->setPosition(m_scrollLayerImpl->position() - m_scrollLayerImpl->scrollDelta());
    222         m_scrollLayerImpl->setScrollDelta(IntSize());
    223     }
     335    scrollInfo->pageScale = m_pageScale * m_scaleDelta;
     336    CCLayerTreeHostCommon::ScrollUpdateInfo scroll;
     337    scroll.layerId = m_scrollLayerImpl->id();
     338    scroll.scrollDelta = m_scrollLayerImpl->scrollDelta();
     339    scrollInfo->scrolls.append(scroll);
     340
     341    m_scrollLayerImpl->setScrollPosition(m_scrollLayerImpl->scrollPosition() + m_scrollLayerImpl->scrollDelta());
     342    m_scrollLayerImpl->setPosition(m_scrollLayerImpl->position() - m_scrollLayerImpl->scrollDelta());
     343    m_scrollLayerImpl->setScrollDelta(IntSize());
     344
    224345    return scrollInfo.release();
    225346}

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

    r99286 r99774  
    9898    void setZoomAnimatorTransform(const TransformationMatrix&);
    9999
     100    void setPageScale(float);
     101    float pageScale() const { return m_pageScale; }
     102    void setPageScaleFactorLimits(float minPageScale, float maxPageScale);
     103
    100104    const CCSettings& settings() const { return m_settings; }
    101105
    102     PassOwnPtr<CCScrollUpdateSet> processScrollDeltas();
     106    virtual void pinchGestureBegin();
     107    virtual void pinchGestureUpdate(float, const IntPoint&);
     108    virtual void pinchGestureEnd();
     109    PassOwnPtr<CCScrollAndScaleSet> processScrollDeltas();
     110    void updateMaxScrollPosition();
    103111
    104112protected:
    … …  
    109117
    110118private:
     119    void setScaleDelta(float);
     120
    111121    OwnPtr<LayerRendererChromium> m_layerRenderer;
    112122    RefPtr<CCLayerImpl> m_rootLayerImpl;
    … …  
    116126    bool m_visible;
    117127    bool m_haveWheelEventHandlers;
     128
     129    float m_pageScale;
     130    float m_scaleDelta;
     131    float m_minPageScale, m_maxPageScale;
     132
     133    bool m_pinchGestureActive;
    118134};
    119135

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

    r98778 r99774  
    3737    virtual void scrollRootLayer(const IntSize&) = 0;
    3838    virtual bool haveWheelEventHandlers() = 0;
     39    virtual void pinchGestureBegin() = 0;
     40    virtual void pinchGestureUpdate(float magnifyDelta, const IntPoint& anchor) = 0;
     41    virtual void pinchGestureEnd() = 0;
    3942
    4043protected:

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

    r99033 r99774  
    167167        // In the single-threaded case, the scroll deltas should never be
    168168        // touched on the impl layer tree.
    169         OwnPtr<CCScrollUpdateSet> scrollInfo = m_layerTreeHostImpl->processScrollDeltas();
    170         ASSERT(!scrollInfo->size());
     169        OwnPtr<CCScrollAndScaleSet> scrollInfo = m_layerTreeHostImpl->processScrollDeltas();
     170        ASSERT(!scrollInfo->scrolls.size());
    171171#endif
    172172    }

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

    r99253 r99774  
    342342    int thisTaskSequenceNumber = m_numBeginFrameAndCommitsIssuedOnImplThread;
    343343    m_numBeginFrameAndCommitsIssuedOnImplThread++;
    344     OwnPtr<CCScrollUpdateSet> scrollInfo = m_layerTreeHostImpl->processScrollDeltas();
     344    OwnPtr<CCScrollAndScaleSet> scrollInfo = m_layerTreeHostImpl->processScrollDeltas();
    345345    return createMainThreadTask(this, &CCThreadProxy::beginFrameAndCommit, thisTaskSequenceNumber, frameBeginTime, scrollInfo.release());
    346346}
    347347
    348 void CCThreadProxy::beginFrameAndCommit(int sequenceNumber, double frameBeginTime, PassOwnPtr<CCScrollUpdateSet> scrollInfo)
     348void CCThreadProxy::beginFrameAndCommit(int sequenceNumber, double frameBeginTime, PassOwnPtr<CCScrollAndScaleSet> scrollInfo)
    349349{
    350350    TRACE_EVENT("CCThreadProxy::beginFrameAndCommit", this, 0);
    … …  
    354354
    355355    // Scroll deltas need to be applied even if the commit will be dropped.
    356     m_layerTreeHost->applyScrollDeltas(*scrollInfo.get());
     356    m_layerTreeHost->applyScrollAndScale(*scrollInfo.get());
    357357
    358358    // Drop beginFrameAndCommit calls that occur out of sequence. See createBeginFrameAndCommitTaskOnImplThread for

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

    r99253 r99774  
    8282
    8383    // Called on CCMainThread
    84     void beginFrameAndCommit(int sequenceNumber, double frameBeginTime, PassOwnPtr<CCScrollUpdateSet>);
     84    void beginFrameAndCommit(int sequenceNumber, double frameBeginTime, PassOwnPtr<CCScrollAndScaleSet>);
    8585    void didCommitAndDrawFrame(int frameNumber);
    8686

  • trunk/Source/WebKit/chromium/ChangeLog

    r99770 r99774  
     12011-11-09  Alexandre Elias  <aelias@google.com>
     2
     3        [chromium] Add draw-time scale delta to compositor thread
     4        https://bugs.webkit.org/show_bug.cgi?id=71595
     5
     6        Reviewed by James Robinson.
     7
     8        There are two magnify values:
     9        1. The WebKit-side pageScale value corresponding to the resolution of
     10           the painted content.
     11        2. The Impl-side-only scaleDelta value representing the additional
     12           degree of current magnification, applied as a draw transform.  WebKit
     13           is never explicitly aware of this value and the only way to change it
     14           currently is via pinch events (and in the future, double-tap/etc
     15           events).  At the end of a pinch zoom, we multiply pageScale *
     16           scaleDelta and tell WebKit to use it as the new pageScale.
     17
     18        Scroll offsets and max-extents are maintained in pageScale space.
     19        When the scale changes, we need to take care to convert them to the
     20        new scale and avoid getting them clamped to the extents at the wrong
     21        scale.
     22
     23        I removed maxScrollPosition on the non-impl side because it makes no
     24        sense to precompute it in the presence of an impl-side zoom.  Replaced
     25        with a simple 'bool m_scrollable'.
     26
     27        zoomAnimatorTransform is not used because it currently isn't in the
     28        branch, and mostly doesn't behave the way we want anyway (it does most
     29        things in WebKit thread).  We will need to unify these later.
     30
     31        Also introduce deviceOrPageScaleFactorChanged() call which invalidates
     32        layers.
     33
     34        * public/WebLayerTreeViewClient.h:
     35        * public/WebView.h:
     36        * src/WebCompositorImpl.cpp:
     37        * src/WebLayerTreeViewImpl.cpp:
     38        (WebKit::WebLayerTreeViewImpl::applyScrollAndScale):
     39        * src/WebLayerTreeViewImpl.h:
     40        * src/WebViewImpl.cpp:
     41        (WebKit::WebViewImpl::enableFixedLayoutMode):
     42        (WebKit::WebViewImpl::setPageScaleFactorLimits):
     43        (WebKit::WebViewImpl::applyScrollAndScale):
     44        (WebKit::WebViewImpl::updateLayerTreeViewport):
     45        * src/WebViewImpl.h:
     46        * tests/CCLayerTreeHostImplTest.cpp:
     47        (WebKit::CCLayerTreeHostImplTest::expectContains):
     48        (WebKit::TEST_F):
     49        * tests/CCLayerTreeHostTest.cpp:
     50        (WTF::TestHooks::applyScrollAndScale):
     51        (WTF::MockLayerTreeHostClient::applyScrollAndScale):
     52        (WTF::CCLayerTreeHostTestScrollSimple::beginTest):
     53        (WTF::CCLayerTreeHostTestScrollSimple::drawLayersOnCCThread):
     54        (WTF::CCLayerTreeHostTestScrollSimple::applyScrollAndScale):
     55        (WTF::CCLayerTreeHostTestScrollMultipleRedraw::beginTest):
     56        (WTF::CCLayerTreeHostTestScrollMultipleRedraw::drawLayersOnCCThread):
     57        (WTF::CCLayerTreeHostTestScrollMultipleRedraw::applyScrollAndScale):
     58
    1592011-11-09  Dominic Mazzoni  <dmazzoni@google.com>
    260

  • trunk/Source/WebKit/chromium/public/WebLayerTreeViewClient.h

    r96990 r99774  
    3838    virtual void animateAndLayout(double frameBeginTime) = 0;
    3939
    40     // Applies a scroll delta to the root layer. This is triggered by events
    41     // sent to the compositor thread through the WebCompositor interface.
    42     virtual void applyScrollDelta(const WebSize&) = 0;
     40    // Applies a scroll delta to the root layer, which is bundled with a page
     41    // scale factor that may apply a CSS transform on the whole document (used
     42    // for mobile-device pinch zooming). This is triggered by events sent to the
     43    // compositor thread through the WebCompositor interface.
     44    virtual void applyScrollAndScale(const WebSize& scrollDelta, float scaleFactor) = 0;
    4345
    4446    // Creates a 3D context suitable for the compositing. This may be called

  • trunk/Source/WebKit/chromium/public/WebView.h

    r99624 r99774  
    208208    WEBKIT_EXPORT static double zoomFactorToZoomLevel(double factor);
    209209
     210    // PageScaleFactor will be force-clamped between minPageScale and maxPageScale
     211    // (and these values will persist until setPageScaleFactorLimits is called
     212    // again).
     213    virtual void setPageScaleFactorLimits(float minPageScale, float maxPageScale) = 0;
     214
    210215    // Gets the scale factor of the page, where 1.0 is the normal size, > 1.0
    211216    // is scaled up, < 1.0 is scaled down.

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

    r98778 r99774  
    134134
    135135}
    136 

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

    r99286 r99774  
    6666}
    6767
    68 void WebLayerTreeViewImpl::applyScrollDelta(const WebCore::IntSize& delta)
     68void WebLayerTreeViewImpl::applyScrollAndScale(const WebCore::IntSize& scrollDelta, float pageScale)
    6969{
    7070    if (m_client)
    71         m_client->applyScrollDelta(WebSize(delta));
     71        m_client->applyScrollAndScale(WebSize(scrollDelta), pageScale);
    7272}
    7373

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

    r98915 r99774  
    4343    virtual ~WebLayerTreeViewImpl();
    4444    virtual void animateAndLayout(double frameBeginTime);
    45     virtual void applyScrollDelta(const WebCore::IntSize&);
     45    virtual void applyScrollAndScale(const WebCore::IntSize& scrollDelta, float pageScale);
    4646    virtual PassRefPtr<WebCore::GraphicsContext3D> createLayerTreeHostContext3D();
    4747    virtual void didCommitAndDrawFrame(int frameNumber);

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

    r99659 r99774  
    18951895
    18961896    frame->view()->setUseFixedLayout(enable);
     1897
     1898#if USE(ACCELERATED_COMPOSITING)
     1899    // Also notify the base layer, which RenderLayerCompositor does not see.
     1900    if (m_nonCompositedContentHost) {
     1901        m_nonCompositedContentHost->topLevelRootLayer()->deviceOrPageScaleFactorChanged();
     1902        updateLayerTreeViewport();
     1903    }
     1904#endif
     1905}
     1906
     1907void WebViewImpl::setPageScaleFactorLimits(float minPageScale, float maxPageScale)
     1908{
     1909#if USE(ACCELERATED_COMPOSITING)
     1910    m_layerTreeHost->setPageScaleFactorLimits(minPageScale, maxPageScale);
     1911#endif
    18971912}
    18981913
    … …  
    27032718}
    27042719
    2705 void WebViewImpl::applyScrollDelta(const IntSize& scrollDelta)
     2720void WebViewImpl::applyScrollAndScale(const IntSize& scrollDelta, float scaleFactor)
    27062721{
    27072722    if (!mainFrameImpl() || !mainFrameImpl()->frameView())
    27082723        return;
    27092724
    2710     mainFrameImpl()->frameView()->scrollBy(scrollDelta);
     2725    float oldScale = pageScaleFactor();
     2726    if (!oldScale)
     2727        oldScale = 1.0f;
     2728
     2729    if (!scaleFactor || oldScale == scaleFactor)
     2730        mainFrameImpl()->frameView()->scrollBy(scrollDelta);
     2731    else {
     2732        // The page scale changed, so apply a scale and scroll in a single
     2733        // operation. The old scroll offset (and passed-in delta) are
     2734        // in the old coordinate space, so we first need to multiply them
     2735        // by the page scale delta.
     2736        WebSize scrollOffset = mainFrame()->scrollOffset();
     2737        scrollOffset.width += scrollDelta.width();
     2738        scrollOffset.height += scrollDelta.height();
     2739        float scaleDelta = scaleFactor / oldScale;
     2740        WebPoint scaledScrollOffset(scrollOffset.width * scaleDelta,
     2741                                    scrollOffset.height * scaleDelta);
     2742        setPageScaleFactor(scaleFactor, scaledScrollOffset);
     2743    }
    27112744}
    27122745
    … …  
    27432776void WebViewImpl::updateLayerTreeViewport()
    27442777{
    2745     if (!page())
     2778    if (!page() || !m_nonCompositedContentHost || !m_layerTreeHost)
    27462779        return;
    27472780
    … …  
    27502783    IntPoint scroll(view->scrollX(), view->scrollY());
    27512784
    2752     m_nonCompositedContentHost->setViewport(visibleRect.size(), view->contentsSize(), scroll);
     2785    m_nonCompositedContentHost->setViewport(visibleRect.size(), view->contentsSize(), scroll, pageScaleFactor());
    27532786    m_layerTreeHost->setViewport(visibleRect.size());
     2787    m_layerTreeHost->setPageScale(pageScaleFactor());
    27542788}
    27552789

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

    r99624 r99774  
    160160    virtual float pageScaleFactor() const;
    161161    virtual void setPageScaleFactor(float scaleFactor, const WebPoint& origin);
     162    virtual void setPageScaleFactorLimits(float minPageScale, float maxPageScale);
    162163    virtual float deviceScaleFactor() const;
    163164    virtual void setDeviceScaleFactor(float);
    … …  
    221222    // CCLayerTreeHostClient
    222223    virtual void animateAndLayout(double frameBeginTime);
    223     virtual void applyScrollDelta(const WebCore::IntSize&);
     224    virtual void applyScrollAndScale(const WebCore::IntSize&, float);
    224225    virtual PassRefPtr<WebCore::GraphicsContext3D> createLayerTreeHostContext3D();
    225226    virtual void didCommitAndDrawFrame(int frameNumber);

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

    r98567 r99774  
    6060    }
    6161
    62     static void expectContains(const CCScrollUpdateSet& scrollInfo, int id, const IntSize& scrollDelta)
     62    static void expectContains(const CCScrollAndScaleSet& scrollInfo, int id, const IntSize& scrollDelta)
    6363    {
    6464        int timesEncountered = 0;
    6565
    66         for (size_t i = 0; i < scrollInfo.size(); ++i) {
    67             if (scrollInfo[i].layerId != id)
     66        for (size_t i = 0; i < scrollInfo.scrolls.size(); ++i) {
     67            if (scrollInfo.scrolls[i].layerId != id)
    6868                continue;
    69             ASSERT_EQ(scrollInfo[i].scrollDelta, scrollDelta);
     69            ASSERT_EQ(scrollInfo.scrolls[i].scrollDelta, scrollDelta);
    7070            timesEncountered++;
    7171        }
    … …  
    8585    ASSERT_FALSE(m_hostImpl->rootLayer());
    8686
    87     OwnPtr<CCScrollUpdateSet> scrollInfo = m_hostImpl->processScrollDeltas();
    88     ASSERT_EQ(scrollInfo->size(), 0u);
     87    OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     88    ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
    8989}
    9090
    … …  
    101101    expectClearedScrollDeltasRecursive(root.get());
    102102
    103     OwnPtr<CCScrollUpdateSet> scrollInfo;
    104 
    105     scrollInfo = m_hostImpl->processScrollDeltas();
    106     ASSERT_EQ(scrollInfo->size(), 0u);
    107     expectClearedScrollDeltasRecursive(root.get());
    108 
    109     scrollInfo = m_hostImpl->processScrollDeltas();
    110     ASSERT_EQ(scrollInfo->size(), 0u);
     103    OwnPtr<CCScrollAndScaleSet> scrollInfo;
     104
     105    scrollInfo = m_hostImpl->processScrollDeltas();
     106    ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
     107    expectClearedScrollDeltasRecursive(root.get());
     108
     109    scrollInfo = m_hostImpl->processScrollDeltas();
     110    ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
    111111    expectClearedScrollDeltasRecursive(root.get());
    112112}
    … …  
    118118    RefPtr<CCLayerImpl> root = CCLayerImpl::create(10);
    119119    root->setScrollPosition(scrollPosition);
     120    root->setScrollable(true);
    120121    root->setMaxScrollPosition(IntSize(100, 100));
    121122    root->scrollBy(scrollDelta);
    122123    m_hostImpl->setRootLayer(root);
    123124
    124     OwnPtr<CCScrollUpdateSet> scrollInfo;
     125    OwnPtr<CCScrollAndScaleSet> scrollInfo;
    125126
    126127    scrollInfo = m_hostImpl->processScrollDeltas();
    127128    ASSERT_EQ(root->scrollPosition(), scrollPosition + scrollDelta);
    128     ASSERT_EQ(scrollInfo->size(), 1u);
     129    ASSERT_EQ(scrollInfo->scrolls.size(), 1u);
    129130    expectContains(*scrollInfo.get(), root->id(), scrollDelta);
    130131    expectClearedScrollDeltasRecursive(root.get());
    … …  
    134135    scrollInfo = m_hostImpl->processScrollDeltas();
    135136    ASSERT_EQ(root->scrollPosition(), scrollPosition + scrollDelta + scrollDelta2);
    136     ASSERT_EQ(scrollInfo->size(), 1u);
     137    ASSERT_EQ(scrollInfo->scrolls.size(), 1u);
    137138    expectContains(*scrollInfo.get(), root->id(), scrollDelta2);
    138139    expectClearedScrollDeltasRecursive(root.get());
    … …  
    141142    scrollInfo = m_hostImpl->processScrollDeltas();
    142143    ASSERT_EQ(root->scrollPosition(), scrollPosition + scrollDelta + scrollDelta2);
    143     ASSERT_EQ(scrollInfo->size(), 0u);
     144    ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
    144145    expectClearedScrollDeltasRecursive(root.get());
    145146}

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

    r99286 r99774  
    5858    virtual void commitCompleteOnCCThread(CCLayerTreeHostImpl*) { }
    5959    virtual void drawLayersOnCCThread(CCLayerTreeHostImpl*) { }
    60     virtual void applyScrollDelta(const IntSize&) { }
     60    virtual void applyScrollAndScale(const IntSize&, float) { }
    6161};
    6262
    … …  
    154154    }
    155155
    156     virtual void applyScrollDelta(const IntSize& scrollDelta)
    157     {
    158         m_testHooks->applyScrollDelta(scrollDelta);
     156    virtual void applyScrollAndScale(const IntSize& scrollDelta, float scale)
     157    {
     158        m_testHooks->applyScrollAndScale(scrollDelta, scale);
    159159    }
    160160
    … …  
    625625    virtual void beginTest()
    626626    {
    627         m_layerTreeHost->rootLayer()->setMaxScrollPosition(IntSize(100, 100));
     627        m_layerTreeHost->rootLayer()->setScrollable(true);
    628628        m_layerTreeHost->rootLayer()->setScrollPosition(m_initialScroll);
    629629        postSetNeedsCommitToMainThread();
    … …  
    648648        EXPECT_EQ(root->scrollDelta(), IntSize());
    649649
     650        root->setScrollable(true);
     651        root->setMaxScrollPosition(IntSize(100, 100));
    650652        root->scrollBy(m_scrollAmount);
    651653
    … …  
    661663    }
    662664
    663     virtual void applyScrollDelta(const IntSize& scrollDelta)
     665    virtual void applyScrollAndScale(const IntSize& scrollDelta, float scale)
    664666    {
    665667        IntPoint position = m_layerTreeHost->rootLayer()->scrollPosition();
    … …  
    695697    virtual void beginTest()
    696698    {
    697         m_layerTreeHost->rootLayer()->setMaxScrollPosition(IntSize(100, 100));
     699        m_layerTreeHost->rootLayer()->setScrollable(true);
    698700        m_layerTreeHost->rootLayer()->setScrollPosition(m_initialScroll);
    699701        postSetNeedsCommitToMainThread();
    … …  
    714716    {
    715717        CCLayerImpl* root = impl->rootLayer();
     718        root->setScrollable(true);
     719        root->setMaxScrollPosition(IntSize(100, 100));
    716720
    717721        if (impl->frameNumber() == 1) {
    … …  
    736740    }
    737741
    738     virtual void applyScrollDelta(const IntSize& scrollDelta)
     742    virtual void applyScrollAndScale(const IntSize& scrollDelta, float scale)
    739743    {
    740744        IntPoint position = m_layerTreeHost->rootLayer()->scrollPosition();

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

    r99327 r99774  
    647647    EXECUTE_AND_VERIFY_NOTIFY_SYNC_BEHAVIOR(mockDelegate, 1, testLayer->setPosition(FloatPoint(4.0f, 9.0f)));
    648648    EXECUTE_AND_VERIFY_NOTIFY_SYNC_BEHAVIOR(mockDelegate, 1, testLayer->setSublayerTransform(TransformationMatrix()));
     649    EXECUTE_AND_VERIFY_NOTIFY_SYNC_BEHAVIOR(mockDelegate, 1, testLayer->setScrollable(true));
    649650    EXECUTE_AND_VERIFY_NOTIFY_SYNC_BEHAVIOR(mockDelegate, 1, testLayer->setTransform(TransformationMatrix()));
    650651    EXECUTE_AND_VERIFY_NOTIFY_SYNC_BEHAVIOR(mockDelegate, 1, testLayer->setDoubleSided(false));
Note: See TracChangeset for help on using the changeset viewer.