Attachment #205548 for bug #104360

View Details Raw Unified Return to Bug 104360

| Differences between



2013-03-13  Gwang Yoon Hwang  <ryumiel@company100.net>

        Coordinated Graphics: Separate CoordinatedLayerTreeHost into CoordinatedLayerTreeHost and CompositingCoordinator
        https://bugs.webkit.org/show_bug.cgi?id=104360

        Reviewed by Noam Rosenthal.

        The CoordinatedLayerTreeHost has too many responsibilities. It
        implements LayerTreeHost, GraphicsLayerClient,
        CoordinatedGraphicsLayerClient, CoordinatedImageBacking::Client,
        UpdateAtlas::Client, GraphicsLayerFactory and
        WebCustomFilterProgramProxyClient.

        This refactoring reduces the responsibilities of CoordinatedLayerTreeHost.

        This patch introduces a new class called CompositingCoordinator, which
        takes the responsibility of managing compositing resources in
        WebProcess.

        CoordinatedLayerTreeHost is responsible only for the scheduling and
        IPC-specific stuff, which are relevant only for WebKit2.

        No new tests, covered by existing tests.

        * CMakeLists.txt:
        * Target.pri:
        * platform/graphics/texmap/coordinated/CompositingCoordinator.cpp: Added.
        (WebCore::CompositingCoordinator::create):
        (WebCore::CompositingCoordinator::~CompositingCoordinator):
        (WebCore::CompositingCoordinator::CompositingCoordinator):
        (WebCore::CompositingCoordinator::setRootCompositingLayer):
        (WebCore::CompositingCoordinator::sizeDidChange):
        (WebCore::CompositingCoordinator::flushPendingLayerChanges):
        (WebCore::CompositingCoordinator::syncDisplayState):
        (WebCore::CompositingCoordinator::nextAnimationServiceTime):
        (WebCore::CompositingCoordinator::clearPendingStateChanges):
        (WebCore::CompositingCoordinator::initializeRootCompositingLayerIfNeeded):
        (WebCore::CompositingCoordinator::createRootLayer):
        (WebCore::CompositingCoordinator::syncLayerState):
        (WebCore::CompositingCoordinator::createImageBackingIfNeeded):
        (WebCore::CompositingCoordinator::createImageBacking):
        (WebCore::CompositingCoordinator::updateImageBacking):
        (WebCore::CompositingCoordinator::clearImageBackingContents):
        (WebCore::CompositingCoordinator::removeImageBacking):
        (WebCore::CompositingCoordinator::flushPendingImageBackingChanges):
        (WebCore::CompositingCoordinator::notifyAnimationStarted):
        (WebCore::CompositingCoordinator::notifyFlushRequired):
        (WebCore::CompositingCoordinator::paintContents):
        (WebCore::CompositingCoordinator::createGraphicsLayer):
        (WebCore::CompositingCoordinator::deviceScaleFactor):
        (WebCore::CompositingCoordinator::pageScaleFactor):
        (WebCore::CompositingCoordinator::createUpdateAtlas):
        (WebCore::CompositingCoordinator::removeUpdateAtlas):
        (WebCore::CompositingCoordinator::visibleContentsRect):
        (WebCore::CompositingCoordinator::mainContentsLayer):
        (WebCore::CompositingCoordinator::setVisibleContentsRect):
        (WebCore::CompositingCoordinator::deviceOrPageScaleFactorChanged):
        (WebCore::CompositingCoordinator::detachLayer):
        (WebCore::CompositingCoordinator::commitScrollOffset):
        (WebCore::CompositingCoordinator::renderNextFrame):
        (WebCore::CompositingCoordinator::purgeBackingStores):
        (WebCore::CompositingCoordinator::paintToSurface):
        (WebCore::CompositingCoordinator::scheduleReleaseInactiveAtlases):
        (WebCore::CompositingCoordinator::releaseInactiveAtlasesTimerFired):
        * platform/graphics/texmap/coordinated/CompositingCoordinator.h: Added.
        (WebCore::CompositingCoordinator::clearRootLayer):
        (WebCore::CompositingCoordinator::rootLayer):
        (WebCore::CompositingCoordinator::state):

2013-06-26  Roger Fong  <roger_fong@apple.com>

        Add an accessibility delegate interface to AppleWin port.



2013-03-13  Gwang Yoon Hwang  <ryumiel@company100.net>

        Coordinated Graphics: Separate CoordinatedLayerTreeHost into CoordinatedLayerTreeHost and CompositingCoordinator
        https://bugs.webkit.org/show_bug.cgi?id=104360

        Reviewed by Noam Rosenthal.

        The CoordinatedLayerTreeHost has too many responsibilities. It
        implements LayerTreeHost, GraphicsLayerClient,
        CoordinatedGraphicsLayerClient, CoordinatedImageBacking::Client,
        UpdateAtlas::Client, GraphicsLayerFactory and
        WebCustomFilterProgramProxyClient.

        This refactoring reduces the responsibilities of CoordinatedLayerTreeHost.

        This patch introduces a new class called CompositingCoordinator, which
        takes the responsibility of managing compositing resources in
        WebProcess.

        CoordinatedLayerTreeHost is responsible only for the scheduling and
        IPC-specific stuff, which are relevant only for WebKit2.

        No new tests, covered by existing tests.

        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.cpp:
        (WebKit::CoordinatedLayerTreeHost::~CoordinatedLayerTreeHost):
        (WebKit::CoordinatedLayerTreeHost::CoordinatedLayerTreeHost):
        (WebKit::CoordinatedLayerTreeHost::setRootCompositingLayer):
        (WebKit::CoordinatedLayerTreeHost::invalidate):
        (WebKit::CoordinatedLayerTreeHost::forceRepaint):
        (WebKit::CoordinatedLayerTreeHost::sizeDidChange):
        (WebKit::CoordinatedLayerTreeHost::setVisibleContentsRect):
        (WebKit::CoordinatedLayerTreeHost::renderNextFrame):
        (WebKit::CoordinatedLayerTreeHost::purgeBackingStores):
        (WebKit::CoordinatedLayerTreeHost::willSyncLayerState):
        (WebKit::CoordinatedLayerTreeHost::prepareCustomFilterProxiesForAnimations):
        (WebKit::CoordinatedLayerTreeHost::checkCustomFilterProgramProxies):
        (WebKit::CoordinatedLayerTreeHost::removeCustomFilterProgramProxy):
        (WebKit::CoordinatedLayerTreeHost::didFlushRootLayer):
        (WebKit::CoordinatedLayerTreeHost::performScheduledLayerFlush):
        (WebKit::CoordinatedLayerTreeHost::createPageOverlayLayer):
        (WebKit::CoordinatedLayerTreeHost::paintLayerContents):
        (WebKit::CoordinatedLayerTreeHost::commitSceneState):
        (WebKit::CoordinatedLayerTreeHost::deviceOrPageScaleFactorChanged):
        (WebKit::CoordinatedLayerTreeHost::graphicsLayerFactory):
        (WebKit::CoordinatedLayerTreeHost::scheduleAnimation):
        (WebKit::CoordinatedLayerTreeHost::commitScrollOffset):
        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h:
        * WebProcess/WebPage/LayerTreeHost.h:

2013-06-26  Simon Cooper  <scooper@apple.com>

        QuickTime plug-in cannot update com.apple.quicktime.plugin.preferences.plist file

Lines 1978-1983 set(WebCore_SOURCES a/Source/WebCore/CMakeLists.txt_sec1
- a/Source/WebCore/CMakeLists.txt +1 lines
1978	platform/graphics/filters/SpotLightSource.cpp	1978	platform/graphics/filters/SpotLightSource.cpp
1979		1979
1980	platform/graphics/texmap/coordinated/AreaAllocator.cpp	1980	platform/graphics/texmap/coordinated/AreaAllocator.cpp
		1981	platform/graphics/texmap/coordinated/CompositingCoordinator.cpp
1981	platform/graphics/texmap/coordinated/CoordinatedBackingStore.cpp	1982	platform/graphics/texmap/coordinated/CoordinatedBackingStore.cpp
1982	platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp	1983	platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp
1983	platform/graphics/texmap/coordinated/CoordinatedGraphicsScene.cpp	1984	platform/graphics/texmap/coordinated/CoordinatedGraphicsScene.cpp



        platform/graphics/texmap/TextureMapperGL.h \
        platform/graphics/texmap/TextureMapperShaderProgram.h \
        platform/graphics/texmap/coordinated/AreaAllocator.h \
        platform/graphics/texmap/coordinated/CompositingCoordinator.h \
        platform/graphics/texmap/coordinated/CoordinatedBackingStore.h \
        platform/graphics/texmap/coordinated/CoordinatedCustomFilterOperation.h \
        platform/graphics/texmap/coordinated/CoordinatedCustomFilterProgram.h \

        platform/graphics/texmap/TextureMapperGL.cpp \
        platform/graphics/texmap/TextureMapperShaderProgram.cpp \
        platform/graphics/texmap/coordinated/AreaAllocator.cpp \
        platform/graphics/texmap/coordinated/CompositingCoordinator.cpp \
        platform/graphics/texmap/coordinated/CoordinatedBackingStore.cpp \
        platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp \
        platform/graphics/texmap/coordinated/CoordinatedGraphicsScene.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



#include "WebPageProxyMessages.h"
#include <WebCore/Frame.h>
#include <WebCore/FrameView.h>
#include <WebCore/GraphicsSurface.h>
#include <WebCore/InspectorController.h>
#include <WebCore/Page.h>
#include <WebCore/RenderLayer.h>
#include <WebCore/RenderLayerBacking.h>
#include <WebCore/RenderLayerCompositor.h>
#include <WebCore/RenderView.h>
#include <WebCore/Settings.h>
#include <WebCore/SurfaceUpdateInfo.h>
#include <WebCore/TextureMapperPlatformLayer.h>
#include <wtf/CurrentTime.h>
#include <wtf/TemporaryChange.h>

#if ENABLE(CSS_SHADERS)
#include "CustomFilterValidatedProgram.h"

#if ENABLE(CSS_SHADERS)
    disconnectCustomFilterPrograms();
#endif
    purgeBackingStores();

    LayerMap::iterator end = m_registeredLayers.end();
    for (LayerMap::iterator it = m_registeredLayers.begin(); it != end; ++it)
        it->value->setCoordinator(0);
}

CoordinatedLayerTreeHost::CoordinatedLayerTreeHost(WebPage* webPage)
    : LayerTreeHost(webPage)
    , m_rootCompositingLayer(0)
    , m_notifyAfterScheduledLayerFlush(false)
    , m_isValid(true)
    , m_isPurging(false)
    , m_isFlushingLayerChanges(false)
    , m_waitingForUIProcess(true)
    , m_isSuspended(false)
    , m_isWaitingForRenderer(true)
    , m_didInitializeRootCompositingLayer(false)
    , m_layerFlushTimer(this, &CoordinatedLayerTreeHost::layerFlushTimerFired)
    , m_releaseInactiveAtlasesTimer(this, &CoordinatedLayerTreeHost::releaseInactiveAtlasesTimerFired)
    , m_layerFlushSchedulingEnabled(true)
    , m_forceRepaintAsyncCallbackID(0)
    , m_animationsLocked(false)
#if ENABLE(REQUEST_ANIMATION_FRAME)
    , m_lastAnimationServiceTime(0)
#endif
{
    m_coordinator = CompositingCoordinator::create(webPage->corePage(), this);

    m_coordinator->createRootLayer(webPage->size());
    m_layerTreeContext.coordinatedLayerID = toCoordinatedGraphicsLayer(m_coordinator->rootLayer())->id();
#ifndef NDEBUG
    m_rootLayer->setName("CoordinatedLayerTreeHost root layer");
#endif
    m_rootLayer->setDrawsContent(false);
    m_rootLayer->setSize(m_webPage->size());
    m_layerTreeContext.coordinatedLayerID = toCoordinatedGraphicsLayer(m_rootLayer.get())->id();

    CoordinatedSurface::setFactory(createCoordinatedSurface);

    if (webPage->hasPageOverlay())
    // See https://bugs.webkit.org/show_bug.cgi?id=114869
    CoordinatedGraphicsLayer::setShouldSupportContentsTiling(true);

    if (m_webPage->hasPageOverlay())
        createPageOverlayLayer();

    scheduleLayerFlush();


void CoordinatedLayerTreeHost::setRootCompositingLayer(WebCore::GraphicsLayer* graphicsLayer)
{
    m_coordinator->setRootCompositingLayer(graphicsLayer);
        m_rootCompositingLayer->removeFromParent();

    m_rootCompositingLayer = graphicsLayer;
    if (m_rootCompositingLayer)
        m_rootLayer->addChildAtIndex(m_rootCompositingLayer, 0);
}

void CoordinatedLayerTreeHost::invalidate()

    cancelPendingLayerFlush();

    ASSERT(m_isValid);
    m_coordinator->clearRootLayer();
    m_isValid = false;
}


{
    // This is necessary for running layout tests. Since in this case we are not waiting for a UIProcess to reply nicely.
    // Instead we are just triggering forceRepaint. But we still want to have the scripted animation callbacks being executed.
    m_coordinator->syncDisplayState();

    // We need to schedule another flush, otherwise the forced paint might cancel a later expected flush.
    // This is aligned with LayerTreeHostCA.
    scheduleLayerFlush();
    m_coordinator->flushPendingLayerChanges();
}

bool CoordinatedLayerTreeHost::forceRepaintAsync(uint64_t callbackID)


void CoordinatedLayerTreeHost::sizeDidChange(const WebCore::IntSize& newSize)
{
    m_coordinator->sizeDidChange(newSize);
    scheduleLayerFlush();
}


    scheduleLayerFlush();
}

void CoordinatedLayerTreeHost::setVisibleContentsRect(const FloatRect& rect, const FloatPoint& trajectoryVector)
{
    m_coordinator->setVisibleContentsRect(rect, trajectoryVector);
    scheduleLayerFlush();

    TemporaryChange<bool> protector(m_isFlushingLayerChanges, true);

    initializeRootCompositingLayerIfNeeded();

    m_rootLayer->flushCompositingStateForThisLayerOnly();
    if (m_pageOverlayLayer)
        m_pageOverlayLayer->flushCompositingStateForThisLayerOnly();

    bool didSync = m_webPage->corePage()->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_webPage->send(Messages::CoordinatedLayerTreeHostProxy::CommitCoordinatedGraphicsState(m_state));

        clearPendingStateChanges();
        m_waitingForUIProcess = true;
        m_shouldSyncFrame = false;
    }

    if (m_forceRepaintAsyncCallbackID) {
        m_webPage->send(Messages::WebPageProxy::VoidCallback(m_forceRepaintAsyncCallbackID));
        m_forceRepaintAsyncCallbackID = 0;
    }

    return didSync;
}

void CoordinatedLayerTreeHost::renderNextFrame()
{
    m_coordinator->renderNextFrame();
    m_isWaitingForRenderer = false;
    scheduleLayerFlush();

    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 CoordinatedLayerTreeHost::purgeBackingStores()
{
    m_coordinator->purgeBackingStores();
        return;

    m_state.rootCompositingLayer = toCoordinatedGraphicsLayer(m_rootLayer.get())->id();
    m_didInitializeRootCompositingLayer = true;
    m_shouldSyncFrame = true;
}

void CoordinatedLayerTreeHost::willSyncLayerState(CoordinatedGraphicsLayerState& state)
{
    m_shouldSyncFrame = true;

#if ENABLE(CSS_SHADERS)
    if (state.animationsChanged)
        prepareCustomFilterProxiesForAnimations(state.animations);

    if (state.filtersChanged)
        checkCustomFilterProgramProxies(state.filters);
#else
    UNUSED_PARAM(state);
#endif
}

#if ENABLE(CSS_SHADERS)
void CoordinatedLayerTreeHost::prepareCustomFilterProxiesForAnimations(GraphicsLayerAnimations& activeAnimations)
{
    for (size_t i = 0; i < activeAnimations.animations().size(); ++i) {
        const KeyframeValueList& keyframes = activeAnimations.animations().at(i).keyframes();
        if (keyframes.property() != AnimatedPropertyWebkitFilter)
            continue;
        for (size_t j = 0; j < keyframes.size(); ++j) {
            const FilterAnimationValue& filterValue = static_cast<const FilterAnimationValue&>(keyframes.at(j));
            checkCustomFilterProgramProxies(filterValue.value());
                const FilterAnimationValue& filterValue = static_cast<const FilterAnimationValue&>(keyframes.at(j));
                checkCustomFilterProgramProxies(filterValue.value());
            }
        }
    }

    if (state.filtersChanged)
        checkCustomFilterProgramProxies(state.filters);
}

void CoordinatedLayerTreeHost::checkCustomFilterProgramProxies(const FilterOperations& filters)

        if (!customFilterProgramProxy->client()) {
            customFilterProgramProxy->setClient(this);
            m_customFilterPrograms.add(customFilterProgramProxy.get());
            m_coordinator->state().customFiltersToCreate.append(std::make_pair(customFilterProgramProxy->id(), customOperation->validatedProgram()->validatedProgramInfo()));
        } else {
            // If the client was not disconnected then this coordinator must be the client for it.
            ASSERT(customFilterProgramProxy->client() == this);

    // At this time the shader is not needed anymore, so we remove it from our set and
    // send a message to the other process to delete it.
    m_customFilterPrograms.remove(customFilterProgramProxy);
    m_coordinator->state().customFiltersToRemove.append(customFilterProgramProxy->id());
}

void CoordinatedLayerTreeHost::disconnectCustomFilterPrograms()

}
#endif // ENABLE(CSS_SHADERS)

void CoordinatedLayerTreeHost::didFlushRootLayer()
{
    if (m_pageOverlayLayer)
        m_pageOverlayLayer->flushCompositingStateForThisLayerOnly();
    size_t index = m_state.layersToCreate.find(layer->id());
    if (index != notFound) {
        m_state.layersToCreate.remove(index);
        return;
    }

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

void CoordinatedLayerTreeHost::performScheduledLayerFlush()
{
    if (m_isSuspended || m_isWaitingForRenderer)
        return;

    m_coordinator->syncDisplayState();

    if (!m_isValid)
        return;

    bool didSync = m_coordinator->flushPendingLayerChanges();
        didPerformScheduledLayerFlush();
}

void CoordinatedLayerTreeHost::syncDisplayState()
{
#if ENABLE(INSPECTOR)
    m_webPage->corePage()->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_webPage->corePage()->mainFrame()->view()->serviceScriptedAnimations(m_lastAnimationServiceTime);
#endif

    if (m_forceRepaintAsyncCallbackID) {
        m_webPage->send(Messages::WebPageProxy::VoidCallback(m_forceRepaintAsyncCallbackID));
        m_forceRepaintAsyncCallbackID = 0;
    }

    if (m_notifyAfterScheduledLayerFlush && didSync) {
{
    if (m_notifyAfterScheduledLayerFlush) {
        static_cast<DrawingAreaImpl*>(m_webPage->drawingArea())->layerHostDidFlushLayers();
        m_notifyAfterScheduledLayerFlush = false;
    }

{
    ASSERT(!m_pageOverlayLayer);

    m_pageOverlayLayer = GraphicsLayer::create(graphicsLayerFactory(), m_coordinator.get());
#ifndef NDEBUG
    m_pageOverlayLayer->setName("CompositingCoordinator page overlay content");
#endif

    m_pageOverlayLayer->setDrawsContent(true);
    m_pageOverlayLayer->setSize(m_coordinator->rootLayer()->size());

    m_coordinator->rootLayer()->addChild(m_pageOverlayLayer.get());
}

void CoordinatedLayerTreeHost::destroyPageOverlayLayer()

    m_pageOverlayLayer = nullptr;
}

void CoordinatedLayerTreeHost::paintLayerContents(const GraphicsLayer* graphicsLayer, GraphicsContext& graphicsContext, const IntRect& clipRect)
{
    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 CoordinatedLayerTreeHost::createImageBacking(CoordinatedImageBackingID imageID)
{
    m_state.imagesToCreate.append(imageID);
}

void CoordinatedLayerTreeHost::updateImageBacking(CoordinatedImageBackingID imageID, PassRefPtr<CoordinatedSurface> coordinatedSurface)
{
    m_shouldSyncFrame = true;
    m_state.imagesToUpdate.append(std::make_pair(imageID, coordinatedSurface));
}

void CoordinatedLayerTreeHost::clearImageBackingContents(CoordinatedImageBackingID imageID)
{
    m_shouldSyncFrame = true;
    m_state.imagesToClear.append(imageID);
}

void CoordinatedLayerTreeHost::removeImageBacking(CoordinatedImageBackingID imageID)
{
    if (m_isPurging)
        return;

    ASSERT(m_imageBackings.contains(imageID));
    m_imageBackings.remove(imageID);

    m_state.imagesToRemove.append(imageID);
}

void CoordinatedLayerTreeHost::flushPendingImageBackingChanges()
{
    ImageBackingMap::iterator end = m_imageBackings.end();
    for (ImageBackingMap::iterator iter = m_imageBackings.begin(); iter != end; ++iter)
        iter->value->update();
}

void CoordinatedLayerTreeHost::notifyAnimationStarted(const WebCore::GraphicsLayer*, double /* time */)
{
}

void CoordinatedLayerTreeHost::notifyFlushRequired(const WebCore::GraphicsLayer*)
{
    scheduleLayerFlush();
}

void CoordinatedLayerTreeHost::paintContents(const WebCore::GraphicsLayer* graphicsLayer, WebCore::GraphicsContext& graphicsContext, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& clipRect)
{
    if (graphicsLayer == m_pageOverlayLayer) {
        // Overlays contain transparent contents and won't clear the context as part of their rendering, so we do it here.

    }
}

void CoordinatedLayerTreeHost::commitSceneState(WebCore::CoordinatedGraphicsState& state)
{
    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::CommitCoordinatedGraphicsState(state));
    m_isWaitingForRenderer = true;
    m_registeredLayers.add(layer->id(), layer);
    m_state.layersToCreate.append(layer->id());
    layer->setNeedsVisibleRectAdjustment();
    scheduleLayerFlush();
    return adoptPtr(layer);
}

PassRefPtr<CoordinatedSurface> CoordinatedLayerTreeHost::createCoordinatedSurface(const IntSize& size, CoordinatedSurface::Flags flags)

    return WebCoordinatedSurface::create(size, flags);
}

float CoordinatedLayerTreeHost::deviceScaleFactor() const
{
    return m_webPage->deviceScaleFactor();
}

float CoordinatedLayerTreeHost::pageScaleFactor() const
{
    return m_webPage->pageScaleFactor();
}

bool LayerTreeHost::supportsAcceleratedCompositing()
{
    return true;
}

void CoordinatedLayerTreeHost::createUpdateAtlas(uint32_t atlasID, PassRefPtr<CoordinatedSurface> coordinatedSurface)
{
    m_state.updateAtlasesToCreate.append(std::make_pair(atlasID, coordinatedSurface));
}

void CoordinatedLayerTreeHost::removeUpdateAtlas(uint32_t atlasID)
{
    if (m_isPurging)
        return;
    m_state.updateAtlasesToRemove.append(atlasID);
}

WebCore::FloatRect CoordinatedLayerTreeHost::visibleContentsRect() const
{
    return m_visibleContentsRect;
}

CoordinatedGraphicsLayer* CoordinatedLayerTreeHost::mainContentsLayer()
{
    if (!m_rootCompositingLayer)
        return 0;

    return toCoordinatedGraphicsLayer(m_rootCompositingLayer)->findFirstDescendantWithContentsRecursively();
}

void CoordinatedLayerTreeHost::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();
        }
    }

    scheduleLayerFlush();
    if (m_webPage->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.
        m_webPage->setFixedVisibleContentRect(roundedIntRect(rect));
    }
}

void CoordinatedLayerTreeHost::deviceOrPageScaleFactorChanged()
{
    m_coordinator->deviceOrPageScaleFactorChanged();
    if (m_pageOverlayLayer)
        m_pageOverlayLayer->deviceOrPageScaleFactorChanged();
}


GraphicsLayerFactory* CoordinatedLayerTreeHost::graphicsLayerFactory()
{
    return m_coordinator.get();
}

#if ENABLE(REQUEST_ANIMATION_FRAME)
void CoordinatedLayerTreeHost::scheduleAnimation()
{
    if (m_isWaitingForRenderer)
        return;

    if (m_layerFlushTimer.isActive())
        return;

    m_layerFlushTimer.startOneShot(m_coordinator->nextAnimationServiceTime());
    static const double MinimalTimeoutForAnimations = 1. / 60.;
    m_layerFlushTimer.startOneShot(std::max<double>(0., MinimalTimeoutForAnimations - WTF::monotonicallyIncreasingTime() + m_lastAnimationServiceTime));
    scheduleLayerFlush();
}
#endif

void CoordinatedLayerTreeHost::renderNextFrame()
{
    m_waitingForUIProcess = false;
    scheduleLayerFlush();
    for (unsigned i = 0; i < m_updateAtlases.size(); ++i)
        m_updateAtlases[i]->didSwapBuffers();
}

void CoordinatedLayerTreeHost::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 CoordinatedLayerTreeHost::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 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 CoordinatedLayerTreeHost::scheduleReleaseInactiveAtlases()
{
    if (!m_releaseInactiveAtlasesTimer.isActive())
        m_releaseInactiveAtlasesTimer.startRepeating(ReleaseInactiveAtlasesTimerInterval);
}

void CoordinatedLayerTreeHost::releaseInactiveAtlasesTimerFired(Timer<CoordinatedLayerTreeHost>*)
{
    // 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();
}

void CoordinatedLayerTreeHost::setBackgroundColor(const WebCore::Color& color)
{
    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::SetBackgroundColor(color));


void CoordinatedLayerTreeHost::commitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset)
{
    m_coordinator->commitScrollOffset(layerID, offset);
    if (i == m_registeredLayers.end())
        return;

    i->value->commitScrollOffset(offset);
}

} // namespace WebKit




#include "LayerTreeContext.h"
#include "LayerTreeHost.h"
#include <WebCore/CompositingCoordinator.h>
#include <WebCore/CoordinatedGraphicsLayer.h>
#include <WebCore/CoordinatedGraphicsState.h>
#include <WebCore/CoordinatedImageBacking.h>
#include <WebCore/GraphicsLayerClient.h>
#include <WebCore/GraphicsLayerFactory.h>
#include <WebCore/UpdateAtlas.h>
#include <wtf/OwnPtr.h>

#if ENABLE(CSS_SHADERS)


class WebPage;

class CoordinatedLayerTreeHost : public LayerTreeHost, public WebCore::CompositingCoordinator::Client
    , public WebCore::CoordinatedGraphicsLayerClient
    , public WebCore::CoordinatedImageBacking::Client
    , public WebCore::UpdateAtlas::Client
    , public WebCore::GraphicsLayerFactory
#if ENABLE(CSS_SHADERS)
    , WebCustomFilterProgramProxyClient
#endif

    virtual void deviceOrPageScaleFactorChanged() OVERRIDE;
    virtual void pageBackgroundTransparencyChanged() OVERRIDE;

    virtual void renderNextFrame();
    virtual void purgeBackingStores();
    virtual void setVisibleContentsRect(const WebCore::FloatRect&, const WebCore::FloatPoint&);
    virtual void didReceiveCoordinatedLayerTreeHostMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
    virtual WebCore::GraphicsLayerFactory* graphicsLayerFactory() OVERRIDE;
    WebCore::CoordinatedGraphicsLayer* mainContentsLayer();


    static PassRefPtr<WebCore::CoordinatedSurface> createCoordinatedSurface(const WebCore::IntSize&, WebCore::CoordinatedSurface::Flags);

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

protected:
    explicit CoordinatedLayerTreeHost(WebPage*);

private:
    // GraphicsLayerClient
    virtual void notifyAnimationStarted(const WebCore::GraphicsLayer*, double time);
    virtual void notifyFlushRequired(const WebCore::GraphicsLayer*);
    virtual void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& clipRect);
    virtual float deviceScaleFactor() const OVERRIDE;
    virtual float pageScaleFactor() const OVERRIDE;

    // CoordinatedImageBacking::Client
    virtual void createImageBacking(WebCore::CoordinatedImageBackingID) OVERRIDE;
    virtual void updateImageBacking(WebCore::CoordinatedImageBackingID, PassRefPtr<WebCore::CoordinatedSurface>) OVERRIDE;
    virtual void clearImageBackingContents(WebCore::CoordinatedImageBackingID) OVERRIDE;
    virtual void removeImageBacking(WebCore::CoordinatedImageBackingID) OVERRIDE;

    void flushPendingImageBackingChanges();

    // CoordinatedGraphicsLayerClient
    virtual bool isFlushingLayerChanges() const OVERRIDE { return m_isFlushingLayerChanges; }
    virtual WebCore::FloatRect visibleContentsRect() const;
    virtual PassRefPtr<WebCore::CoordinatedImageBacking> createImageBackingIfNeeded(WebCore::Image*) OVERRIDE;
    virtual void detachLayer(WebCore::CoordinatedGraphicsLayer*);
    virtual bool paintToSurface(const WebCore::IntSize&, WebCore::CoordinatedSurface::Flags, uint32_t& /* atlasID */, WebCore::IntPoint&, WebCore::CoordinatedSurface::Client*) OVERRIDE;
    virtual void syncLayerState(WebCore::CoordinatedLayerID, WebCore::CoordinatedGraphicsLayerState&);

    // UpdateAtlas::Client
    virtual void createUpdateAtlas(uint32_t atlasID, PassRefPtr<WebCore::CoordinatedSurface>) OVERRIDE;
    virtual void removeUpdateAtlas(uint32_t atlasID) OVERRIDE;

    // GraphicsLayerFactory
    virtual PassOwnPtr<WebCore::GraphicsLayer> createGraphicsLayer(WebCore::GraphicsLayerClient*) OVERRIDE;

    // CoordinatedLayerTreeHost
    void initializeRootCompositingLayerIfNeeded();
    void createPageOverlayLayer();
    void destroyPageOverlayLayer();
    bool flushPendingLayerChanges();
    void clearPendingStateChanges();
    void cancelPendingLayerFlush();
    void performScheduledLayerFlush();
    void setVisibleContentsRect(const WebCore::FloatRect&, const WebCore::FloatPoint&);
    void renderNextFrame();
    void purgeBackingStores();
    void commitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset);

    void layerFlushTimerFired(WebCore::Timer<CoordinatedLayerTreeHost>*);

    // CompositingCoordinator::Client
    virtual void didFlushRootLayer() OVERRIDE;
    virtual void willSyncLayerState(WebCore::CoordinatedGraphicsLayerState&) OVERRIDE;
    virtual void notifyFlushRequired() OVERRIDE { scheduleLayerFlush(); };
    virtual void commitSceneState(WebCore::CoordinatedGraphicsState&) OVERRIDE;
    virtual void paintLayerContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, const WebCore::IntRect& clipRect) OVERRIDE;

#if ENABLE(CSS_SHADERS)
    void prepareCustomFilterProxiesForAnimations(WebCore::GraphicsLayerAnimations&);

    // WebCustomFilterProgramProxyClient
    void removeCustomFilterProgramProxy(WebCustomFilterProgramProxy*);

    void disconnectCustomFilterPrograms();
#endif

    OwnPtr<WebCore::CompositingCoordinator> m_coordinator;
    WebCore::GraphicsLayer* m_rootCompositingLayer;

    // The page overlay layer. Will be null if there's no page overlay.
    OwnPtr<WebCore::GraphicsLayer> m_pageOverlayLayer;
    RefPtr<PageOverlay> m_pageOverlay;

    WebCore::CoordinatedGraphicsState m_state;

    typedef HashMap<WebCore::CoordinatedLayerID, WebCore::CoordinatedGraphicsLayer*> LayerMap;
    LayerMap m_registeredLayers;
    typedef HashMap<WebCore::CoordinatedImageBackingID, RefPtr<WebCore::CoordinatedImageBacking> > ImageBackingMap;
    ImageBackingMap m_imageBackings;
    Vector<OwnPtr<WebCore::UpdateAtlas> > m_updateAtlases;

#if ENABLE(CSS_SHADERS)
    HashSet<WebCustomFilterProgramProxy*> m_customFilterPrograms;
#endif

    bool m_notifyAfterScheduledLayerFlush;
    bool m_isValid;
    // We don't send the messages related to releasing resources to UI Process during purging, because UI Process already had removed all resources.
    bool m_isPurging;
    bool m_isFlushingLayerChanges;

    bool m_waitingForUIProcess;
    bool m_isSuspended;
    bool m_isWaitingForRenderer;

    LayerTreeContext m_layerTreeContext;

    bool m_didInitializeRootCompositingLayer;
    WebCore::Timer<CoordinatedLayerTreeHost> m_layerFlushTimer;
    WebCore::Timer<CoordinatedLayerTreeHost> m_releaseInactiveAtlasesTimer;
    bool m_layerFlushSchedulingEnabled;
    uint64_t m_forceRepaintAsyncCallbackID;
    bool m_animationsLocked;

#if ENABLE(REQUEST_ANIMATION_FRAME)
    double m_lastAnimationServiceTime;
#endif
};

} // namespace WebKit



    virtual void setBackgroundColor(const WebCore::Color&) { }

#if USE(COORDINATED_GRAPHICS)
    virtual void setVisibleContentsRect(const WebCore::FloatRect&, float /* scale */, const WebCore::FloatPoint&) { }
    virtual void renderNextFrame() { }
    virtual void purgeBackingStores() { }
    virtual void didReceiveCoordinatedLayerTreeHostMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&) = 0;
#endif


Return to Bug 104360

Lines 25-37 a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h_sec1
- a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h -79 / +17 lines
25		25
26	#include "LayerTreeContext.h"	26	#include "LayerTreeContext.h"
27	#include "LayerTreeHost.h"	27	#include "LayerTreeHost.h"
28	#include "Timer.h"	28	#include <WebCore/CompositingCoordinator.h>
29	#include <WebCore/CoordinatedGraphicsLayer.h>
30	#include <WebCore/CoordinatedGraphicsState.h>
31	#include <WebCore/CoordinatedImageBacking.h>
32	#include <WebCore/GraphicsLayerClient.h>
33	#include <WebCore/GraphicsLayerFactory.h>	29	#include <WebCore/GraphicsLayerFactory.h>
34	#include <WebCore/UpdateAtlas.h>
35	#include <wtf/OwnPtr.h>	30	#include <wtf/OwnPtr.h>
36		31
37	#if ENABLE(CSS_SHADERS)	32	#if ENABLE(CSS_SHADERS)
Lines 46-56 namespace WebKit { a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h_sec2
46		41
47	class WebPage;	42	class WebPage;
48		43
49	class CoordinatedLayerTreeHost : public LayerTreeHost, WebCore::GraphicsLayerClient	44	class CoordinatedLayerTreeHost : public LayerTreeHost, public WebCore::CompositingCoordinator::Client
50	, public WebCore::CoordinatedGraphicsLayerClient
51	, public WebCore::CoordinatedImageBacking::Client
52	, public WebCore::UpdateAtlas::Client
53	, public WebCore::GraphicsLayerFactory
54	#if ENABLE(CSS_SHADERS)	45	#if ENABLE(CSS_SHADERS)
55	, WebCustomFilterProgramProxyClient	46	, WebCustomFilterProgramProxyClient
56	#endif	47	#endif
Lines 84-92 public: a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h_sec3
84	virtual void deviceOrPageScaleFactorChanged() OVERRIDE;	75	virtual void deviceOrPageScaleFactorChanged() OVERRIDE;
85	virtual void pageBackgroundTransparencyChanged() OVERRIDE;	76	virtual void pageBackgroundTransparencyChanged() OVERRIDE;
86		77
87	virtual void renderNextFrame();
88	virtual void purgeBackingStores();
89	virtual void setVisibleContentsRect(const WebCore::FloatRect&, const WebCore::FloatPoint&);
90	virtual void didReceiveCoordinatedLayerTreeHostMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);	78	virtual void didReceiveCoordinatedLayerTreeHostMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
91	virtual WebCore::GraphicsLayerFactory* graphicsLayerFactory() OVERRIDE;	79	virtual WebCore::GraphicsLayerFactory* graphicsLayerFactory() OVERRIDE;
92	WebCore::CoordinatedGraphicsLayer* mainContentsLayer();	80	WebCore::CoordinatedGraphicsLayer* mainContentsLayer();
Lines 98-157 public: a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h_sec4
98		86
99	static PassRefPtr<WebCore::CoordinatedSurface> createCoordinatedSurface(const WebCore::IntSize&, WebCore::CoordinatedSurface::Flags);	87	static PassRefPtr<WebCore::CoordinatedSurface> createCoordinatedSurface(const WebCore::IntSize&, WebCore::CoordinatedSurface::Flags);
100		88
101	void commitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset);
102
103	protected:	89	protected:
104	explicit CoordinatedLayerTreeHost(WebPage*);	90	explicit CoordinatedLayerTreeHost(WebPage*);
105		91
106	private:	92	private:
107	// GraphicsLayerClient
108	virtual void notifyAnimationStarted(const WebCore::GraphicsLayer*, double time);
109	virtual void notifyFlushRequired(const WebCore::GraphicsLayer*);
110	virtual void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& clipRect);
111	virtual float deviceScaleFactor() const OVERRIDE;
112	virtual float pageScaleFactor() const OVERRIDE;
113
114	// CoordinatedImageBacking::Client
115	virtual void createImageBacking(WebCore::CoordinatedImageBackingID) OVERRIDE;
116	virtual void updateImageBacking(WebCore::CoordinatedImageBackingID, PassRefPtr<WebCore::CoordinatedSurface>) OVERRIDE;
117	virtual void clearImageBackingContents(WebCore::CoordinatedImageBackingID) OVERRIDE;
118	virtual void removeImageBacking(WebCore::CoordinatedImageBackingID) OVERRIDE;
119
120	void flushPendingImageBackingChanges();
121
122	// CoordinatedGraphicsLayerClient
123	virtual bool isFlushingLayerChanges() const OVERRIDE { return m_isFlushingLayerChanges; }
124	virtual WebCore::FloatRect visibleContentsRect() const;
125	virtual PassRefPtr<WebCore::CoordinatedImageBacking> createImageBackingIfNeeded(WebCore::Image*) OVERRIDE;
126	virtual void detachLayer(WebCore::CoordinatedGraphicsLayer*);
127	virtual bool paintToSurface(const WebCore::IntSize&, WebCore::CoordinatedSurface::Flags, uint32_t& /* atlasID /, WebCore::IntPoint&, WebCore::CoordinatedSurface::Client) OVERRIDE;
128	virtual void syncLayerState(WebCore::CoordinatedLayerID, WebCore::CoordinatedGraphicsLayerState&);
129
130	// UpdateAtlas::Client
131	virtual void createUpdateAtlas(uint32_t atlasID, PassRefPtr<WebCore::CoordinatedSurface>) OVERRIDE;
132	virtual void removeUpdateAtlas(uint32_t atlasID) OVERRIDE;
133
134	// GraphicsLayerFactory
135	virtual PassOwnPtr<WebCore::GraphicsLayer> createGraphicsLayer(WebCore::GraphicsLayerClient*) OVERRIDE;
136
137	// CoordinatedLayerTreeHost	93	// CoordinatedLayerTreeHost
138	void initializeRootCompositingLayerIfNeeded();
139	void createPageOverlayLayer();	94	void createPageOverlayLayer();
140	void destroyPageOverlayLayer();	95	void destroyPageOverlayLayer();
141	bool flushPendingLayerChanges();
142	void clearPendingStateChanges();
143	void cancelPendingLayerFlush();	96	void cancelPendingLayerFlush();
144	void performScheduledLayerFlush();	97	void performScheduledLayerFlush();
145	void didPerformScheduledLayerFlush();	98	void setVisibleContentsRect(const WebCore::FloatRect&, const WebCore::FloatPoint&);
146	void syncDisplayState();	99	void renderNextFrame();
147	void layerFlushTimerFired(WebCore::Timer<CoordinatedLayerTreeHost>*);	100	void purgeBackingStores();
		101	void commitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset);
148		102
149	void scheduleReleaseInactiveAtlases();	103	void layerFlushTimerFired(WebCore::Timer<CoordinatedLayerTreeHost>*);
150		104
151	void releaseInactiveAtlasesTimerFired(WebCore::Timer<CoordinatedLayerTreeHost>*);	105	// CompositingCoordinator::Client
		106	virtual void didFlushRootLayer() OVERRIDE;
		107	virtual void willSyncLayerState(WebCore::CoordinatedGraphicsLayerState&) OVERRIDE;
		108	virtual void notifyFlushRequired() OVERRIDE { scheduleLayerFlush(); };
		109	virtual void commitSceneState(WebCore::CoordinatedGraphicsState&) OVERRIDE;
		110	virtual void paintLayerContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, const WebCore::IntRect& clipRect) OVERRIDE;
152		111
153	#if ENABLE(CSS_SHADERS)	112	#if ENABLE(CSS_SHADERS)
154	void prepareCustomFilterProxiesIfNeeded(WebCore::CoordinatedGraphicsLayerState&);	113	void prepareCustomFilterProxiesForAnimations(WebCore::GraphicsLayerAnimations&);
155		114
156	// WebCustomFilterProgramProxyClient	115	// WebCustomFilterProgramProxyClient
157	void removeCustomFilterProgramProxy(WebCustomFilterProgramProxy*);	116	void removeCustomFilterProgramProxy(WebCustomFilterProgramProxy*);
Lines 160-206 private: a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h_sec5
160	void disconnectCustomFilterPrograms();	119	void disconnectCustomFilterPrograms();
161	#endif	120	#endif
162		121
163	OwnPtr<WebCore::GraphicsLayer> m_rootLayer;	122	OwnPtr<WebCore::CompositingCoordinator> m_coordinator;
164	WebCore::GraphicsLayer* m_rootCompositingLayer;
165		123
166	// The page overlay layer. Will be null if there's no page overlay.	124	// The page overlay layer. Will be null if there's no page overlay.
167	OwnPtr<WebCore::GraphicsLayer> m_pageOverlayLayer;	125	OwnPtr<WebCore::GraphicsLayer> m_pageOverlayLayer;
168	RefPtr<PageOverlay> m_pageOverlay;	126	RefPtr<PageOverlay> m_pageOverlay;
169		127
170	WebCore::CoordinatedGraphicsState m_state;
171
172	typedef HashMap<WebCore::CoordinatedLayerID, WebCore::CoordinatedGraphicsLayer*> LayerMap;
173	LayerMap m_registeredLayers;
174	typedef HashMap<WebCore::CoordinatedImageBackingID, RefPtr<WebCore::CoordinatedImageBacking> > ImageBackingMap;
175	ImageBackingMap m_imageBackings;
176	Vector<OwnPtr<WebCore::UpdateAtlas> > m_updateAtlases;
177
178	#if ENABLE(CSS_SHADERS)	128	#if ENABLE(CSS_SHADERS)
179	HashSet<WebCustomFilterProgramProxy*> m_customFilterPrograms;	129	HashSet<WebCustomFilterProgramProxy*> m_customFilterPrograms;
180	#endif	130	#endif
181		131
182	bool m_notifyAfterScheduledLayerFlush;	132	bool m_notifyAfterScheduledLayerFlush;
183	bool m_isValid;	133	bool m_isValid;
184	// We don't send the messages related to releasing resources to UI Process during purging, because UI Process already had removed all resources.
185	bool m_isPurging;
186	bool m_isFlushingLayerChanges;
187
188	bool m_waitingForUIProcess;
189	bool m_isSuspended;	134	bool m_isSuspended;
190	WebCore::FloatRect m_visibleContentsRect;	135	bool m_isWaitingForRenderer;
191		136
192	LayerTreeContext m_layerTreeContext;	137	LayerTreeContext m_layerTreeContext;
193	bool m_shouldSyncFrame;	138
194	bool m_didInitializeRootCompositingLayer;
195	WebCore::Timer<CoordinatedLayerTreeHost> m_layerFlushTimer;	139	WebCore::Timer<CoordinatedLayerTreeHost> m_layerFlushTimer;
196	WebCore::Timer<CoordinatedLayerTreeHost> m_releaseInactiveAtlasesTimer;
197	bool m_layerFlushSchedulingEnabled;	140	bool m_layerFlushSchedulingEnabled;
198	uint64_t m_forceRepaintAsyncCallbackID;	141	uint64_t m_forceRepaintAsyncCallbackID;
199	bool m_animationsLocked;
200
201	#if ENABLE(REQUEST_ANIMATION_FRAME)
202	double m_lastAnimationServiceTime;
203	#endif
204	};	142	};
205		143
206	} // namespace WebKit	144	} // namespace WebKit

Lines 87-95 public: a/Source/WebKit2/WebProcess/WebPage/LayerTreeHost.h_sec1
- a/Source/WebKit2/WebProcess/WebPage/LayerTreeHost.h -3 lines
87	virtual void setBackgroundColor(const WebCore::Color&) { }	87	virtual void setBackgroundColor(const WebCore::Color&) { }
88		88
89	#if USE(COORDINATED_GRAPHICS)	89	#if USE(COORDINATED_GRAPHICS)
90	virtual void setVisibleContentsRect(const WebCore::FloatRect&, float /* scale */, const WebCore::FloatPoint&) { }
91	virtual void renderNextFrame() { }
92	virtual void purgeBackingStores() { }
93	virtual void didReceiveCoordinatedLayerTreeHostMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&) = 0;	90	virtual void didReceiveCoordinatedLayerTreeHostMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&) = 0;
94	#endif	91	#endif
95		92

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +69 lines
		1	2013-03-13 Gwang Yoon Hwang <ryumiel@company100.net>
		2
		3	Coordinated Graphics: Separate CoordinatedLayerTreeHost into CoordinatedLayerTreeHost and CompositingCoordinator
		4	https://bugs.webkit.org/show_bug.cgi?id=104360
		5
		6	Reviewed by Noam Rosenthal.
		7
		8	The CoordinatedLayerTreeHost has too many responsibilities. It
		9	implements LayerTreeHost, GraphicsLayerClient,
		10	CoordinatedGraphicsLayerClient, CoordinatedImageBacking::Client,
		11	UpdateAtlas::Client, GraphicsLayerFactory and
		12	WebCustomFilterProgramProxyClient.
		13
		14	This refactoring reduces the responsibilities of CoordinatedLayerTreeHost.
		15
		16	This patch introduces a new class called CompositingCoordinator, which
		17	takes the responsibility of managing compositing resources in
		18	WebProcess.
		19
		20	CoordinatedLayerTreeHost is responsible only for the scheduling and
		21	IPC-specific stuff, which are relevant only for WebKit2.
		22
		23	No new tests, covered by existing tests.
		24
		25	* CMakeLists.txt:
		26	* Target.pri:
		27	* platform/graphics/texmap/coordinated/CompositingCoordinator.cpp: Added.
		28	(WebCore::CompositingCoordinator::create):
		29	(WebCore::CompositingCoordinator::~CompositingCoordinator):
		30	(WebCore::CompositingCoordinator::CompositingCoordinator):
		31	(WebCore::CompositingCoordinator::setRootCompositingLayer):
		32	(WebCore::CompositingCoordinator::sizeDidChange):
		33	(WebCore::CompositingCoordinator::flushPendingLayerChanges):
		34	(WebCore::CompositingCoordinator::syncDisplayState):
		35	(WebCore::CompositingCoordinator::nextAnimationServiceTime):
		36	(WebCore::CompositingCoordinator::clearPendingStateChanges):
		37	(WebCore::CompositingCoordinator::initializeRootCompositingLayerIfNeeded):
		38	(WebCore::CompositingCoordinator::createRootLayer):
		39	(WebCore::CompositingCoordinator::syncLayerState):
		40	(WebCore::CompositingCoordinator::createImageBackingIfNeeded):
		41	(WebCore::CompositingCoordinator::createImageBacking):
		42	(WebCore::CompositingCoordinator::updateImageBacking):
		43	(WebCore::CompositingCoordinator::clearImageBackingContents):
		44	(WebCore::CompositingCoordinator::removeImageBacking):
		45	(WebCore::CompositingCoordinator::flushPendingImageBackingChanges):
		46	(WebCore::CompositingCoordinator::notifyAnimationStarted):
		47	(WebCore::CompositingCoordinator::notifyFlushRequired):
		48	(WebCore::CompositingCoordinator::paintContents):
		49	(WebCore::CompositingCoordinator::createGraphicsLayer):
		50	(WebCore::CompositingCoordinator::deviceScaleFactor):
		51	(WebCore::CompositingCoordinator::pageScaleFactor):
		52	(WebCore::CompositingCoordinator::createUpdateAtlas):
		53	(WebCore::CompositingCoordinator::removeUpdateAtlas):
		54	(WebCore::CompositingCoordinator::visibleContentsRect):
		55	(WebCore::CompositingCoordinator::mainContentsLayer):
		56	(WebCore::CompositingCoordinator::setVisibleContentsRect):
		57	(WebCore::CompositingCoordinator::deviceOrPageScaleFactorChanged):
		58	(WebCore::CompositingCoordinator::detachLayer):
		59	(WebCore::CompositingCoordinator::commitScrollOffset):
		60	(WebCore::CompositingCoordinator::renderNextFrame):
		61	(WebCore::CompositingCoordinator::purgeBackingStores):
		62	(WebCore::CompositingCoordinator::paintToSurface):
		63	(WebCore::CompositingCoordinator::scheduleReleaseInactiveAtlases):
		64	(WebCore::CompositingCoordinator::releaseInactiveAtlasesTimerFired):
65	* platform/graphics/texmap/coordinated/CompositingCoordinator.h: Added.
66	(WebCore::CompositingCoordinator::clearRootLayer):
67	(WebCore::CompositingCoordinator::rootLayer):
68	(WebCore::CompositingCoordinator::state):
69
1	2013-06-26 Roger Fong <roger_fong@apple.com>	70	2013-06-26 Roger Fong <roger_fong@apple.com>
2		71
3	Add an accessibility delegate interface to AppleWin port.	72	Add an accessibility delegate interface to AppleWin port.

Lines 1-3 a/Source/WebKit2/ChangeLog_sec1
- a/Source/WebKit2/ChangeLog +50 lines
		1	2013-03-13 Gwang Yoon Hwang <ryumiel@company100.net>
		2
		3	Coordinated Graphics: Separate CoordinatedLayerTreeHost into CoordinatedLayerTreeHost and CompositingCoordinator
		4	https://bugs.webkit.org/show_bug.cgi?id=104360
		5
		6	Reviewed by Noam Rosenthal.
		7
		8	The CoordinatedLayerTreeHost has too many responsibilities. It
		9	implements LayerTreeHost, GraphicsLayerClient,
		10	CoordinatedGraphicsLayerClient, CoordinatedImageBacking::Client,
		11	UpdateAtlas::Client, GraphicsLayerFactory and
		12	WebCustomFilterProgramProxyClient.
		13
		14	This refactoring reduces the responsibilities of CoordinatedLayerTreeHost.
		15
		16	This patch introduces a new class called CompositingCoordinator, which
		17	takes the responsibility of managing compositing resources in
		18	WebProcess.
		19
		20	CoordinatedLayerTreeHost is responsible only for the scheduling and
		21	IPC-specific stuff, which are relevant only for WebKit2.
		22
		23	No new tests, covered by existing tests.
		24
		25	* WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.cpp:
		26	(WebKit::CoordinatedLayerTreeHost::~CoordinatedLayerTreeHost):
		27	(WebKit::CoordinatedLayerTreeHost::CoordinatedLayerTreeHost):
		28	(WebKit::CoordinatedLayerTreeHost::setRootCompositingLayer):
		29	(WebKit::CoordinatedLayerTreeHost::invalidate):
		30	(WebKit::CoordinatedLayerTreeHost::forceRepaint):
		31	(WebKit::CoordinatedLayerTreeHost::sizeDidChange):
		32	(WebKit::CoordinatedLayerTreeHost::setVisibleContentsRect):
		33	(WebKit::CoordinatedLayerTreeHost::renderNextFrame):
		34	(WebKit::CoordinatedLayerTreeHost::purgeBackingStores):
		35	(WebKit::CoordinatedLayerTreeHost::willSyncLayerState):
		36	(WebKit::CoordinatedLayerTreeHost::prepareCustomFilterProxiesForAnimations):
		37	(WebKit::CoordinatedLayerTreeHost::checkCustomFilterProgramProxies):
		38	(WebKit::CoordinatedLayerTreeHost::removeCustomFilterProgramProxy):
		39	(WebKit::CoordinatedLayerTreeHost::didFlushRootLayer):
		40	(WebKit::CoordinatedLayerTreeHost::performScheduledLayerFlush):
		41	(WebKit::CoordinatedLayerTreeHost::createPageOverlayLayer):
		42	(WebKit::CoordinatedLayerTreeHost::paintLayerContents):
		43	(WebKit::CoordinatedLayerTreeHost::commitSceneState):
		44	(WebKit::CoordinatedLayerTreeHost::deviceOrPageScaleFactorChanged):
		45	(WebKit::CoordinatedLayerTreeHost::graphicsLayerFactory):
		46	(WebKit::CoordinatedLayerTreeHost::scheduleAnimation):
		47	(WebKit::CoordinatedLayerTreeHost::commitScrollOffset):
		48	* WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h:
		49	* WebProcess/WebPage/LayerTreeHost.h:
		50
1	2013-06-26 Simon Cooper <scooper@apple.com>	51	2013-06-26 Simon Cooper <scooper@apple.com>
2		52
3	QuickTime plug-in cannot update com.apple.quicktime.plugin.preferences.plist file	53	QuickTime plug-in cannot update com.apple.quicktime.plugin.preferences.plist file

Lines 4089-4094 use?(3D_GRAPHICS) { a/Source/WebCore/Target.pri_sec1
- a/Source/WebCore/Target.pri +2 lines
4089	platform/graphics/texmap/TextureMapperGL.h \	4089	platform/graphics/texmap/TextureMapperGL.h \
4090	platform/graphics/texmap/TextureMapperShaderProgram.h \	4090	platform/graphics/texmap/TextureMapperShaderProgram.h \
4091	platform/graphics/texmap/coordinated/AreaAllocator.h \	4091	platform/graphics/texmap/coordinated/AreaAllocator.h \
		4092	platform/graphics/texmap/coordinated/CompositingCoordinator.h \
4092	platform/graphics/texmap/coordinated/CoordinatedBackingStore.h \	4093	platform/graphics/texmap/coordinated/CoordinatedBackingStore.h \
4093	platform/graphics/texmap/coordinated/CoordinatedCustomFilterOperation.h \	4094	platform/graphics/texmap/coordinated/CoordinatedCustomFilterOperation.h \
4094	platform/graphics/texmap/coordinated/CoordinatedCustomFilterProgram.h \	4095	platform/graphics/texmap/coordinated/CoordinatedCustomFilterProgram.h \
Lines 4124-4129 use?(3D_GRAPHICS) { a/Source/WebCore/Target.pri_sec2
4124	platform/graphics/texmap/TextureMapperGL.cpp \	4125	platform/graphics/texmap/TextureMapperGL.cpp \
4125	platform/graphics/texmap/TextureMapperShaderProgram.cpp \	4126	platform/graphics/texmap/TextureMapperShaderProgram.cpp \
4126	platform/graphics/texmap/coordinated/AreaAllocator.cpp \	4127	platform/graphics/texmap/coordinated/AreaAllocator.cpp \
		4128	platform/graphics/texmap/coordinated/CompositingCoordinator.cpp \
4127	platform/graphics/texmap/coordinated/CoordinatedBackingStore.cpp \	4129	platform/graphics/texmap/coordinated/CoordinatedBackingStore.cpp \
4128	platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp \	4130	platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp \
4129	platform/graphics/texmap/coordinated/CoordinatedGraphicsScene.cpp \	4131	platform/graphics/texmap/coordinated/CoordinatedGraphicsScene.cpp \

Line 0 a/Source/WebCore/platform/graphics/texmap/coordinated/CompositingCoordinator.cpp_sec1
- a/Source/WebCore/platform/graphics/texmap/coordinated/CompositingCoordinator.cpp +434 lines
		1	/*
		2	* Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
		3	* Copyright (C) 2013 Company 100, Inc. All rights reserved.
		4	*
		5	* Redistribution and use in source and binary forms, with or without
		6	* modification, are permitted provided that the following conditions
		7	* are met:
		8	* 1. Redistributions of source code must retain the above copyright
		9	* notice, this list of conditions and the following disclaimer.
		10	* 2. Redistributions in binary form must reproduce the above copyright
		11	* notice, this list of conditions and the following disclaimer in the
		12	* documentation and/or other materials provided with the distribution.
		13	*
		14	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
		15	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		16	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		17	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
		18	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		19	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		20	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
		21	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
		22	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		23	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
		24	* THE POSSIBILITY OF SUCH DAMAGE.
		25	*/
		26
		27	#include "config.h"
		28
		29	#if USE(COORDINATED_GRAPHICS)
		30	#include "CompositingCoordinator.h"
		31
		32	#include "Frame.h"
		33	#include "FrameView.h"
		34	#include "GraphicsContext.h"
		35	#include "InspectorController.h"
		36	#include "Page.h"
		37	#include "Settings.h"
		38	#include <wtf/CurrentTime.h>
		39	#include <wtf/TemporaryChange.h>
		40
		41	namespace WebCore {
		42
		43	PassOwnPtr<CompositingCoordinator> CompositingCoordinator::create(Page* page, CompositingCoordinator::Client* client)
		44	{
		45	return adoptPtr(new CompositingCoordinator(page, client));
		46	}
		47
		48	CompositingCoordinator::~CompositingCoordinator()
		49	{
		50	purgeBackingStores();
		51
		52	LayerMap::iterator end = m_registeredLayers.end();
		53	for (LayerMap::iterator it = m_registeredLayers.begin(); it != end; ++it)
		54	it->value->setCoordinator(0);
		55	}
		56
		57	CompositingCoordinator::CompositingCoordinator(Page* page, CompositingCoordinator::Client* client)
		58	: m_page(page)
		59	, m_client(client)
		60	, m_rootCompositingLayer(0)
		61	, m_isPurging(false)
		62	, m_isFlushingLayerChanges(false)
		63	, m_shouldSyncFrame(false)
		64	, m_didInitializeRootCompositingLayer(false)
65	, m_releaseInactiveAtlasesTimer(this, &CompositingCoordinator::releaseInactiveAtlasesTimerFired)
66	#if ENABLE(REQUEST_ANIMATION_FRAME)
67	, m_lastAnimationServiceTime(0)
68	#endif
69	{
70	m_page->settings()->setApplyDeviceScaleFactorInCompositor(true);
71
72	// This is a temporary way to enable this only in the GL case, until TextureMapperImageBuffer is removed.
73	// See https://bugs.webkit.org/show_bug.cgi?id=114869
74	CoordinatedGraphicsLayer::setShouldSupportContentsTiling(true);
75	}
76
77	void CompositingCoordinator::setRootCompositingLayer(GraphicsLayer* layer)
78	{
79	if (m_rootCompositingLayer)
80	m_rootCompositingLayer->removeFromParent();
81
82	m_rootCompositingLayer = layer;
83	if (m_rootCompositingLayer)
84	m_rootLayer->addChildAtIndex(m_rootCompositingLayer, 0);
85	}
86
87	void CompositingCoordinator::sizeDidChange(const IntSize& newSize)
88	{
89	m_rootLayer->setSize(newSize);
90	m_client->notifyFlushRequired();
91	}
92
93	bool CompositingCoordinator::flushPendingLayerChanges()
94	{
95	TemporaryChange<bool> protector(m_isFlushingLayerChanges, true);
96
97	initializeRootCompositingLayerIfNeeded();
98
99	m_rootLayer->flushCompositingStateForThisLayerOnly();
100	m_client->didFlushRootLayer();
101
102	bool didSync = m_page->mainFrame()->view()->flushCompositingStateIncludingSubframes();
103
104	toCoordinatedGraphicsLayer(m_rootLayer.get())->updateContentBuffersIncludingSubLayers();
105	toCoordinatedGraphicsLayer(m_rootLayer.get())->syncPendingStateChangesIncludingSubLayers();
106
107	flushPendingImageBackingChanges();
108
109	if (m_shouldSyncFrame) {
110	didSync = true;
111
112	if (m_rootCompositingLayer) {
113	m_state.contentsSize = roundedIntSize(m_rootCompositingLayer->size());
114	if (CoordinatedGraphicsLayer* contentsLayer = mainContentsLayer())
115	m_state.coveredRect = contentsLayer->coverRect();
116	}
117	m_state.scrollPosition = m_visibleContentsRect.location();
118
119	m_client->commitSceneState(m_state);
120
121	clearPendingStateChanges();
122	m_shouldSyncFrame = false;
123	}
124
125	return didSync;
126	}
127
128	void CompositingCoordinator::syncDisplayState()
129	{
130	#if ENABLE(INSPECTOR)
131	m_page->inspectorController()->didBeginFrame();
132	#endif
133
134	#if ENABLE(REQUEST_ANIMATION_FRAME) && !USE(REQUEST_ANIMATION_FRAME_TIMER) && !USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
135	// Make sure that any previously registered animation callbacks are being executed before we flush the layers.
136	m_lastAnimationServiceTime = WTF::monotonicallyIncreasingTime();
137	m_page->mainFrame()->view()->serviceScriptedAnimations(m_lastAnimationServiceTime);
138	#endif
139	m_page->mainFrame()->view()->updateLayoutAndStyleIfNeededRecursive();
140	}
141
142	#if ENABLE(REQUEST_ANIMATION_FRAME)
143	double CompositingCoordinator::nextAnimationServiceTime() const
144	{
145	// According to the requestAnimationFrame spec, rAF callbacks should not be faster than 60FPS.
146	static const double MinimalTimeoutForAnimations = 1. / 60.;
147	return std::max<double>(0., MinimalTimeoutForAnimations - WTF::monotonicallyIncreasingTime() + m_lastAnimationServiceTime);
148	}
149	#endif
150
151	void CompositingCoordinator::clearPendingStateChanges()
152	{
153	m_state.layersToCreate.clear();
154	m_state.layersToUpdate.clear();
155	m_state.layersToRemove.clear();
156
157	m_state.imagesToCreate.clear();
158	m_state.imagesToRemove.clear();
159	m_state.imagesToUpdate.clear();
160	m_state.imagesToClear.clear();
161
162	m_state.updateAtlasesToCreate.clear();
163	m_state.updateAtlasesToRemove.clear();
164
165	#if ENABLE(CSS_SHADERS)
166	m_state.customFiltersToCreate.clear();
167	m_state.customFiltersToRemove.clear();
168	#endif
169	}
170
171	void CompositingCoordinator::initializeRootCompositingLayerIfNeeded()
172	{
173	if (m_didInitializeRootCompositingLayer)
174	return;
175
176	m_state.rootCompositingLayer = toCoordinatedGraphicsLayer(m_rootLayer.get())->id();
177	m_didInitializeRootCompositingLayer = true;
178	m_shouldSyncFrame = true;
179	}
180
181	void CompositingCoordinator::createRootLayer(const IntSize& size)
182	{
183	ASSERT(!m_rootLayer);
184	// Create a root layer.
185	m_rootLayer = GraphicsLayer::create(this, this);
186	#ifndef NDEBUG
187	m_rootLayer->setName("CompositingCoordinator root layer");
188	#endif
189	m_rootLayer->setDrawsContent(false);
190	m_rootLayer->setSize(size);
191	}
192
193	void CompositingCoordinator::syncLayerState(CoordinatedLayerID id, CoordinatedGraphicsLayerState& state)
194	{
195	m_shouldSyncFrame = true;
196	m_client->willSyncLayerState(state);
197	m_state.layersToUpdate.append(std::make_pair(id, state));
198	}
199
200	PassRefPtr<CoordinatedImageBacking> CompositingCoordinator::createImageBackingIfNeeded(Image* image)
201	{
202	CoordinatedImageBackingID imageID = CoordinatedImageBacking::getCoordinatedImageBackingID(image);
203	ImageBackingMap::iterator it = m_imageBackings.find(imageID);
204	RefPtr<CoordinatedImageBacking> imageBacking;
205	if (it == m_imageBackings.end()) {
206	imageBacking = CoordinatedImageBacking::create(this, image);
207	m_imageBackings.add(imageID, imageBacking);
208	} else
209	imageBacking = it->value;
210
211	return imageBacking;
212	}
213
214	void CompositingCoordinator::createImageBacking(CoordinatedImageBackingID imageID)
215	{
216	m_state.imagesToCreate.append(imageID);
217	}
218
219	void CompositingCoordinator::updateImageBacking(CoordinatedImageBackingID imageID, PassRefPtr<CoordinatedSurface> coordinatedSurface)
220	{
221	m_shouldSyncFrame = true;
222	m_state.imagesToUpdate.append(std::make_pair(imageID, coordinatedSurface));
223	}
224
225	void CompositingCoordinator::clearImageBackingContents(CoordinatedImageBackingID imageID)
226	{
227	m_shouldSyncFrame = true;
228	m_state.imagesToClear.append(imageID);
229	}
230
231	void CompositingCoordinator::removeImageBacking(CoordinatedImageBackingID imageID)
232	{
233	if (m_isPurging)
234	return;
235
236	ASSERT(m_imageBackings.contains(imageID));
237	m_imageBackings.remove(imageID);
238
239	m_state.imagesToRemove.append(imageID);
240	}
241
242	void CompositingCoordinator::flushPendingImageBackingChanges()
243	{
244	ImageBackingMap::iterator end = m_imageBackings.end();
245	for (ImageBackingMap::iterator iter = m_imageBackings.begin(); iter != end; ++iter)
246	iter->value->update();
247	}
248
249	void CompositingCoordinator::notifyAnimationStarted(const GraphicsLayer, double / time */)
250	{
251	}
252
253	void CompositingCoordinator::notifyFlushRequired(const GraphicsLayer*)
254	{
255	m_client->notifyFlushRequired();
256	}
257
258
259	void CompositingCoordinator::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& graphicsContext, GraphicsLayerPaintingPhase, const IntRect& clipRect)
260	{
261	m_client->paintLayerContents(graphicsLayer, graphicsContext, clipRect);
262	}
263
264	PassOwnPtr<GraphicsLayer> CompositingCoordinator::createGraphicsLayer(GraphicsLayerClient* client)
265	{
266	CoordinatedGraphicsLayer* layer = new CoordinatedGraphicsLayer(client);
267	layer->setCoordinator(this);
268	m_registeredLayers.add(layer->id(), layer);
269	m_state.layersToCreate.append(layer->id());
270	layer->setNeedsVisibleRectAdjustment();
271	m_client->notifyFlushRequired();
272	return adoptPtr(layer);
273	}
274
275	float CompositingCoordinator::deviceScaleFactor() const
276	{
277	return m_page->deviceScaleFactor();
278	}
279
280	float CompositingCoordinator::pageScaleFactor() const
281	{
282	return m_page->pageScaleFactor();
283	}
284
285	void CompositingCoordinator::createUpdateAtlas(uint32_t atlasID, PassRefPtr<CoordinatedSurface> coordinatedSurface)
286	{
287	m_state.updateAtlasesToCreate.append(std::make_pair(atlasID, coordinatedSurface));
288	}
289
290	void CompositingCoordinator::removeUpdateAtlas(uint32_t atlasID)
291	{
292	if (m_isPurging)
293	return;
294	m_state.updateAtlasesToRemove.append(atlasID);
295	}
296
297	FloatRect CompositingCoordinator::visibleContentsRect() const
298	{
299	return m_visibleContentsRect;
300	}
301
302	CoordinatedGraphicsLayer* CompositingCoordinator::mainContentsLayer()
303	{
304	if (!m_rootCompositingLayer)
305	return 0;
306
307	return toCoordinatedGraphicsLayer(m_rootCompositingLayer)->findFirstDescendantWithContentsRecursively();
308	}
309
310	void CompositingCoordinator::setVisibleContentsRect(const FloatRect& rect, const FloatPoint& trajectoryVector)
311	{
312	// A zero trajectoryVector indicates that tiles all around the viewport are requested.
313	if (CoordinatedGraphicsLayer* contentsLayer = mainContentsLayer())
314	contentsLayer->setVisibleContentRectTrajectoryVector(trajectoryVector);
315
316	bool contentsRectDidChange = rect != m_visibleContentsRect;
317	if (contentsRectDidChange) {
318	m_visibleContentsRect = rect;
319
320	LayerMap::iterator end = m_registeredLayers.end();
321	for (LayerMap::iterator it = m_registeredLayers.begin(); it != end; ++it)
322	it->value->setNeedsVisibleRectAdjustment();
323	}
324
325	FrameView* view = m_page->mainFrame()->view();
326	if (view->useFixedLayout()) {
327	// Round the rect instead of enclosing it to make sure that its size stays
328	// the same while panning. This can have nasty effects on layout.
329	view->setFixedVisibleContentRect(roundedIntRect(rect));
330	}
331	}
332
333	void CompositingCoordinator::deviceOrPageScaleFactorChanged()
334	{
335	m_rootLayer->deviceOrPageScaleFactorChanged();
336	}
337
338	void CompositingCoordinator::detachLayer(CoordinatedGraphicsLayer* layer)
339	{
340	if (m_isPurging)
341	return;
342
343	m_registeredLayers.remove(layer->id());
344
345	size_t index = m_state.layersToCreate.find(layer->id());
346	if (index != notFound) {
347	m_state.layersToCreate.remove(index);
348	return;
349	}
350
351	m_state.layersToRemove.append(layer->id());
352	m_client->notifyFlushRequired();
353	}
354
355	void CompositingCoordinator::commitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset)
356	{
357	LayerMap::iterator i = m_registeredLayers.find(layerID);
358	if (i == m_registeredLayers.end())
359	return;
360
361	i->value->commitScrollOffset(offset);
362	}
363
364	void CompositingCoordinator::renderNextFrame()
365	{
366	for (unsigned i = 0; i < m_updateAtlases.size(); ++i)
367	m_updateAtlases[i]->didSwapBuffers();
368	}
369
370	void CompositingCoordinator::purgeBackingStores()
371	{
372	TemporaryChange<bool> purgingToggle(m_isPurging, true);
373
374	LayerMap::iterator end = m_registeredLayers.end();
375	for (LayerMap::iterator it = m_registeredLayers.begin(); it != end; ++it)
376	it->value->purgeBackingStores();
377
378	m_imageBackings.clear();
379	m_updateAtlases.clear();
380	}
381
382	bool CompositingCoordinator::paintToSurface(const IntSize& size, CoordinatedSurface::Flags flags, uint32_t& atlasID, IntPoint& offset, CoordinatedSurface::Client* client)
383	{
384	for (unsigned i = 0; i < m_updateAtlases.size(); ++i) {
385	UpdateAtlas* atlas = m_updateAtlases[i].get();
386	if (atlas->supportsAlpha() == (flags & CoordinatedSurface::SupportsAlpha)) {
387	// This will be false if there is no available buffer space.
388	if (atlas->paintOnAvailableBuffer(size, atlasID, offset, client))
389	return true;
390	}
391	}
392
393	static const int ScratchBufferDimension = 1024; // Should be a power of two.
394	m_updateAtlases.append(adoptPtr(new UpdateAtlas(this, ScratchBufferDimension, flags)));
395	scheduleReleaseInactiveAtlases();
396	return m_updateAtlases.last()->paintOnAvailableBuffer(size, atlasID, offset, client);
397	}
398
399	const double ReleaseInactiveAtlasesTimerInterval = 0.5;
400
401	void CompositingCoordinator::scheduleReleaseInactiveAtlases()
402	{
403	if (!m_releaseInactiveAtlasesTimer.isActive())
404	m_releaseInactiveAtlasesTimer.startRepeating(ReleaseInactiveAtlasesTimerInterval);
405	}
406
407	void CompositingCoordinator::releaseInactiveAtlasesTimerFired(Timer<CompositingCoordinator>*)
408	{
409	// We always want to keep one atlas for non-composited content.
410	OwnPtr<UpdateAtlas> atlasToKeepAnyway;
411	bool foundActiveAtlasForNonCompositedContent = false;
412	for (int i = m_updateAtlases.size() - 1; i >= 0; --i) {
413	UpdateAtlas* atlas = m_updateAtlases[i].get();
414	if (!atlas->isInUse())
415	atlas->addTimeInactive(ReleaseInactiveAtlasesTimerInterval);
416	bool usableForNonCompositedContent = !atlas->supportsAlpha();
417	if (atlas->isInactive()) {
418	if (!foundActiveAtlasForNonCompositedContent && !atlasToKeepAnyway && usableForNonCompositedContent)
419	atlasToKeepAnyway = m_updateAtlases[i].release();
420	m_updateAtlases.remove(i);
421	} else if (usableForNonCompositedContent)
422	foundActiveAtlasForNonCompositedContent = true;
423	}
424
425	if (!foundActiveAtlasForNonCompositedContent && atlasToKeepAnyway)
426	m_updateAtlases.append(atlasToKeepAnyway.release());
427
428	if (m_updateAtlases.size() <= 1)
429	m_releaseInactiveAtlasesTimer.stop();
430	}
431
432	} // namespace WebCore
433
434	#endif // USE(COORDINATED_GRAPHICS)