Changeset 130439 in webkit


Ignore:
Timestamp:
Oct 4, 2012 5:43:04 PM (12 years ago)
Author:
Simon Fraser
Message:

Final part of "sync" to "flush" renaming
​https://bugs.webkit.org/show_bug.cgi?id=98430

Reviewed by Tim Horton.

Change method names on GraphicsLayer and GraphicsLayerClient that
refer to "sync" to use the term "flush" instead, to be consistent
with the rest of the code.

Source/WebCore:

  • platform/graphics/GraphicsLayer.h:

(WebCore::GraphicsLayer::flushCompositingState):
(WebCore::GraphicsLayer::flushCompositingStateForThisLayerOnly):

  • platform/graphics/GraphicsLayerClient.h:

(GraphicsLayerClient):

  • platform/graphics/blackberry/GraphicsLayerBlackBerry.h:

(WebCore::GraphicsLayerBlackBerry::notifyFlushRequired):

  • platform/graphics/blackberry/LayerWebKitThread.cpp:

(WebCore::LayerWebKitThread::setNeedsCommit):

  • platform/graphics/ca/GraphicsLayerCA.cpp:

(WebCore::GraphicsLayerCA::flushCompositingState):
(WebCore::GraphicsLayerCA::flushCompositingStateForThisLayerOnly):
(WebCore::GraphicsLayerCA::platformCALayerDidCreateTiles):
(WebCore::GraphicsLayerCA::positionForCloneRootLayer):
(WebCore::GraphicsLayerCA::noteLayerPropertyChanged):

  • platform/graphics/ca/GraphicsLayerCA.h:

(GraphicsLayerCA):

  • platform/graphics/texmap/GraphicsLayerTextureMapper.cpp:

(WebCore::GraphicsLayerTextureMapper::notifyChange):
(WebCore::GraphicsLayerTextureMapper::flushCompositingStateForThisLayerOnly):
(WebCore::GraphicsLayerTextureMapper::flushCompositingState):

  • platform/graphics/texmap/GraphicsLayerTextureMapper.h:

(GraphicsLayerTextureMapper):

  • platform/graphics/texmap/TextureMapperLayer.cpp:

(WebCore::TextureMapperLayer::flushCompositingState):
(WebCore::TextureMapperLayer::flushCompositingStateSelf):

  • platform/graphics/texmap/TextureMapperLayer.h:

(TextureMapperLayer):

  • rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::notifyFlushRequired):

  • rendering/RenderLayerBacking.h:

(RenderLayerBacking):

  • rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::flushPendingLayerChanges):

  • rendering/RenderLayerCompositor.h:

(WebCore::RenderLayerCompositor::notifyFlushRequired):

Source/WebKit/blackberry:

  • Api/WebOverlay.cpp:

(BlackBerry::WebKit::WebOverlayPrivateWebKitThread::notifyFlushRequired):

  • Api/WebOverlay_p.h:

(WebOverlayPrivateWebKitThread):

  • Api/WebPage.cpp:

(BlackBerry::WebKit::WebPagePrivate::notifyFlushRequired):

  • Api/WebPage_p.h:

(WebPagePrivate):

  • WebKitSupport/DefaultTapHighlight.cpp:

(BlackBerry::WebKit::DefaultTapHighlight::notifyFlushRequired):

  • WebKitSupport/DefaultTapHighlight.h:

(DefaultTapHighlight):

  • WebKitSupport/InspectorOverlayBlackBerry.cpp:

(BlackBerry::WebKit::InspectorOverlay::notifyFlushRequired):

  • WebKitSupport/InspectorOverlayBlackBerry.h:

(InspectorOverlay):

  • WebKitSupport/SelectionOverlay.cpp:

(BlackBerry::WebKit::SelectionOverlay::notifyFlushRequired):

  • WebKitSupport/SelectionOverlay.h:

(SelectionOverlay):

Source/WebKit/efl:

  • WebCoreSupport/AcceleratedCompositingContextEfl.cpp:

(WebCore::AcceleratedCompositingContext::syncLayersNow):
(WebCore::AcceleratedCompositingContext::attachRootGraphicsLayer):

Source/WebKit/gtk:

  • WebCoreSupport/AcceleratedCompositingContext.h:

(AcceleratedCompositingContext):

  • WebCoreSupport/AcceleratedCompositingContextCairo.cpp:

(WebKit::AcceleratedCompositingContext::attachRootGraphicsLayer):
(WebKit::AcceleratedCompositingContext::resizeRootLayer):
(WebKit::AcceleratedCompositingContext::syncLayersNow):
(WebKit::AcceleratedCompositingContext::notifyFlushRequired):

  • WebCoreSupport/AcceleratedCompositingContextClutter.cpp:

(WebKit::AcceleratedCompositingContext::flushPendingLayerChanges):
(WebKit::AcceleratedCompositingContext::notifyFlushRequired):

  • WebCoreSupport/AcceleratedCompositingContextGL.cpp:

(WebKit::AcceleratedCompositingContext::flushPendingLayerChanges):
(WebKit::AcceleratedCompositingContext::notifyFlushRequired):

Source/WebKit/mac:

  • WebView/WebView.mm:

Source/WebKit/qt:

  • WebCoreSupport/PageClientQt.cpp:

(WebCore::TextureMapperLayerClientQt::syncRootLayer):

Source/WebKit/win:

  • WebView.cpp:

(WebView::notifyFlushRequired):
(WebView::flushPendingGraphicsLayerChanges):

  • WebView.h:

Source/WebKit2:

  • UIProcess/CoordinatedGraphics/LayerTreeRenderer.cpp:

(WebKit::LayerTreeRenderer::paintToCurrentGLContext):
(WebKit::LayerTreeRenderer::flushLayerChanges):

  • UIProcess/CoordinatedGraphics/LayerTreeRenderer.h:

(WebKit::LayerTreeRenderer::notifyFlushRequired):

  • WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp:

(WebCore::CoordinatedGraphicsLayer::didChangeLayerState):
(WebCore::CoordinatedGraphicsLayer::didChangeAnimatedProperties):
(WebCore::CoordinatedGraphicsLayer::didChangeChildren):
(WebCore::CoordinatedGraphicsLayer::didChangeFilters):
(WebCore::CoordinatedGraphicsLayer::setContentsNeedsDisplay):
(WebCore::CoordinatedGraphicsLayer::setContentsToCanvas):
(WebCore::CoordinatedGraphicsLayer::flushCompositingState):
(WebCore::CoordinatedGraphicsLayer::flushCompositingStateForThisLayerOnly):

  • WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.h:

(CoordinatedGraphicsLayer):

  • WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp:

(WebKit::LayerTreeCoordinator::flushPendingLayerChanges):
(WebKit::LayerTreeCoordinator::notifyFlushRequired):

  • WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.h:

(LayerTreeCoordinator):

  • WebProcess/WebPage/ca/LayerTreeHostCA.cpp:

(WebKit::LayerTreeHostCA::notifyFlushRequired):
(WebKit::LayerTreeHostCA::flushPendingLayerChanges):

  • WebProcess/WebPage/ca/LayerTreeHostCA.h:

(LayerTreeHostCA):

  • WebProcess/WebPage/gtk/LayerTreeHostGtk.cpp:

(WebKit::LayerTreeHostGtk::notifyFlushRequired):
(WebKit::LayerTreeHostGtk::flushPendingLayerChanges):

  • WebProcess/WebPage/gtk/LayerTreeHostGtk.h:

(LayerTreeHostGtk):

  • WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.h:

(TiledCoreAnimationDrawingArea):

  • WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm:

(WebKit::TiledCoreAnimationDrawingArea::notifyFlushRequired):
(WebKit::TiledCoreAnimationDrawingArea::flushLayers):

Location:
trunk/Source
Files:
58 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r130437 r130439  
     12012-10-04  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Final part of "sync" to "flush" renaming
     4        https://bugs.webkit.org/show_bug.cgi?id=98430
     5
     6        Reviewed by Tim Horton.
     7
     8        Change method names on GraphicsLayer and GraphicsLayerClient that
     9        refer to "sync" to use the term "flush" instead, to be consistent
     10        with the rest of the code.
     11
     12        * platform/graphics/GraphicsLayer.h:
     13        (WebCore::GraphicsLayer::flushCompositingState):
     14        (WebCore::GraphicsLayer::flushCompositingStateForThisLayerOnly):
     15        * platform/graphics/GraphicsLayerClient.h:
     16        (GraphicsLayerClient):
     17        * platform/graphics/blackberry/GraphicsLayerBlackBerry.h:
     18        (WebCore::GraphicsLayerBlackBerry::notifyFlushRequired):
     19        * platform/graphics/blackberry/LayerWebKitThread.cpp:
     20        (WebCore::LayerWebKitThread::setNeedsCommit):
     21        * platform/graphics/ca/GraphicsLayerCA.cpp:
     22        (WebCore::GraphicsLayerCA::flushCompositingState):
     23        (WebCore::GraphicsLayerCA::flushCompositingStateForThisLayerOnly):
     24        (WebCore::GraphicsLayerCA::platformCALayerDidCreateTiles):
     25        (WebCore::GraphicsLayerCA::positionForCloneRootLayer):
     26        (WebCore::GraphicsLayerCA::noteLayerPropertyChanged):
     27        * platform/graphics/ca/GraphicsLayerCA.h:
     28        (GraphicsLayerCA):
     29        * platform/graphics/texmap/GraphicsLayerTextureMapper.cpp:
     30        (WebCore::GraphicsLayerTextureMapper::notifyChange):
     31        (WebCore::GraphicsLayerTextureMapper::flushCompositingStateForThisLayerOnly):
     32        (WebCore::GraphicsLayerTextureMapper::flushCompositingState):
     33        * platform/graphics/texmap/GraphicsLayerTextureMapper.h:
     34        (GraphicsLayerTextureMapper):
     35        * platform/graphics/texmap/TextureMapperLayer.cpp:
     36        (WebCore::TextureMapperLayer::flushCompositingState):
     37        (WebCore::TextureMapperLayer::flushCompositingStateSelf):
     38        * platform/graphics/texmap/TextureMapperLayer.h:
     39        (TextureMapperLayer):
     40        * rendering/RenderLayerBacking.cpp:
     41        (WebCore::RenderLayerBacking::notifyFlushRequired):
     42        * rendering/RenderLayerBacking.h:
     43        (RenderLayerBacking):
     44        * rendering/RenderLayerCompositor.cpp:
     45        (WebCore::RenderLayerCompositor::flushPendingLayerChanges):
     46        * rendering/RenderLayerCompositor.h:
     47        (WebCore::RenderLayerCompositor::notifyFlushRequired):
     48
    1492012-10-04  Tab Atkins  <tabatkins@google.com>
    250

  • trunk/Source/WebCore/platform/graphics/GraphicsLayer.h

    r130185 r130439  
    386386    // with updates drawn into the window. These methods flush internal batched state on this layer
    387387    // and descendant layers, and this layer only.
    388     virtual void syncCompositingState(const FloatRect& /* clipRect */) { }
    389     virtual void syncCompositingStateForThisLayerOnly() { }
     388    virtual void flushCompositingState(const FloatRect& /* clipRect */) { }
     389    virtual void flushCompositingStateForThisLayerOnly() { }
    390390   
    391391    // Return a string with a human readable form of the layer tree, If debug is true

  • trunk/Source/WebCore/platform/graphics/GraphicsLayerClient.h

    r126663 r130439  
    6464    virtual void notifyAnimationStarted(const GraphicsLayer*, double time) = 0;
    6565
    66     // Notification that a layer property changed that requires a subsequent call to syncCompositingState()
     66    // Notification that a layer property changed that requires a subsequent call to flushCompositingState()
    6767    // to appear on the screen.
    68     virtual void notifySyncRequired(const GraphicsLayer*) = 0;
     68    virtual void notifyFlushRequired(const GraphicsLayer*) = 0;
    6969   
    7070    virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const IntRect& inClip) = 0;

  • trunk/Source/WebCore/platform/graphics/blackberry/GraphicsLayerBlackBerry.h

    r127502 r130439  
    117117    virtual void setDebugBorder(const Color&, float borderWidth);
    118118
    119     void notifySyncRequired()
     119    void notifyFlushRequired()
    120120    {
    121121        if (m_client)
    122             m_client->notifySyncRequired(this);
     122            m_client->notifyFlushRequired(this);
    123123    }
    124124

  • trunk/Source/WebCore/platform/graphics/blackberry/LayerWebKitThread.cpp

    r126885 r130439  
    196196void LayerWebKitThread::setNeedsCommit()
    197197{
    198     // Call notifySyncRequired(), which in this implementation plumbs through to
     198    // Call notifyFlushRequired(), which in this implementation plumbs through to
    199199    // call scheduleRootLayerCommit() on the WebView, which will cause us to commit
    200200    // changes done on the WebKit thread for display on the Compositing thread.
    201201    if (m_owner)
    202         m_owner->notifySyncRequired();
     202        m_owner->notifyFlushRequired();
    203203}
    204204

  • trunk/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp

    r130072 r130439  
    894894}
    895895
    896 void GraphicsLayerCA::syncCompositingState(const FloatRect& clipRect)
     896void GraphicsLayerCA::flushCompositingState(const FloatRect& clipRect)
    897897{
    898898    TransformState state(TransformState::UnapplyInverseTransformDirection, FloatQuad(clipRect));
    … …  
    900900}
    901901
    902 void GraphicsLayerCA::syncCompositingStateForThisLayerOnly()
     902void GraphicsLayerCA::flushCompositingStateForThisLayerOnly()
    903903{
    904904    float pageScaleFactor;
    … …  
    10061006
    10071007    // Ensure that the layout is up to date before any individual tiles are painted by telling the client
    1008     // that it needs to sync its layer state, which will end up scheduling the layer flusher.
    1009     client()->notifySyncRequired(this);
     1008    // that it needs to flush its layer state, which will end up scheduling the layer flusher.
     1009    client()->notifyFlushRequired(this);
    10101010}
    10111011
    … …  
    25872587FloatPoint GraphicsLayerCA::positionForCloneRootLayer() const
    25882588{
    2589     // This can get called during a sync when we've just removed the m_replicaLayer.
     2589    // This can get called during a flush when we've just removed the m_replicaLayer.
    25902590    if (!m_replicaLayer)
    25912591        return FloatPoint();
    … …  
    28442844{
    28452845    if (!m_uncommittedChanges && m_client)
    2846         m_client->notifySyncRequired(this);
     2846        m_client->notifyFlushRequired(this);
    28472847
    28482848    m_uncommittedChanges |= flags;

  • trunk/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h

    r121461 r130439  
    3939
    4040// Enable this to add a light red wash over the visible portion of Tiled Layers, as computed
    41 // by syncCompositingState().
     41// by flushCompositingState().
    4242// #define VISIBLE_TILE_WASH
    4343
    … …  
    132132    void recursiveCommitChanges(const TransformState&, float pageScaleFactor = 1, const FloatPoint& positionRelativeToBase = FloatPoint(), bool affectedByPageScale = false);
    133133
    134     virtual void syncCompositingState(const FloatRect&);
    135     virtual void syncCompositingStateForThisLayerOnly();
     134    virtual void flushCompositingState(const FloatRect&);
     135    virtual void flushCompositingStateForThisLayerOnly();
    136136
    137137    virtual TiledBacking* tiledBacking() OVERRIDE;

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

    r130185 r130439  
    5757    if (!client())
    5858        return;
    59     client()->notifySyncRequired(this);
     59    client()->notifyFlushRequired(this);
    6060}
    6161
    … …  
    368368/* \reimp (GraphicsLayer.h)
    369369*/
    370 void GraphicsLayerTextureMapper::syncCompositingStateForThisLayerOnly()
    371 {
    372     m_layer->syncCompositingState(this);
    373 }
    374 
    375 /* \reimp (GraphicsLayer.h)
    376 */
    377 void GraphicsLayerTextureMapper::syncCompositingState(const FloatRect&)
    378 {
    379     m_layer->syncCompositingState(this, TextureMapperLayer::TraverseDescendants);
     370void GraphicsLayerTextureMapper::flushCompositingStateForThisLayerOnly()
     371{
     372    m_layer->flushCompositingState(this);
     373}
     374
     375/* \reimp (GraphicsLayer.h)
     376*/
     377void GraphicsLayerTextureMapper::flushCompositingState(const FloatRect&)
     378{
     379    m_layer->flushCompositingState(this, TextureMapperLayer::TraverseDescendants);
    380380}
    381381

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

    r125834 r130439  
    7070    virtual void setContentsToMedia(PlatformLayer*);
    7171    virtual void setContentsToCanvas(PlatformLayer* canvas) { setContentsToMedia(canvas); }
    72     virtual void syncCompositingState(const FloatRect&);
    73     virtual void syncCompositingStateForThisLayerOnly();
     72    virtual void flushCompositingState(const FloatRect&);
     73    virtual void flushCompositingStateForThisLayerOnly();
    7474    virtual void setName(const String& name);
    7575    virtual PlatformLayer* platformLayer() const { return 0; }

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

    r129993 r130439  
    403403}
    404404
    405 void TextureMapperLayer::syncCompositingState(GraphicsLayerTextureMapper* graphicsLayer, int options)
    406 {
    407     syncCompositingState(graphicsLayer, rootLayer()->m_textureMapper, options);
    408 }
    409 
    410 void TextureMapperLayer::syncCompositingStateSelf(GraphicsLayerTextureMapper* graphicsLayer, TextureMapper* textureMapper)
     405void TextureMapperLayer::flushCompositingState(GraphicsLayerTextureMapper* graphicsLayer, int options)
     406{
     407    flushCompositingState(graphicsLayer, rootLayer()->m_textureMapper, options);
     408}
     409
     410void TextureMapperLayer::flushCompositingStateSelf(GraphicsLayerTextureMapper* graphicsLayer, TextureMapper* textureMapper)
    411411{
    412412    int changeMask = graphicsLayer->changeMask();
    … …  
    520520}
    521521
    522 void TextureMapperLayer::syncCompositingState(GraphicsLayerTextureMapper* graphicsLayer, TextureMapper* textureMapper, int options)
     522void TextureMapperLayer::flushCompositingState(GraphicsLayerTextureMapper* graphicsLayer, TextureMapper* textureMapper, int options)
    523523{
    524524    if (!textureMapper)
    … …  
    526526
    527527    if (graphicsLayer && !(options & ComputationsOnly)) {
    528         syncCompositingStateSelf(graphicsLayer, textureMapper);
     528        flushCompositingStateSelf(graphicsLayer, textureMapper);
    529529        graphicsLayer->didSynchronize();
    530530    }
    531531
    532532    if (graphicsLayer && m_state.maskLayer) {
    533         m_state.maskLayer->syncCompositingState(toGraphicsLayerTextureMapper(graphicsLayer->maskLayer()), textureMapper);
     533        m_state.maskLayer->flushCompositingState(toGraphicsLayerTextureMapper(graphicsLayer->maskLayer()), textureMapper);
    534534
    535535        // A mask layer has its parent's size by default, in case it's not set specifically.
    … …  
    539539
    540540    if (m_state.replicaLayer)
    541         m_state.replicaLayer->syncCompositingState(toGraphicsLayerTextureMapper(graphicsLayer->replicaLayer()), textureMapper);
     541        m_state.replicaLayer->flushCompositingState(toGraphicsLayerTextureMapper(graphicsLayer->replicaLayer()), textureMapper);
    542542
    543543    syncAnimations();
    … …  
    553553            if (!layer)
    554554                continue;
    555             layer->syncCompositingState(toGraphicsLayerTextureMapper(children[i]), textureMapper, options);
     555            layer->flushCompositingState(toGraphicsLayerTextureMapper(children[i]), textureMapper, options);
    556556        }
    557557    } else {
    558558        for (int i = m_children.size() - 1; i >= 0; --i)
    559             m_children[i]->syncCompositingState(0, textureMapper, options);
     559            m_children[i]->flushCompositingState(0, textureMapper, options);
    560560    }
    561561}

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

    r128572 r130439  
    115115    virtual ~TextureMapperLayer();
    116116
    117     void syncCompositingState(GraphicsLayerTextureMapper*, int syncOptions = 0);
    118     void syncCompositingState(GraphicsLayerTextureMapper*, TextureMapper*, int syncOptions = 0);
     117    void flushCompositingState(GraphicsLayerTextureMapper*, int syncOptions = 0);
     118    void flushCompositingState(GraphicsLayerTextureMapper*, TextureMapper*, int syncOptions = 0);
    119119    IntSize size() const { return IntSize(m_size.width(), m_size.height()); }
    120120    void setTransform(const TransformationMatrix&);
    … …  
    145145    void invalidateViewport(const FloatRect&);
    146146    void notifyChange(ChangeMask);
    147     void syncCompositingStateSelf(GraphicsLayerTextureMapper*, TextureMapper*);
     147    void flushCompositingStateSelf(GraphicsLayerTextureMapper*, TextureMapper*);
    148148
    149149    static int compareGraphicsLayersZValue(const void* a, const void* b);

  • trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

    r130302 r130439  
    16771677}
    16781678
    1679 void RenderLayerBacking::notifySyncRequired(const GraphicsLayer*)
     1679void RenderLayerBacking::notifyFlushRequired(const GraphicsLayer*)
    16801680{
    16811681    if (!renderer()->documentBeingDestroyed())

  • trunk/Source/WebCore/rendering/RenderLayerBacking.h

    r130081 r130439  
    138138    virtual bool usingTileCache(const GraphicsLayer*) const { return m_usingTiledCacheLayer; }
    139139    virtual void notifyAnimationStarted(const GraphicsLayer*, double startTime);
    140     virtual void notifySyncRequired(const GraphicsLayer*);
     140    virtual void notifyFlushRequired(const GraphicsLayer*);
    141141
    142142    virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const IntRect& clip);

  • trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

    r130407 r130439  
    284284{
    285285    // FrameView::flushCompositingStateIncludingSubframes() flushes each subframe,
    286     // but GraphicsLayer::syncCompositingState() will cross frame boundaries
     286    // but GraphicsLayer::flushCompositingState() will cross frame boundaries
    287287    // if the GraphicsLayers are connected (the RootLayerAttachedViaEnclosingFrame case).
    288288    // As long as we're not the root of the flush, we can bail.
    … …  
    298298            // FIXME: Passing frameRect() is correct only when RenderLayerCompositor uses a ScrollLayer (as in WebKit2)
    299299            // otherwise, the passed clip rect needs to take scrolling into account
    300             rootLayer->syncCompositingState(frameView->frameRect());
     300            rootLayer->flushCompositingState(frameView->frameRect());
    301301        }
    302302    }

  • trunk/Source/WebCore/rendering/RenderLayerCompositor.h

    r130407 r130439  
    226226    // GraphicsLayerClient Implementation
    227227    virtual void notifyAnimationStarted(const GraphicsLayer*, double) { }
    228     virtual void notifySyncRequired(const GraphicsLayer*) { scheduleLayerFlush(); }
     228    virtual void notifyFlushRequired(const GraphicsLayer*) { scheduleLayerFlush(); }
    229229    virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const IntRect&);
    230230

  • trunk/Source/WebKit/blackberry/Api/WebOverlay.cpp

    r128755 r130439  
    365365}
    366366
    367 void WebOverlayPrivateWebKitThread::notifySyncRequired(const WebCore::GraphicsLayer*)
     367void WebOverlayPrivateWebKitThread::notifyFlushRequired(const WebCore::GraphicsLayer*)
    368368{
    369369    if (WebPagePrivate* page = this->page())

  • trunk/Source/WebKit/blackberry/Api/WebOverlay_p.h

    r128755 r130439  
    166166    // GraphicsLayerClient
    167167    virtual void notifyAnimationStarted(const WebCore::GraphicsLayer*, double time) { }
    168     virtual void notifySyncRequired(const WebCore::GraphicsLayer*);
     168    virtual void notifyFlushRequired(const WebCore::GraphicsLayer*);
    169169    virtual void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& inClip);
    170170    virtual bool showDebugBorders(const WebCore::GraphicsLayer*) const { return false; }

  • trunk/Source/WebKit/blackberry/Api/WebPage.cpp

    r130392 r130439  
    58845884}
    58855885
    5886 void WebPagePrivate::notifySyncRequired(const GraphicsLayer*)
     5886void WebPagePrivate::notifyFlushRequired(const GraphicsLayer*)
    58875887{
    58885888    scheduleRootLayerCommit();

  • trunk/Source/WebKit/blackberry/Api/WebPage_p.h

    r129909 r130439  
    399399    // Fallback GraphicsLayerClient implementation, used for various overlay layers.
    400400    virtual void notifyAnimationStarted(const WebCore::GraphicsLayer*, double time) { }
    401     virtual void notifySyncRequired(const WebCore::GraphicsLayer*);
     401    virtual void notifyFlushRequired(const WebCore::GraphicsLayer*);
    402402    virtual void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& inClip) { }
    403403    virtual bool showDebugBorders(const WebCore::GraphicsLayer*) const;

  • trunk/Source/WebKit/blackberry/ChangeLog

    r130400 r130439  
     12012-10-04  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Final part of "sync" to "flush" renaming
     4        https://bugs.webkit.org/show_bug.cgi?id=98430
     5
     6        Reviewed by Tim Horton.
     7
     8        Change method names on GraphicsLayer and GraphicsLayerClient that
     9        refer to "sync" to use the term "flush" instead, to be consistent
     10        with the rest of the code.
     11
     12        * Api/WebOverlay.cpp:
     13        (BlackBerry::WebKit::WebOverlayPrivateWebKitThread::notifyFlushRequired):
     14        * Api/WebOverlay_p.h:
     15        (WebOverlayPrivateWebKitThread):
     16        * Api/WebPage.cpp:
     17        (BlackBerry::WebKit::WebPagePrivate::notifyFlushRequired):
     18        * Api/WebPage_p.h:
     19        (WebPagePrivate):
     20        * WebKitSupport/DefaultTapHighlight.cpp:
     21        (BlackBerry::WebKit::DefaultTapHighlight::notifyFlushRequired):
     22        * WebKitSupport/DefaultTapHighlight.h:
     23        (DefaultTapHighlight):
     24        * WebKitSupport/InspectorOverlayBlackBerry.cpp:
     25        (BlackBerry::WebKit::InspectorOverlay::notifyFlushRequired):
     26        * WebKitSupport/InspectorOverlayBlackBerry.h:
     27        (InspectorOverlay):
     28        * WebKitSupport/SelectionOverlay.cpp:
     29        (BlackBerry::WebKit::SelectionOverlay::notifyFlushRequired):
     30        * WebKitSupport/SelectionOverlay.h:
     31        (SelectionOverlay):
     32
    1332012-10-04  Simon Fraser  <simon.fraser@apple.com>
    234

  • trunk/Source/WebKit/blackberry/WebKitSupport/DefaultTapHighlight.cpp

    r125382 r130439  
    111111}
    112112
    113 void DefaultTapHighlight::notifySyncRequired(const GraphicsLayer* layer)
     113void DefaultTapHighlight::notifyFlushRequired(const GraphicsLayer* layer)
    114114{
    115     m_page->notifySyncRequired(layer);
     115    m_page->notifyFlushRequired(layer);
    116116}
    117117

  • trunk/Source/WebKit/blackberry/WebKitSupport/DefaultTapHighlight.h

    r129901 r130439  
    5656    // GraphicsLayerClient
    5757    virtual void notifyAnimationStarted(const WebCore::GraphicsLayer*, double time) { }
    58     virtual void notifySyncRequired(const WebCore::GraphicsLayer*);
     58    virtual void notifyFlushRequired(const WebCore::GraphicsLayer*);
    5959    virtual void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& inClip);
    6060    virtual bool showDebugBorders(const WebCore::GraphicsLayer*) const;

  • trunk/Source/WebKit/blackberry/WebKitSupport/InspectorOverlayBlackBerry.cpp

    r128502 r130439  
    4343
    4444#if USE(ACCELERATED_COMPOSITING)
    45 void InspectorOverlay::notifySyncRequired(const WebCore::GraphicsLayer* layer)
     45void InspectorOverlay::notifyFlushRequired(const WebCore::GraphicsLayer* layer)
    4646{
    47     m_webPage->notifySyncRequired(layer);
     47    m_webPage->notifyFlushRequired(layer);
    4848}
    4949

  • trunk/Source/WebKit/blackberry/WebKitSupport/InspectorOverlayBlackBerry.h

    r128502 r130439  
    5353#if USE(ACCELERATED_COMPOSITING)
    5454    virtual void notifyAnimationStarted(const WebCore::GraphicsLayer*, double time) { }
    55     virtual void notifySyncRequired(const WebCore::GraphicsLayer*);
     55    virtual void notifyFlushRequired(const WebCore::GraphicsLayer*);
    5656    virtual void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& inClip);
    5757    virtual bool showDebugBorders(const WebCore::GraphicsLayer*) const;

  • trunk/Source/WebKit/blackberry/WebKitSupport/SelectionOverlay.cpp

    r124615 r130439  
    9595}
    9696
    97 void SelectionOverlay::notifySyncRequired(const GraphicsLayer* layer)
     97void SelectionOverlay::notifyFlushRequired(const GraphicsLayer* layer)
    9898{
    99     m_page->notifySyncRequired(layer);
     99    m_page->notifyFlushRequired(layer);
    100100}
    101101

  • trunk/Source/WebKit/blackberry/WebKitSupport/SelectionOverlay.h

    r124615 r130439  
    5151    // GraphicsLayerClient
    5252    virtual void notifyAnimationStarted(const WebCore::GraphicsLayer*, double time) { }
    53     virtual void notifySyncRequired(const WebCore::GraphicsLayer*);
     53    virtual void notifyFlushRequired(const WebCore::GraphicsLayer*);
    5454    virtual void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& inClip);
    5555    virtual bool showDebugBorders(const WebCore::GraphicsLayer*) const;

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

    r130321 r130439  
    167167}
    168168
    169 void NonCompositedContentHost::notifySyncRequired(const WebCore::GraphicsLayer*)
     169void NonCompositedContentHost::notifyFlushRequired(const WebCore::GraphicsLayer*)
    170170{
    171171    m_webView->scheduleCompositingLayerSync();

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

    r127789 r130439  
    7070    // GraphicsLayerClient
    7171    virtual void notifyAnimationStarted(const WebCore::GraphicsLayer*, double time);
    72     virtual void notifySyncRequired(const WebCore::GraphicsLayer*);
     72    virtual void notifyFlushRequired(const WebCore::GraphicsLayer*);
    7373    virtual void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& clipRect);
    7474    virtual bool showDebugBorders(const WebCore::GraphicsLayer*) const;

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

    r116689 r130439  
    7676    virtual void notifyAnimationStarted(const GraphicsLayer*, double time) { }
    7777
    78     virtual void notifySyncRequired(const GraphicsLayer*) { }
     78    virtual void notifyFlushRequired(const GraphicsLayer*) { }
    7979
    8080    virtual void paintContents(const GraphicsLayer*, GraphicsContext& gc, GraphicsLayerPaintingPhase, const IntRect& inClip)

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

    r129160 r130439  
    5151  public:
    5252    virtual void notifyAnimationStarted(const GraphicsLayer*, double time) OVERRIDE { }
    53     virtual void notifySyncRequired(const GraphicsLayer*) OVERRIDE { }
     53    virtual void notifyFlushRequired(const GraphicsLayer*) OVERRIDE { }
    5454    virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const IntRect& inClip) OVERRIDE { }
    5555    virtual bool showDebugBorders(const GraphicsLayer*) const OVERRIDE { return false; }

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

    r129160 r130439  
    3939  public:
    4040    virtual void notifyAnimationStarted(const GraphicsLayer*, double time) { }
    41     virtual void notifySyncRequired(const GraphicsLayer*) { }
     41    virtual void notifyFlushRequired(const GraphicsLayer*) { }
    4242    virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const IntRect& inClip) { }
    4343    virtual bool showDebugBorders(const GraphicsLayer*) const { return false; }

  • trunk/Source/WebKit/efl/ChangeLog

    r130400 r130439  
     12012-10-04  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Final part of "sync" to "flush" renaming
     4        https://bugs.webkit.org/show_bug.cgi?id=98430
     5
     6        Reviewed by Tim Horton.
     7
     8        Change method names on GraphicsLayer and GraphicsLayerClient that
     9        refer to "sync" to use the term "flush" instead, to be consistent
     10        with the rest of the code.
     11
     12        * WebCoreSupport/AcceleratedCompositingContextEfl.cpp:
     13        (WebCore::AcceleratedCompositingContext::syncLayersNow):
     14        (WebCore::AcceleratedCompositingContext::attachRootGraphicsLayer):
     15
    1162012-10-04  Simon Fraser  <simon.fraser@apple.com>
    217

  • trunk/Source/WebKit/efl/WebCoreSupport/AcceleratedCompositingContextEfl.cpp

    r130400 r130439  
    6969{
    7070    if (m_rootGraphicsLayer)
    71         m_rootGraphicsLayer->syncCompositingStateForThisLayerOnly();
     71        m_rootGraphicsLayer->flushCompositingStateForThisLayerOnly();
    7272
    7373    EWKPrivate::corePage(m_view)->mainFrame()->view()->flushCompositingStateIncludingSubframes();
    … …  
    110110    m_rootTextureMapperLayer->setTextureMapper(m_textureMapper.get());
    111111
    112     m_rootGraphicsLayer->syncCompositingStateForThisLayerOnly();
     112    m_rootGraphicsLayer->flushCompositingStateForThisLayerOnly();
    113113}
    114114

  • trunk/Source/WebKit/gtk/ChangeLog

    r130400 r130439  
     12012-10-04  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Final part of "sync" to "flush" renaming
     4        https://bugs.webkit.org/show_bug.cgi?id=98430
     5
     6        Reviewed by Tim Horton.
     7
     8        Change method names on GraphicsLayer and GraphicsLayerClient that
     9        refer to "sync" to use the term "flush" instead, to be consistent
     10        with the rest of the code.
     11
     12        * WebCoreSupport/AcceleratedCompositingContext.h:
     13        (AcceleratedCompositingContext):
     14        * WebCoreSupport/AcceleratedCompositingContextCairo.cpp:
     15        (WebKit::AcceleratedCompositingContext::attachRootGraphicsLayer):
     16        (WebKit::AcceleratedCompositingContext::resizeRootLayer):
     17        (WebKit::AcceleratedCompositingContext::syncLayersNow):
     18        (WebKit::AcceleratedCompositingContext::notifyFlushRequired):
     19        * WebCoreSupport/AcceleratedCompositingContextClutter.cpp:
     20        (WebKit::AcceleratedCompositingContext::flushPendingLayerChanges):
     21        (WebKit::AcceleratedCompositingContext::notifyFlushRequired):
     22        * WebCoreSupport/AcceleratedCompositingContextGL.cpp:
     23        (WebKit::AcceleratedCompositingContext::flushPendingLayerChanges):
     24        (WebKit::AcceleratedCompositingContext::notifyFlushRequired):
     25
    1262012-10-04  Simon Fraser  <simon.fraser@apple.com>
    227

  • trunk/Source/WebKit/gtk/WebCoreSupport/AcceleratedCompositingContext.h

    r129651 r130439  
    5959    // GraphicsLayerClient
    6060    virtual void notifyAnimationStarted(const WebCore::GraphicsLayer*, double time);
    61     virtual void notifySyncRequired(const WebCore::GraphicsLayer*);
     61    virtual void notifyFlushRequired(const WebCore::GraphicsLayer*);
    6262    virtual void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& rectToPaint);
    6363    virtual bool showDebugBorders(const WebCore::GraphicsLayer*) const;

  • trunk/Source/WebKit/gtk/WebCoreSupport/AcceleratedCompositingContextCairo.cpp

    r130400 r130439  
    9090    m_textureMapper = TextureMapperImageBuffer::create();
    9191    m_rootTextureMapperLayer->setTextureMapper(m_textureMapper.get());
    92     m_rootGraphicsLayer->syncCompositingStateForThisLayerOnly();
     92    m_rootGraphicsLayer->flushCompositingStateForThisLayerOnly();
    9393}
    9494
    … …  
    111111        return;
    112112    m_rootGraphicsLayer->setSize(size);
    113     m_rootGraphicsLayer->syncCompositingStateForThisLayerOnly();
     113    m_rootGraphicsLayer->flushCompositingStateForThisLayerOnly();
    114114}
    115115
    … …  
    136136
    137137    if (m_rootGraphicsLayer)
    138         m_rootGraphicsLayer->syncCompositingStateForThisLayerOnly();
     138        m_rootGraphicsLayer->flushCompositingStateForThisLayerOnly();
    139139
    140140    core(m_webView)->mainFrame()->view()->flushCompositingStateIncludingSubframes();
    … …  
    159159
    160160}
    161 void AcceleratedCompositingContext::notifySyncRequired(const GraphicsLayer*)
     161void AcceleratedCompositingContext::notifyFlushRequired(const GraphicsLayer*)
    162162{
    163163

  • trunk/Source/WebKit/gtk/WebCoreSupport/AcceleratedCompositingContextClutter.cpp

    r130400 r130439  
    137137{
    138138    if (m_rootGraphicsLayer)
    139         m_rootGraphicsLayer->syncCompositingStateForThisLayerOnly();
     139        m_rootGraphicsLayer->flushCompositingStateForThisLayerOnly();
    140140
    141141    return core(m_webView)->mainFrame()->view()->flushCompositingStateIncludingSubframes();
    … …  
    156156    ASSERT_NOT_REACHED();
    157157}
    158 void AcceleratedCompositingContext::notifySyncRequired(const WebCore::GraphicsLayer*)
     158void AcceleratedCompositingContext::notifyFlushRequired(const WebCore::GraphicsLayer*)
    159159{
    160160    ASSERT_NOT_REACHED();

  • trunk/Source/WebKit/gtk/WebCoreSupport/AcceleratedCompositingContextGL.cpp

    r130400 r130439  
    323323bool AcceleratedCompositingContext::flushPendingLayerChanges()
    324324{
    325     m_rootLayer->syncCompositingStateForThisLayerOnly();
    326     m_nonCompositedContentLayer->syncCompositingStateForThisLayerOnly();
     325    m_rootLayer->flushCompositingStateForThisLayerOnly();
     326    m_nonCompositedContentLayer->flushCompositingStateForThisLayerOnly();
    327327    return core(m_webView)->mainFrame()->view()->flushCompositingStateIncludingSubframes();
    328328}
    … …  
    371371
    372372}
    373 void AcceleratedCompositingContext::notifySyncRequired(const GraphicsLayer*)
     373void AcceleratedCompositingContext::notifyFlushRequired(const GraphicsLayer*)
    374374{
    375375

  • trunk/Source/WebKit/mac/ChangeLog

    r130416 r130439  
     12012-10-04  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Final part of "sync" to "flush" renaming
     4        https://bugs.webkit.org/show_bug.cgi?id=98430
     5
     6        Reviewed by Tim Horton.
     7
     8        Change method names on GraphicsLayer and GraphicsLayerClient that
     9        refer to "sync" to use the term "flush" instead, to be consistent
     10        with the rest of the code.
     11
     12        * WebView/WebView.mm:
     13
    1142012-10-03  Benjamin Poulain  <bpoulain@apple.com>
    215

  • trunk/Source/WebKit/mac/WebView/WebView.mm

    r130400 r130439  
    63306330    To fix this, the GraphicsLayerCA code in WebCore does not change the CA
    63316331    layer tree during style changes and layout; it stores up all changes and
    6332     commits them via syncCompositingState(). There are then two situations in
    6333     which we can call syncCompositingState():
    6334    
    6335     1. When painting. FrameView::paintContents() makes a call to syncCompositingState().
     6332    commits them via flushCompositingState(). There are then two situations in
     6333    which we can call flushCompositingState():
     6334   
     6335    1. When painting. FrameView::paintContents() makes a call to flushCompositingState().
    63366336   
    63376337    2. When style changes/layout have made changes to the layer tree which do not
    63386338       result in painting. In this case we need a run loop observer to do a
    6339        syncCompositingState() at an appropriate time. The observer will keep firing
     6339       flushCompositingState() at an appropriate time. The observer will keep firing
    63406340       until the time is right (essentially when there are no more pending layouts).
    63416341   

  • trunk/Source/WebKit/qt/ChangeLog

    r130400 r130439  
     12012-10-04  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Final part of "sync" to "flush" renaming
     4        https://bugs.webkit.org/show_bug.cgi?id=98430
     5
     6        Reviewed by Tim Horton.
     7
     8        Change method names on GraphicsLayer and GraphicsLayerClient that
     9        refer to "sync" to use the term "flush" instead, to be consistent
     10        with the rest of the code.
     11
     12        * WebCoreSupport/PageClientQt.cpp:
     13        (WebCore::TextureMapperLayerClientQt::syncRootLayer):
     14
    1152012-10-04  Simon Fraser  <simon.fraser@apple.com>
    216

  • trunk/Source/WebKit/qt/WebCoreSupport/PageClientQt.cpp

    r130400 r130439  
    111111void TextureMapperLayerClientQt::syncRootLayer()
    112112{
    113     m_rootGraphicsLayer->syncCompositingStateForThisLayerOnly();
     113    m_rootGraphicsLayer->flushCompositingStateForThisLayerOnly();
    114114}
    115115

  • trunk/Source/WebKit/win/ChangeLog

    r130400 r130439  
     12012-10-04  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Final part of "sync" to "flush" renaming
     4        https://bugs.webkit.org/show_bug.cgi?id=98430
     5
     6        Reviewed by Tim Horton.
     7
     8        Change method names on GraphicsLayer and GraphicsLayerClient that
     9        refer to "sync" to use the term "flush" instead, to be consistent
     10        with the rest of the code.
     11
     12        * WebView.cpp:
     13        (WebView::notifyFlushRequired):
     14        (WebView::flushPendingGraphicsLayerChanges):
     15        * WebView.h:
     16
    1172012-10-04  Simon Fraser  <simon.fraser@apple.com>
    218

  • trunk/Source/WebKit/win/WebView.cpp

    r130400 r130439  
    66326632}
    66336633
    6634 void WebView::notifySyncRequired(const GraphicsLayer*)
     6634void WebView::notifyFlushRequired(const GraphicsLayer*)
    66356635{
    66366636    flushPendingGraphicsLayerChangesSoon();
    … …  
    66746674    // Updating layout might have taken us out of compositing mode.
    66756675    if (m_backingLayer)
    6676         m_backingLayer->syncCompositingStateForThisLayerOnly();
     6676        m_backingLayer->flushCompositingStateForThisLayerOnly();
    66776677
    66786678    view->flushCompositingStateIncludingSubframes();

  • trunk/Source/WebKit/win/WebView.h

    r122676 r130439  
    10191019    // GraphicsLayerClient
    10201020    virtual void notifyAnimationStarted(const WebCore::GraphicsLayer*, double time);
    1021     virtual void notifySyncRequired(const WebCore::GraphicsLayer*);
     1021    virtual void notifyFlushRequired(const WebCore::GraphicsLayer*);
    10221022    virtual void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& inClip);
    10231023    virtual bool showDebugBorders(const WebCore::GraphicsLayer*) const;

  • trunk/Source/WebKit2/ChangeLog

    r130434 r130439  
     12012-10-04  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Final part of "sync" to "flush" renaming
     4        https://bugs.webkit.org/show_bug.cgi?id=98430
     5
     6        Reviewed by Tim Horton.
     7
     8        Change method names on GraphicsLayer and GraphicsLayerClient that
     9        refer to "sync" to use the term "flush" instead, to be consistent
     10        with the rest of the code.
     11
     12        * UIProcess/CoordinatedGraphics/LayerTreeRenderer.cpp:
     13        (WebKit::LayerTreeRenderer::paintToCurrentGLContext):
     14        (WebKit::LayerTreeRenderer::flushLayerChanges):
     15        * UIProcess/CoordinatedGraphics/LayerTreeRenderer.h:
     16        (WebKit::LayerTreeRenderer::notifyFlushRequired):
     17        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp:
     18        (WebCore::CoordinatedGraphicsLayer::didChangeLayerState):
     19        (WebCore::CoordinatedGraphicsLayer::didChangeAnimatedProperties):
     20        (WebCore::CoordinatedGraphicsLayer::didChangeChildren):
     21        (WebCore::CoordinatedGraphicsLayer::didChangeFilters):
     22        (WebCore::CoordinatedGraphicsLayer::setContentsNeedsDisplay):
     23        (WebCore::CoordinatedGraphicsLayer::setContentsToCanvas):
     24        (WebCore::CoordinatedGraphicsLayer::flushCompositingState):
     25        (WebCore::CoordinatedGraphicsLayer::flushCompositingStateForThisLayerOnly):
     26        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.h:
     27        (CoordinatedGraphicsLayer):
     28        * WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp:
     29        (WebKit::LayerTreeCoordinator::flushPendingLayerChanges):
     30        (WebKit::LayerTreeCoordinator::notifyFlushRequired):
     31        * WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.h:
     32        (LayerTreeCoordinator):
     33        * WebProcess/WebPage/ca/LayerTreeHostCA.cpp:
     34        (WebKit::LayerTreeHostCA::notifyFlushRequired):
     35        (WebKit::LayerTreeHostCA::flushPendingLayerChanges):
     36        * WebProcess/WebPage/ca/LayerTreeHostCA.h:
     37        (LayerTreeHostCA):
     38        * WebProcess/WebPage/gtk/LayerTreeHostGtk.cpp:
     39        (WebKit::LayerTreeHostGtk::notifyFlushRequired):
     40        (WebKit::LayerTreeHostGtk::flushPendingLayerChanges):
     41        * WebProcess/WebPage/gtk/LayerTreeHostGtk.h:
     42        (LayerTreeHostGtk):
     43        * WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.h:
     44        (TiledCoreAnimationDrawingArea):
     45        * WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm:
     46        (WebKit::TiledCoreAnimationDrawingArea::notifyFlushRequired):
     47        (WebKit::TiledCoreAnimationDrawingArea::flushLayers):
     48
    1492012-10-04  Christophe Dumez  <christophe.dumez@intel.com>
    250

  • trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeRenderer.cpp

    r127273 r130439  
    127127        currentRootLayer->setOpacity(opacity);
    128128        currentRootLayer->setTransform(matrix);
    129         currentRootLayer->syncCompositingStateForThisLayerOnly();
     129        currentRootLayer->flushCompositingStateForThisLayerOnly();
    130130    }
    131131
    … …  
    394394    m_renderedContentsScrollPosition = m_pendingRenderedContentsScrollPosition;
    395395
    396     m_rootLayer->syncCompositingState(FloatRect());
     396    m_rootLayer->flushCompositingState(FloatRect());
    397397    commitTileOperations();
    398398

  • trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeRenderer.h

    r127273 r130439  
    101101    // Reimplementations from WebCore::GraphicsLayerClient.
    102102    virtual void notifyAnimationStarted(const WebCore::GraphicsLayer*, double) { }
    103     virtual void notifySyncRequired(const WebCore::GraphicsLayer*) { }
     103    virtual void notifyFlushRequired(const WebCore::GraphicsLayer*) { }
    104104    virtual bool showDebugBorders(const WebCore::GraphicsLayer*) const { return false; }
    105105    virtual bool showRepaintCounter(const WebCore::GraphicsLayer*) const { return false; }

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

    r128163 r130439  
    6666    m_shouldSyncLayerState = true;
    6767    if (client())
    68         client()->notifySyncRequired(this);
     68        client()->notifyFlushRequired(this);
    6969}
    7070
    … …  
    7373    m_shouldSyncAnimatedProperties = true;
    7474    if (client())
    75         client()->notifySyncRequired(this);
     75        client()->notifyFlushRequired(this);
    7676}
    7777
    … …  
    8080    m_shouldSyncChildren = true;
    8181    if (client())
    82         client()->notifySyncRequired(this);
     82        client()->notifyFlushRequired(this);
    8383}
    8484
    … …  
    8888    m_shouldSyncFilters = true;
    8989    if (client())
    90         client()->notifySyncRequired(this);
     90        client()->notifyFlushRequired(this);
    9191}
    9292#endif
    … …  
    341341    m_canvasNeedsDisplay = true;
    342342    if (client())
    343         client()->notifySyncRequired(this);
     343        client()->notifyFlushRequired(this);
    344344}
    345345
    … …  
    349349    m_canvasNeedsDisplay = true;
    350350    if (client())
    351         client()->notifySyncRequired(this);
     351        client()->notifyFlushRequired(this);
    352352}
    353353
    … …  
    434434}
    435435
    436 void CoordinatedGraphicsLayer::syncCompositingState(const FloatRect& rect)
     436void CoordinatedGraphicsLayer::flushCompositingState(const FloatRect& rect)
    437437{
    438438    if (CoordinatedGraphicsLayer* mask = toCoordinatedGraphicsLayer(maskLayer()))
    439         mask->syncCompositingStateForThisLayerOnly();
     439        mask->flushCompositingStateForThisLayerOnly();
    440440
    441441    if (CoordinatedGraphicsLayer* replica = toCoordinatedGraphicsLayer(replicaLayer()))
    442         replica->syncCompositingStateForThisLayerOnly();
     442        replica->flushCompositingStateForThisLayerOnly();
    443443
    444444    m_CoordinatedGraphicsLayerClient->syncFixedLayers();
    445445
    446     syncCompositingStateForThisLayerOnly();
     446    flushCompositingStateForThisLayerOnly();
    447447
    448448    for (size_t i = 0; i < children().size(); ++i)
    449         children()[i]->syncCompositingState(rect);
     449        children()[i]->flushCompositingState(rect);
    450450}
    451451
    … …  
    546546}
    547547
    548 void CoordinatedGraphicsLayer::syncCompositingStateForThisLayerOnly()
     548void CoordinatedGraphicsLayer::flushCompositingStateForThisLayerOnly()
    549549{
    550550    // The remote image might have been released by purgeBackingStores.

  • trunk/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.h

    r130031 r130439  
    1     /*
     1flushCompositingState    /*
    22 Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
    33
    … …  
    116116    void setContentsScale(float);
    117117    void setVisibleContentRectTrajectoryVector(const FloatPoint&);
    118     virtual void syncCompositingState(const FloatRect&);
    119     virtual void syncCompositingStateForThisLayerOnly();
     118    virtual void flushCompositingState(const FloatRect&);
     119    virtual void flushCompositingStateForThisLayerOnly();
    120120#if ENABLE(CSS_FILTERS)
    121121    bool setFilters(const FilterOperations&);

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

    r130400 r130439  
    260260
    261261    bool didSync = m_webPage->corePage()->mainFrame()->view()->flushCompositingStateIncludingSubframes();
    262     m_nonCompositedContentLayer->syncCompositingStateForThisLayerOnly();
     262    m_nonCompositedContentLayer->flushCompositingStateForThisLayerOnly();
    263263    if (m_pageOverlayLayer)
    264         m_pageOverlayLayer->syncCompositingStateForThisLayerOnly();
    265 
    266     m_rootLayer->syncCompositingStateForThisLayerOnly();
     264        m_pageOverlayLayer->flushCompositingStateForThisLayerOnly();
     265
     266    m_rootLayer->flushCompositingStateForThisLayerOnly();
    267267
    268268    if (m_shouldSyncRootLayer) {
    … …  
    515515}
    516516
    517 void LayerTreeCoordinator::notifySyncRequired(const WebCore::GraphicsLayer*)
     517void LayerTreeCoordinator::notifyFlushRequired(const WebCore::GraphicsLayer*)
    518518{
    519519}

  • trunk/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.h

    r130208 r130439  
    103103    // GraphicsLayerClient
    104104    virtual void notifyAnimationStarted(const WebCore::GraphicsLayer*, double time);
    105     virtual void notifySyncRequired(const WebCore::GraphicsLayer*);
     105    virtual void notifyFlushRequired(const WebCore::GraphicsLayer*);
    106106    virtual void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& clipRect);
    107107    virtual bool showDebugBorders(const WebCore::GraphicsLayer*) const;

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

    r130400 r130439  
    187187}
    188188
    189 void LayerTreeHostCA::notifySyncRequired(const WebCore::GraphicsLayer*)
     189void LayerTreeHostCA::notifyFlushRequired(const WebCore::GraphicsLayer*)
    190190{
    191191}
    … …  
    246246bool LayerTreeHostCA::flushPendingLayerChanges()
    247247{
    248     m_rootLayer->syncCompositingStateForThisLayerOnly();
    249     m_nonCompositedContentLayer->syncCompositingStateForThisLayerOnly();
     248    m_rootLayer->flushCompositingStateForThisLayerOnly();
     249    m_nonCompositedContentLayer->flushCompositingStateForThisLayerOnly();
    250250    if (m_pageOverlayLayer)
    251         m_pageOverlayLayer->syncCompositingStateForThisLayerOnly();
     251        m_pageOverlayLayer->flushCompositingStateForThisLayerOnly();
    252252
    253253    return m_webPage->corePage()->mainFrame()->view()->flushCompositingStateIncludingSubframes();

  • trunk/Source/WebKit2/WebProcess/WebPage/ca/LayerTreeHostCA.h

    r116478 r130439  
    7575    // GraphicsLayerClient
    7676    virtual void notifyAnimationStarted(const WebCore::GraphicsLayer*, double time);
    77     virtual void notifySyncRequired(const WebCore::GraphicsLayer*);
     77    virtual void notifyFlushRequired(const WebCore::GraphicsLayer*);
    7878    virtual void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& clipRect);
    7979    virtual bool showDebugBorders(const WebCore::GraphicsLayer*) const;

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

    r130400 r130439  
    242242}
    243243
    244 void LayerTreeHostGtk::notifySyncRequired(const WebCore::GraphicsLayer*)
     244void LayerTreeHostGtk::notifyFlushRequired(const WebCore::GraphicsLayer*)
    245245{
    246246}
    … …  
    288288bool LayerTreeHostGtk::flushPendingLayerChanges()
    289289{
    290     m_rootLayer->syncCompositingStateForThisLayerOnly();
    291     m_nonCompositedContentLayer->syncCompositingStateForThisLayerOnly();
     290    m_rootLayer->flushCompositingStateForThisLayerOnly();
     291    m_nonCompositedContentLayer->flushCompositingStateForThisLayerOnly();
    292292    if (m_pageOverlayLayer)
    293         m_pageOverlayLayer->syncCompositingStateForThisLayerOnly();
     293        m_pageOverlayLayer->flushCompositingStateForThisLayerOnly();
    294294
    295295    return m_webPage->corePage()->mainFrame()->view()->flushCompositingStateIncludingSubframes();

  • trunk/Source/WebKit2/WebProcess/WebPage/gtk/LayerTreeHostGtk.h

    r128907 r130439  
    7676    // GraphicsLayerClient
    7777    virtual void notifyAnimationStarted(const WebCore::GraphicsLayer*, double time);
    78     virtual void notifySyncRequired(const WebCore::GraphicsLayer*);
     78    virtual void notifyFlushRequired(const WebCore::GraphicsLayer*);
    7979    virtual void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& clipRect);
    8080    virtual bool showDebugBorders(const WebCore::GraphicsLayer*) const;

  • trunk/Source/WebKit2/WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.h

    r130400 r130439  
    7171    // WebCore::GraphicsLayerClient
    7272    virtual void notifyAnimationStarted(const WebCore::GraphicsLayer*, double time) OVERRIDE;
    73     virtual void notifySyncRequired(const WebCore::GraphicsLayer*) OVERRIDE;
     73    virtual void notifyFlushRequired(const WebCore::GraphicsLayer*) OVERRIDE;
    7474    virtual void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& clipRect) OVERRIDE;
    7575    virtual bool showDebugBorders(const WebCore::GraphicsLayer*) const OVERRIDE;

  • trunk/Source/WebKit2/WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm

    r130400 r130439  
    264264}
    265265
    266 void TiledCoreAnimationDrawingArea::notifySyncRequired(const GraphicsLayer*)
     266void TiledCoreAnimationDrawingArea::notifyFlushRequired(const GraphicsLayer*)
    267267{
    268268}
    … …  
    306306    if (m_pageOverlayLayer) {
    307307        m_pageOverlayLayer->setNeedsDisplay();
    308         m_pageOverlayLayer->syncCompositingStateForThisLayerOnly();
     308        m_pageOverlayLayer->flushCompositingStateForThisLayerOnly();
    309309    }
    310310
Note: See TracChangeset for help on using the changeset viewer.