platform/graphics/texmap/coordinated/CompositingCoordinator.cpp

        platform/graphics/texmap/coordinated/CompositingCoordinator.h \

        platform/graphics/texmap/coordinated/CompositingCoordinator.cpp \

/*

 * Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).

 * Copyright (C) 2013 Company 100, Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#if USE(COORDINATED_GRAPHICS)

#include "CompositingCoordinator.h"

#include "Frame.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "InspectorController.h"

#include "Page.h"

#include "Settings.h"

#include <wtf/CurrentTime.h>

#include <wtf/TemporaryChange.h>

namespace WebCore {

PassOwnPtr<CompositingCoordinator> CompositingCoordinator::create(Page* page, CompositingCoordinator::Client* client)

{

    return adoptPtr(new CompositingCoordinator(page, client));

}

CompositingCoordinator::~CompositingCoordinator()

{

    purgeBackingStores();

    LayerMap::iterator end = m_registeredLayers.end();

    for (LayerMap::iterator it = m_registeredLayers.begin(); it != end; ++it)

        it->value->setCoordinator(0);

}

CompositingCoordinator::CompositingCoordinator(Page* page, CompositingCoordinator::Client* client)

    : m_page(page)

    , m_client(client)

    , m_rootCompositingLayer(0)

    , m_isPurging(false)

    , m_isFlushingLayerChanges(false)

    , m_shouldSyncFrame(false)

    , m_didInitializeRootCompositingLayer(false)

    , m_releaseInactiveAtlasesTimer(this, &CompositingCoordinator::releaseInactiveAtlasesTimerFired)

#if ENABLE(REQUEST_ANIMATION_FRAME)

    , m_lastAnimationServiceTime(0)

#endif

{

    m_page->settings()->setApplyDeviceScaleFactorInCompositor(true);

    // This is a temporary way to enable this only in the GL case, until TextureMapperImageBuffer is removed.

    // See https://bugs.webkit.org/show_bug.cgi?id=114869

    CoordinatedGraphicsLayer::setShouldSupportContentsTiling(true);

}

void CompositingCoordinator::setRootCompositingLayer(GraphicsLayer* layer)

{

    if (m_rootCompositingLayer)

        m_rootCompositingLayer->removeFromParent();

    m_rootCompositingLayer = layer;

    if (m_rootCompositingLayer)

        m_rootLayer->addChildAtIndex(m_rootCompositingLayer, 0);

}

void CompositingCoordinator::sizeDidChange(const IntSize& newSize)

{

    m_rootLayer->setSize(newSize);

    m_client->notifyFlushRequired();

}

bool CompositingCoordinator::flushPendingLayerChanges()

{

    TemporaryChange<bool> protector(m_isFlushingLayerChanges, true);

    initializeRootCompositingLayerIfNeeded();

    m_rootLayer->flushCompositingStateForThisLayerOnly();

    m_client->didFlushRootLayer();

    bool didSync = m_page->mainFrame()->view()->flushCompositingStateIncludingSubframes();

    toCoordinatedGraphicsLayer(m_rootLayer.get())->updateContentBuffersIncludingSubLayers();

    toCoordinatedGraphicsLayer(m_rootLayer.get())->syncPendingStateChangesIncludingSubLayers();

    flushPendingImageBackingChanges();

    if (m_shouldSyncFrame) {

        didSync = true;

        if (m_rootCompositingLayer) {

            m_state.contentsSize = roundedIntSize(m_rootCompositingLayer->size());

            if (CoordinatedGraphicsLayer* contentsLayer = mainContentsLayer())

                m_state.coveredRect = contentsLayer->coverRect();

        }

        m_state.scrollPosition = m_visibleContentsRect.location();

        m_client->commitSceneState(m_state);

        clearPendingStateChanges();

        m_shouldSyncFrame = false;

    }

    return didSync;

}

void CompositingCoordinator::syncDisplayState()

{

#if ENABLE(INSPECTOR)

    m_page->inspectorController()->didBeginFrame();

#endif

#if ENABLE(REQUEST_ANIMATION_FRAME) && !USE(REQUEST_ANIMATION_FRAME_TIMER) && !USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)

    // Make sure that any previously registered animation callbacks are being executed before we flush the layers.

    m_lastAnimationServiceTime = WTF::monotonicallyIncreasingTime();

    m_page->mainFrame()->view()->serviceScriptedAnimations(m_lastAnimationServiceTime);

#endif

    m_page->mainFrame()->view()->updateLayoutAndStyleIfNeededRecursive();

}

#if ENABLE(REQUEST_ANIMATION_FRAME)

double CompositingCoordinator::nextAnimationServiceTime() const

{

    // According to the requestAnimationFrame spec, rAF callbacks should not be faster than 60FPS.

    static const double MinimalTimeoutForAnimations = 1. / 60.;

    return std::max<double>(0., MinimalTimeoutForAnimations - WTF::monotonicallyIncreasingTime() + m_lastAnimationServiceTime);

}

#endif

void CompositingCoordinator::clearPendingStateChanges()

{

    m_state.layersToCreate.clear();

    m_state.layersToUpdate.clear();

    m_state.layersToRemove.clear();

    m_state.imagesToCreate.clear();

    m_state.imagesToRemove.clear();

    m_state.imagesToUpdate.clear();

    m_state.imagesToClear.clear();

    m_state.updateAtlasesToCreate.clear();

    m_state.updateAtlasesToRemove.clear();

#if ENABLE(CSS_SHADERS)

    m_state.customFiltersToCreate.clear();

    m_state.customFiltersToRemove.clear();

#endif

}

void CompositingCoordinator::initializeRootCompositingLayerIfNeeded()

{

    if (m_didInitializeRootCompositingLayer)

        return;

    m_state.rootCompositingLayer = toCoordinatedGraphicsLayer(m_rootLayer.get())->id();

    m_didInitializeRootCompositingLayer = true;

    m_shouldSyncFrame = true;

}

void CompositingCoordinator::createRootLayer(const IntSize& size)

{

    ASSERT(!m_rootLayer);

    // Create a root layer.

    m_rootLayer = GraphicsLayer::create(this, this);

#ifndef NDEBUG

    m_rootLayer->setName("CompositingCoordinator root layer");

#endif

    m_rootLayer->setDrawsContent(false);

    m_rootLayer->setSize(size);

}

void CompositingCoordinator::syncLayerState(CoordinatedLayerID id, CoordinatedGraphicsLayerState& state)

{

    m_shouldSyncFrame = true;

    m_client->willSyncLayerState(state);

    m_state.layersToUpdate.append(std::make_pair(id, state));

}

PassRefPtr<CoordinatedImageBacking> CompositingCoordinator::createImageBackingIfNeeded(Image* image)

{

    CoordinatedImageBackingID imageID = CoordinatedImageBacking::getCoordinatedImageBackingID(image);

    ImageBackingMap::iterator it = m_imageBackings.find(imageID);

    RefPtr<CoordinatedImageBacking> imageBacking;

    if (it == m_imageBackings.end()) {

        imageBacking = CoordinatedImageBacking::create(this, image);

        m_imageBackings.add(imageID, imageBacking);

    } else

        imageBacking = it->value;

    return imageBacking;

}

void CompositingCoordinator::createImageBacking(CoordinatedImageBackingID imageID)

{

    m_state.imagesToCreate.append(imageID);

}

void CompositingCoordinator::updateImageBacking(CoordinatedImageBackingID imageID, PassRefPtr<CoordinatedSurface> coordinatedSurface)

{

    m_shouldSyncFrame = true;

    m_state.imagesToUpdate.append(std::make_pair(imageID, coordinatedSurface));

}

void CompositingCoordinator::clearImageBackingContents(CoordinatedImageBackingID imageID)

{

    m_shouldSyncFrame = true;

    m_state.imagesToClear.append(imageID);

}

void CompositingCoordinator::removeImageBacking(CoordinatedImageBackingID imageID)

{

    if (m_isPurging)

        return;

    ASSERT(m_imageBackings.contains(imageID));

    m_imageBackings.remove(imageID);

    m_state.imagesToRemove.append(imageID);

}

void CompositingCoordinator::flushPendingImageBackingChanges()

{

    ImageBackingMap::iterator end = m_imageBackings.end();

    for (ImageBackingMap::iterator iter = m_imageBackings.begin(); iter != end; ++iter)

        iter->value->update();

}

void CompositingCoordinator::notifyAnimationStarted(const GraphicsLayer*, double /* time */)

{

}

void CompositingCoordinator::notifyFlushRequired(const GraphicsLayer*)

{

    m_client->notifyFlushRequired();

}

void CompositingCoordinator::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& graphicsContext, GraphicsLayerPaintingPhase, const IntRect& clipRect)

{

    m_client->paintLayerContents(graphicsLayer, graphicsContext, clipRect);

}

PassOwnPtr<GraphicsLayer> CompositingCoordinator::createGraphicsLayer(GraphicsLayerClient* client)

{

    CoordinatedGraphicsLayer* layer = new CoordinatedGraphicsLayer(client);

    layer->setCoordinator(this);

    m_registeredLayers.add(layer->id(), layer);

    m_state.layersToCreate.append(layer->id());

    layer->setNeedsVisibleRectAdjustment();

    m_client->notifyFlushRequired();

    return adoptPtr(layer);

}

float CompositingCoordinator::deviceScaleFactor() const

{

    return m_page->deviceScaleFactor();

}

float CompositingCoordinator::pageScaleFactor() const

{

    return m_page->pageScaleFactor();

}

void CompositingCoordinator::createUpdateAtlas(uint32_t atlasID, PassRefPtr<CoordinatedSurface> coordinatedSurface)

{

    m_state.updateAtlasesToCreate.append(std::make_pair(atlasID, coordinatedSurface));

}

void CompositingCoordinator::removeUpdateAtlas(uint32_t atlasID)

{

    if (m_isPurging)

        return;

    m_state.updateAtlasesToRemove.append(atlasID);

}

FloatRect CompositingCoordinator::visibleContentsRect() const

{

    return m_visibleContentsRect;

}

CoordinatedGraphicsLayer* CompositingCoordinator::mainContentsLayer()

{

    if (!m_rootCompositingLayer)

        return 0;

    return toCoordinatedGraphicsLayer(m_rootCompositingLayer)->findFirstDescendantWithContentsRecursively();

}

void CompositingCoordinator::setVisibleContentsRect(const FloatRect& rect, const FloatPoint& trajectoryVector)

{

    // A zero trajectoryVector indicates that tiles all around the viewport are requested.

    if (CoordinatedGraphicsLayer* contentsLayer = mainContentsLayer())

        contentsLayer->setVisibleContentRectTrajectoryVector(trajectoryVector);

    bool contentsRectDidChange = rect != m_visibleContentsRect;

    if (contentsRectDidChange) {

        m_visibleContentsRect = rect;

        LayerMap::iterator end = m_registeredLayers.end();

        for (LayerMap::iterator it = m_registeredLayers.begin(); it != end; ++it)

            it->value->setNeedsVisibleRectAdjustment();

    }

    FrameView* view = m_page->mainFrame()->view();

    if (view->useFixedLayout()) {

        // Round the rect instead of enclosing it to make sure that its size stays

        // the same while panning. This can have nasty effects on layout.

        view->setFixedVisibleContentRect(roundedIntRect(rect));

    }

}

void CompositingCoordinator::deviceOrPageScaleFactorChanged()

{

    m_rootLayer->deviceOrPageScaleFactorChanged();

}

void CompositingCoordinator::detachLayer(CoordinatedGraphicsLayer* layer)

{

    if (m_isPurging)

        return;

    m_registeredLayers.remove(layer->id());

    size_t index = m_state.layersToCreate.find(layer->id());

    if (index != notFound) {

        m_state.layersToCreate.remove(index);

        return;

    }

    m_state.layersToRemove.append(layer->id());

    m_client->notifyFlushRequired();

}

void CompositingCoordinator::commitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset)

{

    LayerMap::iterator i = m_registeredLayers.find(layerID);

    if (i == m_registeredLayers.end())

        return;

    i->value->commitScrollOffset(offset);

}

void CompositingCoordinator::renderNextFrame()

{

    for (unsigned i = 0; i < m_updateAtlases.size(); ++i)

        m_updateAtlases[i]->didSwapBuffers();

}

void CompositingCoordinator::purgeBackingStores()

{

    TemporaryChange<bool> purgingToggle(m_isPurging, true);

    LayerMap::iterator end = m_registeredLayers.end();

    for (LayerMap::iterator it = m_registeredLayers.begin(); it != end; ++it)

        it->value->purgeBackingStores();

    m_imageBackings.clear();

    m_updateAtlases.clear();

}

bool CompositingCoordinator::paintToSurface(const IntSize& size, CoordinatedSurface::Flags flags, uint32_t& atlasID, IntPoint& offset, CoordinatedSurface::Client* client)

{

    for (unsigned i = 0; i < m_updateAtlases.size(); ++i) {

        UpdateAtlas* atlas = m_updateAtlases[i].get();

        if (atlas->supportsAlpha() == (flags & CoordinatedSurface::SupportsAlpha)) {

            // This will be false if there is no available buffer space.

            if (atlas->paintOnAvailableBuffer(size, atlasID, offset, client))

                return true;

        }

    }

    static const int ScratchBufferDimension = 1024; // Should be a power of two.

    m_updateAtlases.append(adoptPtr(new UpdateAtlas(this, ScratchBufferDimension, flags)));

    scheduleReleaseInactiveAtlases();

    return m_updateAtlases.last()->paintOnAvailableBuffer(size, atlasID, offset, client);

}

const double ReleaseInactiveAtlasesTimerInterval = 0.5;

void CompositingCoordinator::scheduleReleaseInactiveAtlases()

{

    if (!m_releaseInactiveAtlasesTimer.isActive())

        m_releaseInactiveAtlasesTimer.startRepeating(ReleaseInactiveAtlasesTimerInterval);

}

void CompositingCoordinator::releaseInactiveAtlasesTimerFired(Timer<CompositingCoordinator>*)

{

    // We always want to keep one atlas for non-composited content.

    OwnPtr<UpdateAtlas> atlasToKeepAnyway;

    bool foundActiveAtlasForNonCompositedContent = false;

    for (int i = m_updateAtlases.size() - 1;  i >= 0; --i) {

        UpdateAtlas* atlas = m_updateAtlases[i].get();

        if (!atlas->isInUse())

            atlas->addTimeInactive(ReleaseInactiveAtlasesTimerInterval);

        bool usableForNonCompositedContent = !atlas->supportsAlpha();

        if (atlas->isInactive()) {

            if (!foundActiveAtlasForNonCompositedContent && !atlasToKeepAnyway && usableForNonCompositedContent)

                atlasToKeepAnyway = m_updateAtlases[i].release();

            m_updateAtlases.remove(i);

        } else if (usableForNonCompositedContent)

            foundActiveAtlasForNonCompositedContent = true;

    }

    if (!foundActiveAtlasForNonCompositedContent && atlasToKeepAnyway)

        m_updateAtlases.append(atlasToKeepAnyway.release());

    if (m_updateAtlases.size() <= 1)

        m_releaseInactiveAtlasesTimer.stop();

}

} // namespace WebCore

#endif // USE(COORDINATED_GRAPHICS)

/*

 * Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies)

 * Copyright (C) 2013 Company 100, Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#ifndef CompositingCoordinator_h

#define CompositingCoordinator_h

#if USE(COORDINATED_GRAPHICS)

#include "CoordinatedGraphicsLayer.h"

#include "CoordinatedGraphicsState.h"

#include "CoordinatedImageBacking.h"

#include "FloatPoint.h"

#include "GraphicsLayerClient.h"

#include "GraphicsLayerFactory.h"

#include "IntRect.h"

#include "Timer.h"

#include "UpdateAtlas.h"

#include <wtf/OwnPtr.h>

#if ENABLE(CSS_SHADERS)

#include "FilterOperations.h"

#endif

namespace WebCore {

class Page;

class GraphicsContext;

class GraphicsLayer;

class CoordinatedSurface;

class CompositingCoordinator : public GraphicsLayerClient

    , public CoordinatedGraphicsLayerClient

    , public CoordinatedImageBacking::Client

    , public UpdateAtlas::Client

    , public GraphicsLayerFactory {

    WTF_MAKE_NONCOPYABLE(CompositingCoordinator); WTF_MAKE_FAST_ALLOCATED;

public:

    class Client {

    public:

        virtual void didFlushRootLayer() = 0;

        virtual void willSyncLayerState(CoordinatedGraphicsLayerState&) = 0;

        virtual void notifyFlushRequired() = 0;

        virtual void commitSceneState(CoordinatedGraphicsState&) = 0;

        virtual void paintLayerContents(const GraphicsLayer*, GraphicsContext&, const IntRect& clipRect) = 0;

    };

    static PassOwnPtr<CompositingCoordinator> create(Page*, CompositingCoordinator::Client*);

    virtual ~CompositingCoordinator();

    void setRootCompositingLayer(GraphicsLayer*);

    void sizeDidChange(const IntSize& newSize);

    void deviceOrPageScaleFactorChanged();

    void setVisibleContentsRect(const FloatRect&, const FloatPoint&);

    void renderNextFrame();

    void purgeBackingStores();

    void commitScrollOffset(uint32_t layerID, const IntSize& offset);

    void createRootLayer(const IntSize&);

    void clearRootLayer() { m_rootLayer = nullptr; }

    GraphicsLayer* rootLayer() const { return m_rootLayer.get(); }

    CoordinatedGraphicsLayer* mainContentsLayer();

    bool flushPendingLayerChanges();

    CoordinatedGraphicsState& state() { return m_state; }

    void syncDisplayState();

#if ENABLE(REQUEST_ANIMATION_FRAME)

    double nextAnimationServiceTime() const;

#endif

private:

    CompositingCoordinator(Page*, CompositingCoordinator::Client*);

    // GraphicsLayerClient

    virtual void notifyAnimationStarted(const GraphicsLayer*, double time) OVERRIDE;

    virtual void notifyFlushRequired(const GraphicsLayer*) OVERRIDE;

    virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const IntRect& clipRect) OVERRIDE;

    virtual float deviceScaleFactor() const OVERRIDE;

    virtual float pageScaleFactor() const OVERRIDE;

    // CoordinatedImageBacking::Client

    virtual void createImageBacking(CoordinatedImageBackingID) OVERRIDE;

    virtual void updateImageBacking(CoordinatedImageBackingID, PassRefPtr<CoordinatedSurface>) OVERRIDE;

    virtual void clearImageBackingContents(CoordinatedImageBackingID) OVERRIDE;

    virtual void removeImageBacking(CoordinatedImageBackingID) OVERRIDE;

    // CoordinatedGraphicsLayerClient

    virtual bool isFlushingLayerChanges() const OVERRIDE { return m_isFlushingLayerChanges; }

    virtual FloatRect visibleContentsRect() const OVERRIDE;

    virtual PassRefPtr<CoordinatedImageBacking> createImageBackingIfNeeded(Image*) OVERRIDE;

    virtual void detachLayer(CoordinatedGraphicsLayer*) OVERRIDE;

    virtual bool paintToSurface(const WebCore::IntSize&, WebCore::CoordinatedSurface::Flags, uint32_t& /* atlasID */, WebCore::IntPoint&, WebCore::CoordinatedSurface::Client*) OVERRIDE;

    virtual void syncLayerState(CoordinatedLayerID, CoordinatedGraphicsLayerState&) OVERRIDE;

    // UpdateAtlas::Client

    virtual void createUpdateAtlas(uint32_t atlasID, PassRefPtr<CoordinatedSurface>) OVERRIDE;

    virtual void removeUpdateAtlas(uint32_t atlasID) OVERRIDE;

    // GraphicsLayerFactory

    virtual PassOwnPtr<GraphicsLayer> createGraphicsLayer(GraphicsLayerClient*) OVERRIDE;

    void initializeRootCompositingLayerIfNeeded();

    void flushPendingImageBackingChanges();

    void clearPendingStateChanges();

    void scheduleReleaseInactiveAtlases();

    void releaseInactiveAtlasesTimerFired(Timer<CompositingCoordinator>*);

    Page* m_page;

    CompositingCoordinator::Client* m_client;

    OwnPtr<GraphicsLayer> m_rootLayer;

    GraphicsLayer* m_rootCompositingLayer;

    CoordinatedGraphicsState m_state;

    typedef HashMap<CoordinatedLayerID, CoordinatedGraphicsLayer*> LayerMap;

    LayerMap m_registeredLayers;

    typedef HashMap<CoordinatedImageBackingID, RefPtr<CoordinatedImageBacking> > ImageBackingMap;

    ImageBackingMap m_imageBackings;

    Vector<OwnPtr<UpdateAtlas> > m_updateAtlases;

    // We don't send the messages related to releasing resources to renderer during purging, because renderer already had removed all resources.

    bool m_isPurging;

    bool m_isFlushingLayerChanges;

    FloatRect m_visibleContentsRect;

    bool m_shouldSyncFrame;

    bool m_didInitializeRootCompositingLayer;

    Timer<CompositingCoordinator> m_releaseInactiveAtlasesTimer;

#if ENABLE(REQUEST_ANIMATION_FRAME)

    double m_lastAnimationServiceTime;

#endif

};

}

#endif

#endif // CompositingCoordinator_h