Changeset 113791 in webkit


Ignore:
Timestamp:
Apr 10, 2012 4:40:51 PM (12 years ago)
Author:
yael.aharon@nokia.com
Message:

Initial support for fixed position elements in Qt WebKit2
​https://bugs.webkit.org/show_bug.cgi?id=81786

Reviewed by Noam Rosenthal.

.:

  • ManualTests/fixed-position.html: Added.

Source/WebCore:

When the setting acceleratedCompositingForFixedPositionEnabled is true, we update
the position of fixed layers, and send updates to the UI process as we scroll.
Before painting, TextureMapperLayer receives a delta of the scroll positions between the UI
and the web processes, and adjusts its transform position accordingly.

  • page/FrameView.cpp:

(WebCore::FrameView::setFixedVisibleContentRect):

  • platform/graphics/texmap/TextureMapperLayer.cpp:

(WebCore::TextureMapperLayer::setScrollPositionDelta):
(WebCore):

  • platform/graphics/texmap/TextureMapperLayer.h:

(TextureMapperLayer):

Source/WebKit2:

Turn on the flag acceleratedCompositingForFixedPositionEnabled when using fixed layout.
As we scroll, we keep track of the delta in scroll position between the UI and web processes,
and adjust the position of all the fixed layers by that delta.
When WebLayerTreeRenderer receives a new scroll position from the web process, it keeps it as pending,
and commit the new scroll position in flushLayerChanges.
This patch does not address scrolling overshoot and it does not fix the wrong positioning
that occurs when we zoom. These issues will be addressed in future patches.

  • Shared/WebLayerTreeInfo.h:
  • UIProcess/API/qt/qquickwebpage.cpp:

(QQuickWebPagePrivate::updateSize):

  • UIProcess/LayerTreeHostProxy.cpp:

(WebKit::LayerTreeHostProxy::setContentsSize):
(WebKit):
(WebKit::LayerTreeHostProxy::renderNextFrame):
(WebKit::LayerTreeHostProxy::didChangeScrollPosition):

  • UIProcess/LayerTreeHostProxy.h:

(LayerTreeHostProxy):

  • UIProcess/LayerTreeHostProxy.messages.in:
  • UIProcess/WebLayerTreeRenderer.cpp:

(WebKit::boundedScrollPosition):
(WebKit):
(WebKit::WebLayerTreeRenderer::paintToCurrentGLContext):
(WebKit::WebLayerTreeRenderer::setContentsSize):
(WebKit::WebLayerTreeRenderer::adjustPositionForFixedLayers):
(WebKit::WebLayerTreeRenderer::didChangeScrollPosition):
(WebKit::WebLayerTreeRenderer::syncLayerParameters):
(WebKit::WebLayerTreeRenderer::deleteLayer):
(WebKit::WebLayerTreeRenderer::flushLayerChanges):

  • UIProcess/WebLayerTreeRenderer.h:

(WebLayerTreeRenderer):

  • WebProcess/WebCoreSupport/WebGraphicsLayer.cpp:

(WebCore::WebGraphicsLayer::WebGraphicsLayer):
(WebCore::WebGraphicsLayer::syncCompositingState):
(WebCore::WebGraphicsLayer::syncCompositingStateForThisLayerOnly):

  • WebProcess/WebCoreSupport/WebGraphicsLayer.h:

(WebGraphicsLayerClient):
(WebCore::WebGraphicsLayer::fixedToViewport):
(WebCore::WebGraphicsLayer::setFixedToViewport):
(WebGraphicsLayer):

  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::setResizesToContentsUsingLayoutSize):

  • WebProcess/WebPage/qt/LayerTreeHostQt.cpp:

(WebKit::LayerTreeHostQt::LayerTreeHostQt):
(WebKit::LayerTreeHostQt::didSyncCompositingStateForLayer):
(WebKit::updateOffsetFromViewportForSelf):
(WebKit):
(WebKit::updateOffsetFromViewportForLayer):
(WebKit::LayerTreeHostQt::syncFixedLayers):
(WebKit::LayerTreeHostQt::setVisibleContentsRect):

  • WebProcess/WebPage/qt/LayerTreeHostQt.h:

(LayerTreeHostQt):

Location:
trunk
Files:
1 added
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/ChangeLog

    r113786 r113791  
     12012-04-10  Yael Aharon  <yael.aharon@nokia.com>
     2
     3        Initial support for fixed position elements in Qt WebKit2
     4        https://bugs.webkit.org/show_bug.cgi?id=81786
     5
     6        Reviewed by Noam Rosenthal.
     7
     8        * ManualTests/fixed-position.html: Added.
     9
    1102012-04-10  Raphael Kubo da Costa  <rakuco@webkit.org>
    211

  • trunk/Source/WebCore/ChangeLog

    r113783 r113791  
     12012-04-10  Yael Aharon  <yael.aharon@nokia.com>
     2
     3        Initial support for fixed position elements in Qt WebKit2
     4        https://bugs.webkit.org/show_bug.cgi?id=81786
     5
     6        Reviewed by Noam Rosenthal.
     7
     8        When the setting acceleratedCompositingForFixedPositionEnabled is true, we update
     9        the position of fixed layers, and send updates to the UI process as we scroll.
     10        Before painting, TextureMapperLayer receives a delta of the scroll positions between the UI
     11        and the web processes, and adjusts its transform position accordingly.
     12
     13        * page/FrameView.cpp:
     14        (WebCore::FrameView::setFixedVisibleContentRect):
     15        * platform/graphics/texmap/TextureMapperLayer.cpp:
     16        (WebCore::TextureMapperLayer::setScrollPositionDelta):
     17        (WebCore):
     18        * platform/graphics/texmap/TextureMapperLayer.h:
     19        (TextureMapperLayer):
     20
    1212012-04-10  Peter Rybin  <peter.rybin@gmail.com>
    222

  • trunk/Source/WebCore/page/FrameView.cpp

    r113287 r113791  
    17031703    IntSize offset = scrollOffset();
    17041704    ScrollView::setFixedVisibleContentRect(visibleContentRect);
    1705     if (offset != scrollOffset())
     1705    if (offset != scrollOffset()) {
     1706        if (m_frame->page()->settings()->acceleratedCompositingForFixedPositionEnabled())
     1707            updateFixedElementsAfterScrolling();
    17061708        scrollPositionChanged();
     1709    }
    17071710    frame()->loader()->client()->didChangeScrollOffset();
    17081711}

  • trunk/Source/WebCore/platform/graphics/texmap/TextureMapperLayer.cpp

    r113678 r113791  
    512512}
    513513
    514 }
    515 #endif
     514void TextureMapperLayer::setScrollPositionDelta(const IntPoint& delta)
     515{
     516    // delta is the difference between the scroll offset in the ui process and the scroll offset
     517    // in the web process. We add this delta to the position of fixed layers, to make
     518    // sure that they do not move while scrolling.
     519    m_scrollPositionDelta = delta;
     520    m_transform.setPosition(m_state.pos + m_scrollPositionDelta);
     521}
     522
     523}
     524#endif

  • trunk/Source/WebCore/platform/graphics/texmap/TextureMapperLayer.h

    r107814 r113791  
    126126    PassRefPtr<TextureMapperBackingStore> backingStore() { return m_backingStore; }
    127127    void clearBackingStoresRecursive();
     128
     129    void setScrollPositionDelta(const IntPoint&);
    128130
    129131private:
    … …  
    218220    TextureMapper* m_textureMapper;
    219221    TextureMapperAnimations m_animations;
     222    IntPoint m_scrollPositionDelta;
    220223};
    221224

  • trunk/Source/WebKit2/ChangeLog

    r113777 r113791  
     12012-04-10  Yael Aharon  <yael.aharon@nokia.com>
     2
     3        Initial support for fixed position elements in Qt WebKit2
     4        https://bugs.webkit.org/show_bug.cgi?id=81786
     5
     6        Reviewed by Noam Rosenthal.
     7
     8        Turn on the flag acceleratedCompositingForFixedPositionEnabled when using fixed layout.
     9        As we scroll, we keep track of the delta in scroll position between the UI and web processes,
     10        and adjust the position of all the fixed layers by that delta.
     11        When WebLayerTreeRenderer receives a new scroll position from the web process, it keeps it as pending,
     12        and commit the new scroll position in flushLayerChanges.
     13        This patch does not address scrolling overshoot and it does not fix the wrong positioning
     14        that occurs when we zoom. These issues will be addressed in future patches.
     15
     16        * Shared/WebLayerTreeInfo.h:
     17        * UIProcess/API/qt/qquickwebpage.cpp:
     18        (QQuickWebPagePrivate::updateSize):
     19        * UIProcess/LayerTreeHostProxy.cpp:
     20        (WebKit::LayerTreeHostProxy::setContentsSize):
     21        (WebKit):
     22        (WebKit::LayerTreeHostProxy::renderNextFrame):
     23        (WebKit::LayerTreeHostProxy::didChangeScrollPosition):
     24        * UIProcess/LayerTreeHostProxy.h:
     25        (LayerTreeHostProxy):
     26        * UIProcess/LayerTreeHostProxy.messages.in:
     27        * UIProcess/WebLayerTreeRenderer.cpp:
     28        (WebKit::boundedScrollPosition):
     29        (WebKit):
     30        (WebKit::WebLayerTreeRenderer::paintToCurrentGLContext):
     31        (WebKit::WebLayerTreeRenderer::setContentsSize):
     32        (WebKit::WebLayerTreeRenderer::adjustPositionForFixedLayers):
     33        (WebKit::WebLayerTreeRenderer::didChangeScrollPosition):
     34        (WebKit::WebLayerTreeRenderer::syncLayerParameters):
     35        (WebKit::WebLayerTreeRenderer::deleteLayer):
     36        (WebKit::WebLayerTreeRenderer::flushLayerChanges):
     37        * UIProcess/WebLayerTreeRenderer.h:
     38        (WebLayerTreeRenderer):
     39        * WebProcess/WebCoreSupport/WebGraphicsLayer.cpp:
     40        (WebCore::WebGraphicsLayer::WebGraphicsLayer):
     41        (WebCore::WebGraphicsLayer::syncCompositingState):
     42        (WebCore::WebGraphicsLayer::syncCompositingStateForThisLayerOnly):
     43        * WebProcess/WebCoreSupport/WebGraphicsLayer.h:
     44        (WebGraphicsLayerClient):
     45        (WebCore::WebGraphicsLayer::fixedToViewport):
     46        (WebCore::WebGraphicsLayer::setFixedToViewport):
     47        (WebGraphicsLayer):
     48        * WebProcess/WebPage/WebPage.cpp:
     49        (WebKit::WebPage::setResizesToContentsUsingLayoutSize):
     50        * WebProcess/WebPage/qt/LayerTreeHostQt.cpp:
     51        (WebKit::LayerTreeHostQt::LayerTreeHostQt):
     52        (WebKit::LayerTreeHostQt::didSyncCompositingStateForLayer):
     53        (WebKit::updateOffsetFromViewportForSelf):
     54        (WebKit):
     55        (WebKit::updateOffsetFromViewportForLayer):
     56        (WebKit::LayerTreeHostQt::syncFixedLayers):
     57        (WebKit::LayerTreeHostQt::setVisibleContentsRect):
     58        * WebProcess/WebPage/qt/LayerTreeHostQt.h:
     59        (LayerTreeHostQt):
     60
    1612012-04-10  Anders Carlsson  <andersca@apple.com>
    262

  • trunk/Source/WebKit2/Shared/WebLayerTreeInfo.h

    r113640 r113791  
    6666            bool preserves3D : 1;
    6767            bool isRootLayer: 1;
     68            bool fixedToViewport : 1;
    6869        };
    6970        unsigned int flags;

  • trunk/Source/WebKit2/UIProcess/API/qt/qquickwebpage.cpp

    r113172 r113791  
    140140    q->setSize(scaledSize);
    141141    viewportItem->updateContentsSize(scaledSize);
     142    DrawingAreaProxy* drawingArea = webPageProxy->drawingArea();
     143    if (drawingArea && drawingArea->layerTreeHostProxy())
     144        drawingArea->layerTreeHostProxy()->setContentsSize(WebCore::FloatSize(contentsSize.width(), contentsSize.height()));
    142145}
    143146

  • trunk/Source/WebKit2/UIProcess/LayerTreeHostProxy.cpp

    r113773 r113791  
    123123}
    124124
     125void LayerTreeHostProxy::setContentsSize(const FloatSize& contentsSize)
     126{
     127    m_renderer->setContentsSize(contentsSize);
     128}
     129
    125130void LayerTreeHostProxy::setVisibleContentsRect(const IntRect& rect, float scale, const FloatPoint& trajectoryVector)
    126131{
    … …  
    134139}
    135140
     141void LayerTreeHostProxy::didChangeScrollPosition(const IntPoint& position)
     142{
     143    dispatchUpdate(bind(&WebLayerTreeRenderer::didChangeScrollPosition, m_renderer.get(), position));
     144}
     145
    136146void LayerTreeHostProxy::purgeBackingStores()
    137147{

  • trunk/Source/WebKit2/UIProcess/LayerTreeHostProxy.h

    r113773 r113791  
    5757    void paintToGraphicsContext(BackingStore::PlatformGraphicsContext);
    5858    void purgeGLResources();
     59    void setContentsSize(const WebCore::FloatSize&);
    5960    void setVisibleContentsRect(const WebCore::IntRect&, float scale, const WebCore::FloatPoint& trajectory);
    6061    void didRenderFrame();
    … …  
    6768    void updateViewport();
    6869    void renderNextFrame();
     70    void didChangeScrollPosition(const WebCore::IntPoint& position);
    6971    void purgeBackingStores();
    7072    WebLayerTreeRenderer* layerTreeRenderer() const { return m_renderer.get(); }

  • trunk/Source/WebKit2/UIProcess/LayerTreeHostProxy.messages.in

    r113773 r113791  
    3030    DestroyDirectlyCompositedImage(int64_t key)
    3131    DidRenderFrame()
     32    DidChangeScrollPosition(WebCore::IntPoint position)
    3233}
    3334#endif

  • trunk/Source/WebKit2/UIProcess/WebLayerTreeRenderer.cpp

    r113773 r113791  
    7474}
    7575
     76static IntPoint boundedScrollPosition(const IntPoint& scrollPosition, const IntRect& visibleContentRect, const FloatSize& contentSize)
     77{
     78    IntSize size(contentSize.width(), contentSize.height());
     79    int scrollPositionX = std::max(scrollPosition.x(), 0);
     80    scrollPositionX = std::min(scrollPositionX, size.width() - visibleContentRect.width());
     81
     82    int scrollPositionY = std::max(scrollPosition.y(), 0);
     83    scrollPositionY = std::min(scrollPositionY, size.height() - visibleContentRect.height());
     84    return IntPoint(scrollPositionX, scrollPositionY);
     85}
     86
    7687WebLayerTreeRenderer::WebLayerTreeRenderer(LayerTreeHostProxy* layerTreeHostProxy)
    7788    : m_layerTreeHostProxy(layerTreeHostProxy)
    … …  
    99110
    100111    syncRemoteContent();
     112    adjustPositionForFixedLayers();
    101113    GraphicsLayer* currentRootLayer = rootLayer();
    102114    if (!currentRootLayer)
    … …  
    144156}
    145157
     158void WebLayerTreeRenderer::setContentsSize(const WebCore::FloatSize& contentsSize)
     159{
     160    m_contentsSize = contentsSize;
     161}
     162
    146163void WebLayerTreeRenderer::setVisibleContentsRect(const IntRect& rect, float scale)
    147164{
    … …  
    154171    if (m_layerTreeHostProxy)
    155172        m_layerTreeHostProxy->updateViewport();
     173}
     174
     175void WebLayerTreeRenderer::adjustPositionForFixedLayers()
     176{
     177    if (m_fixedLayers.isEmpty())
     178        return;
     179
     180    IntPoint scrollPosition = boundedScrollPosition(m_visibleContentsRect.location(), m_visibleContentsRect, m_contentsSize);
     181
     182    LayerMap::iterator end = m_fixedLayers.end();
     183    for (LayerMap::iterator it = m_fixedLayers.begin(); it != end; ++it)
     184        toTextureMapperLayer(it->second)->setScrollPositionDelta(IntPoint(scrollPosition.x() - m_renderedContentsScrollPosition.x(), scrollPosition.y() - m_renderedContentsScrollPosition.y()));
     185}
     186
     187void WebLayerTreeRenderer::didChangeScrollPosition(const IntPoint& position)
     188{
     189    m_pendingRenderedContentsScrollPosition = boundedScrollPosition(position, m_visibleContentsRect, m_contentsSize);
    156190}
    157191
    … …  
    196230    layer->setDrawsContent(layerInfo.drawsContent);
    197231
     232    if (layerInfo.fixedToViewport)
     233        m_fixedLayers.add(id, layer);
     234    else
     235        m_fixedLayers.remove(id);
     236
    198237    assignImageToLayer(layer, layerInfo.imageBackingStoreID);
    199238
    … …  
    214253    layer->removeFromParent();
    215254    m_layers.remove(layerID);
     255    m_fixedLayers.remove(layerID);
    216256    delete layer;
    217257}
    … …  
    311351void WebLayerTreeRenderer::flushLayerChanges()
    312352{
     353    m_renderedContentsScrollPosition = m_pendingRenderedContentsScrollPosition;
     354
    313355    m_rootLayer->syncCompositingState(FloatRect());
    314356    commitTileOperations();

  • trunk/Source/WebKit2/UIProcess/WebLayerTreeRenderer.h

    r113773 r113791  
    6565    void paintToGraphicsContext(BackingStore::PlatformGraphicsContext);
    6666    void syncRemoteContent();
     67    void setContentsSize(const WebCore::FloatSize&);
    6768    void setVisibleContentsRect(const WebCore::IntRect&, float scale);
     69    void didChangeScrollPosition(const WebCore::IntPoint& position);
    6870
    6971    void detach();
    … …  
    9597    void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect&) { }
    9698    void callOnMainTread(const Function<void()>&);
     99    void adjustPositionForFixedLayers();
    97100
    98101    typedef HashMap<WebLayerID, WebCore::GraphicsLayer*> LayerMap;
     102    WebCore::FloatSize m_contentsSize;
    99103    WebCore::IntRect m_visibleContentsRect;
    100104    float m_contentsScale;
    … …  
    125129
    126130    LayerMap m_layers;
     131    LayerMap m_fixedLayers;
    127132    WebLayerID m_rootLayerID;
     133    WebCore::IntPoint m_renderedContentsScrollPosition;
     134    WebCore::IntPoint m_pendingRenderedContentsScrollPosition;
    128135};
    129136

  • trunk/Source/WebKit2/WebProcess/WebCoreSupport/WebGraphicsLayer.cpp

    r113773 r113791  
    9797    , m_maskTarget(0)
    9898    , m_inUpdateMode(false)
     99    , m_fixedToViewport(false)
    99100    , m_shouldUpdateVisibleRect(true)
    100101    , m_shouldSyncLayerState(true)
    … …  
    388389        replica->syncCompositingStateForThisLayerOnly();
    389390
     391    m_webGraphicsLayerClient->syncFixedLayers();
     392
    390393    syncCompositingStateForThisLayerOnly();
    391394
    … …  
    416419        return;
    417420    m_shouldSyncLayerState = false;
     421    m_layerInfo.fixedToViewport = fixedToViewport();
    418422
    419423    m_layerInfo.anchorPoint = anchorPoint();

  • trunk/Source/WebKit2/WebProcess/WebCoreSupport/WebGraphicsLayer.h

    r113773 r113791  
    6060    virtual void attachLayer(WebCore::WebGraphicsLayer*) = 0;
    6161    virtual void detachLayer(WebCore::WebGraphicsLayer*) = 0;
     62    virtual void syncFixedLayers() = 0;
    6263    virtual PassOwnPtr<WebCore::GraphicsContext> beginContentUpdate(const WebCore::IntSize&, ShareableBitmap::Flags, ShareableSurface::Handle&, WebCore::IntPoint&) = 0;
    6364};
    … …  
    112113    Image* image() { return m_image.get(); }
    113114
     115    bool fixedToViewport() const { return m_fixedToViewport; }
     116    void setFixedToViewport(bool isFixed) { m_fixedToViewport = isFixed; }
     117
    114118    GraphicsLayer* maskTarget() const { return m_maskTarget; }
    115119    void setMaskTarget(GraphicsLayer* layer) { m_maskTarget = layer; }
    … …  
    154158    bool m_shouldSyncLayerState: 1;
    155159    bool m_shouldSyncChildren: 1;
     160    bool m_fixedToViewport : 1;
    156161
    157162    void notifyChange();

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.cpp

    r113486 r113791  
    836836    view->setFixedLayoutSize(targetLayoutSize);
    837837
     838    m_page->settings()->setAcceleratedCompositingForFixedPositionEnabled(true);
     839
    838840    // Schedule a layout to use the new target size.
    839841    if (!view->layoutPending()) {

  • trunk/Source/WebKit2/WebProcess/WebPage/qt/LayerTreeHostQt.cpp

    r113773 r113791  
    4040#include <WebCore/FrameView.h>
    4141#include <WebCore/Page.h>
     42#include <WebCore/RenderLayer.h>
     43#include <WebCore/RenderLayerBacking.h>
     44#include <WebCore/RenderLayerCompositor.h>
     45#include <WebCore/RenderView.h>
    4246#include <WebCore/Settings.h>
    4347
    … …  
    6973    , m_isSuspended(false)
    7074    , m_contentsScale(1)
     75    , m_shouldSendScrollPositionUpdate(true)
    7176    , m_shouldSyncFrame(false)
    7277    , m_shouldSyncRootLayer(true)
    … …  
    231236void LayerTreeHostQt::syncLayerState(WebLayerID id, const WebLayerInfo& info)
    232237{
     238    if (m_shouldSendScrollPositionUpdate) {
     239        m_webPage->send(Messages::LayerTreeHostProxy::DidChangeScrollPosition(m_visibleContentsRect.location()));
     240        m_shouldSendScrollPositionUpdate = false;
     241    }
    233242    m_shouldSyncFrame = true;
    234243    m_webPage->send(Messages::LayerTreeHostProxy::SetCompositingLayerState(id, info));
    … …  
    255264    m_shouldSyncFrame = true;
    256265    m_webPage->send(Messages::LayerTreeHostProxy::DeleteCompositingLayer(layer->id()));
     266}
     267
     268static void updateOffsetFromViewportForSelf(RenderLayer* renderLayer)
     269{
     270    // These conditions must match the conditions in RenderLayerCompositor::requiresCompositingForPosition.
     271    RenderLayerBacking* backing = renderLayer->backing();
     272    if (!backing)
     273        return;
     274
     275    RenderStyle* style = renderLayer->renderer()->style();
     276    if (!style)
     277        return;
     278
     279    if (!renderLayer->renderer()->isPositioned() || renderLayer->renderer()->style()->position() != FixedPosition)
     280        return;
     281
     282    if (!renderLayer->renderer()->container()->isRenderView())
     283        return;
     284
     285    if (!renderLayer->isStackingContext())
     286        return;
     287
     288    WebGraphicsLayer* graphicsLayer = toWebGraphicsLayer(backing->graphicsLayer());
     289    graphicsLayer->setFixedToViewport(true);
     290}
     291
     292static void updateOffsetFromViewportForLayer(RenderLayer* renderLayer)
     293{
     294    updateOffsetFromViewportForSelf(renderLayer);
     295
     296    if (renderLayer->firstChild())
     297        updateOffsetFromViewportForLayer(renderLayer->firstChild());
     298    if (renderLayer->nextSibling())
     299        updateOffsetFromViewportForLayer(renderLayer->nextSibling());
     300}
     301
     302void LayerTreeHostQt::syncFixedLayers()
     303{
     304    if (!m_webPage->corePage()->settings() || !m_webPage->corePage()->settings()->acceleratedCompositingForFixedPositionEnabled())
     305        return;
     306
     307    if (!m_webPage->mainFrame()->view()->hasFixedObjects())
     308        return;
     309
     310    RenderLayer* rootRenderLayer = m_webPage->mainFrame()->contentRenderer()->compositor()->rootRenderLayer();
     311    ASSERT(rootRenderLayer);
     312    if (rootRenderLayer->firstChild())
     313        updateOffsetFromViewportForLayer(rootRenderLayer->firstChild());
    257314}
    258315
    … …  
    448505    if (m_webPage->useFixedLayout())
    449506        m_webPage->setFixedVisibleContentRect(rect);
     507    if (contentsRectDidChange)
     508        m_shouldSendScrollPositionUpdate = true;
    450509}
    451510

  • trunk/Source/WebKit2/WebProcess/WebPage/qt/LayerTreeHostQt.h

    r113773 r113791  
    7777    virtual void attachLayer(WebCore::WebGraphicsLayer*);
    7878    virtual void detachLayer(WebCore::WebGraphicsLayer*);
     79    virtual void syncFixedLayers();
    7980
    8081    virtual PassOwnPtr<WebCore::GraphicsContext> beginContentUpdate(const WebCore::IntSize&, ShareableBitmap::Flags, ShareableSurface::Handle&, WebCore::IntPoint&);
    … …  
    120121    WebCore::IntRect m_visibleContentsRect;
    121122    float m_contentsScale;
     123    bool m_shouldSendScrollPositionUpdate;
    122124
    123125    LayerTreeContext m_layerTreeContext;
Note: See TracChangeset for help on using the changeset viewer.