2012-12-07  Gwang Yoon Hwang  <ryumiel@company100.net>

        Coordinated Graphics: Separeate LayerTreeCoordinator into LayerTreeCoordinator and CompositingCoordinator

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

        Reviewed by NOBODY (OOPS!).

        The LayerTreeCoordinator has too many responsibilities. It implements

        LayerTreeHost, GraphicsLayerClient, CoordinatedGraphicsLayerClient,

        CoordinatedImageBacking::Coordinator, UpdateAtlasClient,

        GraphicsLayerFactory and WebCustomFilterProgramProxyClient.

        This refactoring reduces the responsibilities of LayerTreeCoordinator.

        By creates a new class called CompositingCoordinator, which takes the

        responsibility of scheduling compositing task in WebProcess,

        LayerTreeCoordinator acts like simple LayerTreeHost.

        By extracting interfaces dealing with LayerTreeCoordinatorProxy to

        CompositingCoordinatorMessageClient, CompositingCoordinator is decoupled

        from IPC handling.

        WebCompositingCoordinatorMessageClient implements IPC handling for

        CompositingCoordinator and LayerTreeCoordinator.

        WebCustomFilterProgramProxyClient is stands for IPC handling, so

        WebCompositingCoordiantorMessageClient implements this interface, too.

        No new tests because no change in behavior.

        * CMakeLists.txt:

        * Target.pri:

        * WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.cpp:

        Added. It takes responsibiliy for scheduling compositing tasks and

        managing resources.

        (WebKit):

        (WebKit::CompositingCoordinator::create):

        (WebKit::CompositingCoordinator::~CompositingCoordinator):

        (WebKit::CompositingCoordinator::CompositingCoordinator):

        (WebKit::CompositingCoordinator::setLayerFlushSchedulingEnabled):

        (WebKit::CompositingCoordinator::scheduleLayerFlush):

        (WebKit::CompositingCoordinator::cancelPendingLayerFlush):

        (WebKit::CompositingCoordinator::setRootCompositingLayer):

        (WebKit::CompositingCoordinator::invalidate):

        (WebKit::CompositingCoordinator::setNeedsDisplayInRect):

        (WebKit::CompositingCoordinator::forceRepaint):

        (WebKit::CompositingCoordinator::sizeDidChange):

        (WebKit::CompositingCoordinator::flushPendingLayerChanges):

        (WebKit::CompositingCoordinator::syncLayerState):

        (WebKit::CompositingCoordinator::syncLayerChildren):

        (WebKit::CompositingCoordinator::createCanvas):

        (WebKit::CompositingCoordinator::syncCanvas):

        (WebKit::CompositingCoordinator::destroyCanvas):

        (WebKit::CompositingCoordinator::syncLayerFilters):

        (WebKit::CompositingCoordinator::detachLayer):

        (WebKit::updateOffsetFromViewportForSelf):

        (WebKit::updateOffsetFromViewportForLayer):

        (WebKit::CompositingCoordinator::syncFixedLayers):

        (WebKit::CompositingCoordinator::lockAnimations):

        (WebKit::CompositingCoordinator::unlockAnimations):

        (WebKit::CompositingCoordinator::performScheduledLayerFlush):

        (WebKit::CompositingCoordinator::syncDisplayState):

        (WebKit::CompositingCoordinator::layerFlushTimerFired):

        (WebKit::CompositingCoordinator::createPageOverlayLayer):

        (WebKit::CompositingCoordinator::destroyPageOverlayLayer):

        (WebKit::CompositingCoordinator::setPageOverlayNeedsDisplay):

        (WebKit::CompositingCoordinator::setPageOverlayOpacity):

        (WebKit::CompositingCoordinator::createImageBackingIfNeeded):

        (WebKit::CompositingCoordinator::createImageBacking):

        (WebKit::CompositingCoordinator::updateImageBacking):

        (WebKit::CompositingCoordinator::clearImageBackingContents):

        (WebKit::CompositingCoordinator::removeImageBacking):

        (WebKit::CompositingCoordinator::flushPendingImageBackingChanges):

        (WebKit::CompositingCoordinator::notifyAnimationStarted):

        (WebKit::CompositingCoordinator::notifyFlushRequired):

        (WebKit::CompositingCoordinator::paintContents):

        (WebKit::CompositingCoordinator::createGraphicsLayer):

        (WebKit::CompositingCoordinator::createTile):

        (WebKit::CompositingCoordinator::updateTile):

        (WebKit::CompositingCoordinator::removeTile):

        (WebKit::CompositingCoordinator::createUpdateAtlas):

        (WebKit::CompositingCoordinator::removeUpdateAtlas):

        (WebKit::CompositingCoordinator::visibleContentsRect):

        (WebKit::CompositingCoordinator::setLayerAnimations):

        (WebKit::CompositingCoordinator::setVisibleContentsRect):

        (WebKit::CompositingCoordinator::renderNextFrame):

        (WebKit::CompositingCoordinator::layerTreeTileUpdatesAllowed):

        (WebKit::CompositingCoordinator::purgeBackingStores):

        (WebKit::CompositingCoordinator::beginContentUpdate):

        (WebKit::CompositingCoordinator::scheduleReleaseInactiveAtlases):

        (WebKit::CompositingCoordinator::releaseInactiveAtlasesTimerFired):

        * WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.h:

        Added.

        (WebCore):

        (WebKit):

        (CompositingCoordinator):

        (WebKit::CompositingCoordinator::pauseRendering):

        (WebKit::CompositingCoordinator::resumeRendering):

        (WebKit::CompositingCoordinator::rootGraphicsLayer):

        * WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinatorClient.h: Added.

        (WebKit):

        (CompositingCoordinatorMessageClient):

        This interface provides a way to send messages to renderer.

        (CompositingCoordinatorClient):

        This interface provides a way to use LayerTreeCoordinator from

        Compositing Coordinator.

        (WebKit::CompositingCoordinatorClient::~CompositingCoordinatorClient):

        * WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp:

        (WebKit::LayerTreeCoordinator::~LayerTreeCoordinator):

        (WebKit::LayerTreeCoordinator::LayerTreeCoordinator):

        (WebKit::LayerTreeCoordinator::setLayerFlushSchedulingEnabled):

        (WebKit::LayerTreeCoordinator::scheduleLayerFlush):

        (WebKit::LayerTreeCoordinator::setRootCompositingLayer):

        (WebKit::LayerTreeCoordinator::invalidate):

        (WebKit::LayerTreeCoordinator::setNonCompositedContentsNeedDisplay):

        (WebKit::LayerTreeCoordinator::forceRepaint):

        (WebKit::LayerTreeCoordinator::sizeDidChange):

        (WebKit::LayerTreeCoordinator::didInstallPageOverlay):

        (WebKit::LayerTreeCoordinator::didUninstallPageOverlay):

        (WebKit::LayerTreeCoordinator::setPageOverlayNeedsDisplay):

        (WebKit::LayerTreeCoordinator::setPageOverlayOpacity):

        (WebKit::LayerTreeCoordinator::pauseRendering):

        (WebKit::LayerTreeCoordinator::resumeRendering):

        (WebKit::LayerTreeCoordinator::viewSize):

        (WebKit::LayerTreeCoordinator::layoutIfNeeded):

        (WebKit::LayerTreeCoordinator::isOpaqueContents):

        (WebKit::LayerTreeCoordinator::didPerformScheduledLayerFlush):

        (WebKit::LayerTreeCoordinator::paintContents):

        (WebKit::LayerTreeCoordinator::paintOverlayContents):

        (WebKit::LayerTreeCoordinator::setVisibleContentsRect):

        (WebKit::LayerTreeCoordinator::graphicsLayerFactory):

        (WebKit::LayerTreeCoordinator::scheduleAnimation):

        (WebKit::LayerTreeCoordinator::renderNextFrame):

        (WebKit::LayerTreeCoordinator::purgeBackingStores):

        (WebKit::LayerTreeCoordinator::setBackgroundColor):

        * WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.h:

        (WebCore):

        (LayerTreeCoordinator):

        * WebProcess/WebPage/CoordinatedGraphics/WebCompositingCoordinatorMessageClient.cpp:

        Added. Manages sends actual IPC messages and manages

        WebCustomFilterProgram

        (WebKit):

        (WebKit::WebCompositingCoordinatorMessageClient::create):

        (WebKit::WebCompositingCoordinatorMessageClient::~WebCompositingCoordinatorMessageClient):

        (WebKit::WebCompositingCoordinatorMessageClient::WebCompositingCoordinatorMessageClient):

        (WebKit::WebCompositingCoordinatorMessageClient::setRootCompositingLayer):

        (WebKit::WebCompositingCoordinatorMessageClient::setCompositingLayerState):

        (WebKit::WebCompositingCoordinatorMessageClient::setCompositingLayerChildren):

        (WebKit::WebCompositingCoordinatorMessageClient::setCompositingLayerFilters):

        (WebKit::WebCompositingCoordinatorMessageClient::deleteCompositingLayer):

        (WebKit::WebCompositingCoordinatorMessageClient::createTileForLayer):

        (WebKit::WebCompositingCoordinatorMessageClient::updateTileForLayer):

        (WebKit::WebCompositingCoordinatorMessageClient::removeTileForLayer):

        (WebKit::WebCompositingCoordinatorMessageClient::createUpdateAtlas):

        (WebKit::WebCompositingCoordinatorMessageClient::removeUpdateAtlas):

        (WebKit::WebCompositingCoordinatorMessageClient::createImageBacking):

        (WebKit::WebCompositingCoordinatorMessageClient::updateImageBacking):

        (WebKit::WebCompositingCoordinatorMessageClient::clearImageBackingContents):

        (WebKit::WebCompositingCoordinatorMessageClient::removeImageBacking):

        (WebKit::WebCompositingCoordinatorMessageClient::didRenderFrame):

        (WebKit::WebCompositingCoordinatorMessageClient::didChangeScrollPosition):

        (WebKit::WebCompositingCoordinatorMessageClient::createCanvas):

        (WebKit::WebCompositingCoordinatorMessageClient::syncCanvas):

        (WebKit::WebCompositingCoordinatorMessageClient::destroyCanvas):

        (WebKit::WebCompositingCoordinatorMessageClient::setLayerAnimations):

        (WebKit::WebCompositingCoordinatorMessageClient::setAnimationsLocked):

        (WebKit::WebCompositingCoordinatorMessageClient::setBackgroundColor):

        (WebKit::WebCompositingCoordinatorMessageClient::requestAnimationFrame):

        (WebKit::WebCompositingCoordinatorMessageClient::invokeForceRepaintAsyncCallback):

        (WebKit::WebCompositingCoordinatorMessageClient::checkCustomFilterProgramProxies):

        (WebKit::WebCompositingCoordinatorMessageClient::removeCustomFilterProgramProxy):

        (WebKit::WebCompositingCoordinatorMessageClient::disconnectCustomFilterPrograms):

        * WebProcess/WebPage/CoordinatedGraphics/WebCompositingCoordinatorMessageClient.h: Added.

        (WebKit):

        (WebCompositingCoordinatorMessageClient):

    WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.cpp

    WebProcess/WebPage/CoordinatedGraphics/WebCompositingCoordinatorMessageClient.cpp

    WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.h \

    WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinatorClient.h \

    WebProcess/WebPage/CoordinatedGraphics/WebCompositingCoordinatorMessageClient.h \

    WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.cpp \

    WebProcess/WebPage/CoordinatedGraphics/WebCompositingCoordinatorMessageClient.cpp \

/*

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

 * Copyright (C) 2012 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 "CoordinatedLayerInfo.h"

#include "SurfaceUpdateInfo.h"

#include <WebCore/Frame.h>

#include <WebCore/FrameView.h>

#include <WebCore/GraphicsSurface.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/TextureMapperPlatformLayer.h>

#include <wtf/TemporaryChange.h>

#if ENABLE(CSS_SHADERS)

#include "CustomFilterValidatedProgram.h"

#include "ValidatedCustomFilterOperation.h"

#endif

using namespace WebCore;

namespace WebKit {

PassOwnPtr<CompositingCoordinator> CompositingCoordinator::create(Page* page, CompositingCoordinatorClient* client, CompositingCoordinatorMessageClient* messageClient)

{

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

}

CompositingCoordinator::~CompositingCoordinator()

{

    // Prevent setCoordinatedGraphicsLayerClient(0) -> detachLayer() from modifying the set while we iterate it.

    HashSet<CoordinatedGraphicsLayer*> registeredLayers;

    registeredLayers.swap(m_registeredLayers);

    HashSet<CoordinatedGraphicsLayer*>::iterator end = registeredLayers.end();

    for (HashSet<CoordinatedGraphicsLayer*>::iterator it = registeredLayers.begin(); it != end; ++it)

        (*it)->setCoordinator(0);

}

CompositingCoordinator::CompositingCoordinator(Page* page, CompositingCoordinatorClient* client, CompositingCoordinatorMessageClient* messageClient)

    : m_page(page)

    , m_client(client)

    , m_messageClient(messageClient)

    , m_isValid(true)

    , m_isPurging(false)

    , m_waitingForRenderer(true)

    , m_isSuspended(false)

    , m_contentsScale(1)

    , m_shouldSendScrollPositionUpdate(true)

    , m_shouldSyncFrame(false)

    , m_shouldSyncRootLayer(true)

    , m_layerFlushTimer(this, &CompositingCoordinator::layerFlushTimerFired)

    , m_releaseInactiveAtlasesTimer(this, &CompositingCoordinator::releaseInactiveAtlasesTimerFired)

    , m_layerFlushSchedulingEnabled(true)

    , m_forceRepaintAsyncCallbackID(0)

    , m_animationsLocked(false)

{

    // Create a root layer.

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

    CoordinatedGraphicsLayer* coordinatedRootLayer = toCoordinatedGraphicsLayer(m_rootLayer.get());

    coordinatedRootLayer->setRootLayer(true);

#ifndef NDEBUG

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

#endif

    m_rootLayer->setDrawsContent(false);

    IntSize viewSize(m_client->viewSize());

    m_rootLayer->setSize(viewSize);

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

#ifndef NDEBUG

    m_nonCompositedContentLayer->setName("CompositingCoordinator non-composited content");

#endif

    m_nonCompositedContentLayer->setDrawsContent(true);

    m_nonCompositedContentLayer->setSize(viewSize);

    m_rootLayer->addChild(m_nonCompositedContentLayer.get());

    scheduleLayerFlush();

}

void CompositingCoordinator::setLayerFlushSchedulingEnabled(bool layerFlushingEnabled)

{

    if (m_layerFlushSchedulingEnabled == layerFlushingEnabled)

        return;

    m_layerFlushSchedulingEnabled = layerFlushingEnabled;

    if (m_layerFlushSchedulingEnabled) {

        scheduleLayerFlush();

        return;

    }

    cancelPendingLayerFlush();

}

void CompositingCoordinator::scheduleLayerFlush()

{

    if (!m_layerFlushSchedulingEnabled)

        return;

    if (!m_layerFlushTimer.isActive())

        m_layerFlushTimer.startOneShot(0);

}

void CompositingCoordinator::cancelPendingLayerFlush()

{

    m_layerFlushTimer.stop();

}

void CompositingCoordinator::setRootCompositingLayer(GraphicsLayer* graphicsLayer)

{

    m_nonCompositedContentLayer->removeAllChildren();

    m_nonCompositedContentLayer->setContentsOpaque(m_client->isOpaqueContents());

    // Add the accelerated layer tree hierarchy.

    if (graphicsLayer)

        m_nonCompositedContentLayer->addChild(graphicsLayer);

}

void CompositingCoordinator::invalidate()

{

    cancelPendingLayerFlush();

    ASSERT(m_isValid);

    m_rootLayer = nullptr;

    m_isValid = false;

}

void CompositingCoordinator::setNeedsDisplayInRect(const IntRect& rect)

{

    m_nonCompositedContentLayer->setNeedsDisplayInRect(rect);

    if (m_pageOverlayLayer)

        m_pageOverlayLayer->setNeedsDisplayInRect(rect);

    scheduleLayerFlush();

}

void CompositingCoordinator::forceRepaint()

{

    // This is necessary for running layout tests. Since in this case we are not waiting for a renderer to reply nicely.

    // Instead we are just triggering forceRepaint. But we still want to have the scripted animation callbacks being executed.

    syncDisplayState();

    // We need to schedule another flush, otherwise the forced paint might cancel a later expected flush.

    // This is aligned with LayerTreeHostCA.

    scheduleLayerFlush();

    flushPendingLayerChanges();

}

void CompositingCoordinator::sizeDidChange(const IntSize& newSize)

{

    if (m_rootLayer->size() == newSize)

        return;

    m_rootLayer->setSize(newSize);

    // If the newSize exposes new areas of the non-composited content a setNeedsDisplay is needed

    // for those newly exposed areas.

    FloatSize oldSize = m_nonCompositedContentLayer->size();

    m_nonCompositedContentLayer->setSize(newSize);

    if (newSize.width() > oldSize.width()) {

        float height = std::min(static_cast<float>(newSize.height()), oldSize.height());

        m_nonCompositedContentLayer->setNeedsDisplayInRect(FloatRect(oldSize.width(), 0, newSize.width() - oldSize.width(), height));

    }

    if (newSize.height() > oldSize.height())

        m_nonCompositedContentLayer->setNeedsDisplayInRect(FloatRect(0, oldSize.height(), newSize.width(), newSize.height() - oldSize.height()));

    if (m_pageOverlayLayer)

        m_pageOverlayLayer->setSize(newSize);

    scheduleLayerFlush();

}

bool CompositingCoordinator::flushPendingLayerChanges()

{

    if (m_waitingForRenderer)

        return false;

    for (size_t i = 0; i < m_detachedLayers.size(); ++i)

        m_messageClient->deleteCompositingLayer(m_detachedLayers[i]);

    m_detachedLayers.clear();

    m_rootLayer->flushCompositingStateForThisLayerOnly();

    m_nonCompositedContentLayer->flushCompositingStateForThisLayerOnly();

    if (m_pageOverlayLayer)

        m_pageOverlayLayer->flushCompositingStateForThisLayerOnly();

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

    flushPendingImageBackingChanges();

    if (m_shouldSyncRootLayer) {

        m_messageClient->setRootCompositingLayer(toCoordinatedGraphicsLayer(m_rootLayer.get())->id());

        m_shouldSyncRootLayer = false;

        m_shouldSyncFrame = true;

    }

    if (m_shouldSyncFrame) {

        didSync = true;

        IntSize contentsSize = roundedIntSize(m_nonCompositedContentLayer->size());

        IntRect coveredRect = toCoordinatedGraphicsLayer(m_nonCompositedContentLayer.get())->coverRect();

        m_messageClient->didRenderFrame(contentsSize, coveredRect);

        m_waitingForRenderer = true;

        m_shouldSyncFrame = false;

    } else

        unlockAnimations();

    return didSync;

}

void CompositingCoordinator::syncLayerState(CoordinatedLayerID id, const CoordinatedLayerInfo& info)

{

    if (m_shouldSendScrollPositionUpdate) {

        m_messageClient->didChangeScrollPosition(m_visibleContentsRect.location());

        m_shouldSendScrollPositionUpdate = false;

    }

    m_shouldSyncFrame = true;

    m_messageClient->setCompositingLayerState(id, info);

}

void CompositingCoordinator::syncLayerChildren(CoordinatedLayerID id, const Vector<CoordinatedLayerID>& children)

{

    m_shouldSyncFrame = true;

    m_messageClient->setCompositingLayerChildren(id, children);

}

#if USE(GRAPHICS_SURFACE)

void CompositingCoordinator::createCanvas(CoordinatedLayerID id, PlatformLayer* canvasPlatformLayer)

{

    m_shouldSyncFrame = true;

    GraphicsSurfaceToken token = canvasPlatformLayer->graphicsSurfaceToken();

    IntSize canvasSize = canvasPlatformLayer->platformLayerSize();

    m_messageClient->createCanvas(id, canvasSize, token);

}

void CompositingCoordinator::syncCanvas(CoordinatedLayerID id, PlatformLayer* canvasPlatformLayer)

{

    m_shouldSyncFrame = true;

    uint32_t frontBuffer = canvasPlatformLayer->copyToGraphicsSurface();

    m_messageClient->syncCanvas(id, frontBuffer);

}

void CompositingCoordinator::destroyCanvas(CoordinatedLayerID id)

{

    if (m_isPurging)

        return;

    m_shouldSyncFrame = true;

    m_messageClient->destroyCanvas(id);

}

#endif

#if ENABLE(CSS_FILTERS)

void CompositingCoordinator::syncLayerFilters(CoordinatedLayerID id, const FilterOperations& filters)

{

    m_shouldSyncFrame = true;

    m_messageClient->setCompositingLayerFilters(id, filters);

}

#endif

void CompositingCoordinator::detachLayer(CoordinatedGraphicsLayer* layer)

{

    m_registeredLayers.remove(layer);

    m_shouldSyncFrame = true;

    m_detachedLayers.append(layer->id());

    scheduleLayerFlush();

}

static void updateOffsetFromViewportForSelf(RenderLayer* renderLayer)

{

    // These conditions must match the conditions in RenderLayerCompositor::requiresCompositingForPosition.

    RenderLayerBacking* backing = renderLayer->backing();

    if (!backing)

        return;

    RenderStyle* style = renderLayer->renderer()->style();

    if (!style)

        return;

    if (!renderLayer->renderer()->isOutOfFlowPositioned() || renderLayer->renderer()->style()->position() != FixedPosition)

        return;

    if (!renderLayer->renderer()->container()->isRenderView())

        return;

    if (!renderLayer->isStackingContext())

        return;

    CoordinatedGraphicsLayer* graphicsLayer = toCoordinatedGraphicsLayer(backing->graphicsLayer());

    graphicsLayer->setFixedToViewport(true);

}

static void updateOffsetFromViewportForLayer(RenderLayer* renderLayer)

{

    updateOffsetFromViewportForSelf(renderLayer);

    if (renderLayer->firstChild())

        updateOffsetFromViewportForLayer(renderLayer->firstChild());

    if (renderLayer->nextSibling())

        updateOffsetFromViewportForLayer(renderLayer->nextSibling());

}

void CompositingCoordinator::syncFixedLayers()

{

    if (!m_page->settings() || !m_page->settings()->acceleratedCompositingForFixedPositionEnabled())

        return;

    if (!m_page->mainFrame()->view()->hasViewportConstrainedObjects())

        return;

    RenderLayer* rootRenderLayer = m_page->mainFrame()->contentRenderer()->compositor()->rootRenderLayer();

    ASSERT(rootRenderLayer);

    if (rootRenderLayer->firstChild())

        updateOffsetFromViewportForLayer(rootRenderLayer->firstChild());

}

void CompositingCoordinator::lockAnimations()

{

    m_animationsLocked = true;

    m_messageClient->setAnimationsLocked(true);

}

void CompositingCoordinator::unlockAnimations()

{

    if (!m_animationsLocked)

        return;

    m_animationsLocked = false;

    m_messageClient->setAnimationsLocked(false);

}

void CompositingCoordinator::performScheduledLayerFlush()

{

    if (m_isSuspended || m_waitingForRenderer)

        return;

    // We lock the animations while performing layout, to avoid flickers caused by animations continuing in the renderer while

    // the web process layout wants to cancel them.

    lockAnimations();

    syncDisplayState();

    // We can unlock the animations before flushing if there are no visible changes, for example if there are content updates

    // in a layer with opacity 0.

    bool canUnlockBeforeFlush = !m_isValid || !toCoordinatedGraphicsLayer(m_rootLayer.get())->hasPendingVisibleChanges();

    if (canUnlockBeforeFlush)

        unlockAnimations();

    if (!m_isValid)

        return;

    bool didSync = flushPendingLayerChanges();

    m_client->didPerformScheduledLayerFlush(didSync);

}

void CompositingCoordinator::syncDisplayState()

{

#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_page->mainFrame()->view()->serviceScriptedAnimations(convertSecondsToDOMTimeStamp(currentTime()));

#endif

    m_client->layoutIfNeeded();

}

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

{

    performScheduledLayerFlush();

}

void CompositingCoordinator::createPageOverlayLayer()

{

    ASSERT(!m_pageOverlayLayer);

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

#ifndef NDEBUG

    m_pageOverlayLayer->setName("CompositingCoordinator page overlay content");

#endif

    m_pageOverlayLayer->setDrawsContent(true);

    m_pageOverlayLayer->setSize(m_client->viewSize());

    m_rootLayer->addChild(m_pageOverlayLayer.get());

    scheduleLayerFlush();

}

void CompositingCoordinator::destroyPageOverlayLayer()

{

    ASSERT(m_pageOverlayLayer);

    m_pageOverlayLayer->removeFromParent();

    m_pageOverlayLayer = nullptr;

    scheduleLayerFlush();

}

void CompositingCoordinator::setPageOverlayNeedsDisplay(const WebCore::IntRect& rect)

{

    ASSERT(m_pageOverlayLayer);

    m_pageOverlayLayer->setNeedsDisplayInRect(rect);

    scheduleLayerFlush();

}

void CompositingCoordinator::setPageOverlayOpacity(float value)

{

    ASSERT(m_pageOverlayLayer);

    m_pageOverlayLayer->setOpacity(value);

    scheduleLayerFlush();

}

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_shouldSyncFrame = true;

    m_messageClient->createImageBacking(imageID);

}

void CompositingCoordinator::updateImageBacking(CoordinatedImageBackingID imageID, const ShareableSurface::Handle& handle)

{

    m_shouldSyncFrame = true;

    m_messageClient->updateImageBacking(imageID, handle);

}

void CompositingCoordinator::clearImageBackingContents(CoordinatedImageBackingID imageID)

{

    m_shouldSyncFrame = true;

    m_messageClient->clearImageBackingContents(imageID);

}

void CompositingCoordinator::removeImageBacking(CoordinatedImageBackingID imageID)

{

    if (m_isPurging)

        return;

    ASSERT(m_imageBackings.contains(imageID));

    m_shouldSyncFrame = true;

    m_imageBackings.remove(imageID);

    m_messageClient->removeImageBacking(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*)

{

}

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

{

    bool isNonCompositingContent = (graphicsLayer == m_nonCompositedContentLayer);

    bool isPageOverlay = (graphicsLayer == m_pageOverlayLayer);

    if (isNonCompositingContent)

        m_client->paintContents(graphicsContext, clipRect);

    else if (isPageOverlay)

        m_client->paintOverlayContents(graphicsContext, clipRect);

}

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

{

    CoordinatedGraphicsLayer* layer = new CoordinatedGraphicsLayer(client);

    layer->setCoordinator(this);

    m_registeredLayers.add(layer);

    layer->setContentsScale(m_contentsScale);

    layer->adjustVisibleRect();

    return adoptPtr(layer);

}

void CompositingCoordinator::createTile(CoordinatedLayerID layerID, uint32_t tileID, const SurfaceUpdateInfo& updateInfo, const IntRect& tileRect)

{

    m_shouldSyncFrame = true;

    m_messageClient->createTileForLayer(layerID, tileID, tileRect, updateInfo);

}

void CompositingCoordinator::updateTile(CoordinatedLayerID layerID, uint32_t tileID, const SurfaceUpdateInfo& updateInfo, const IntRect& tileRect)

{

    m_shouldSyncFrame = true;

    m_messageClient->updateTileForLayer(layerID, tileID, tileRect, updateInfo);

}

void CompositingCoordinator::removeTile(CoordinatedLayerID layerID, uint32_t tileID)

{

    if (m_isPurging)

        return;

    m_shouldSyncFrame = true;

    m_messageClient->removeTileForLayer(layerID, tileID);

}

void CompositingCoordinator::createUpdateAtlas(int atlasID, const ShareableSurface::Handle& handle)

{

    m_messageClient->createUpdateAtlas(atlasID, handle);

}

void CompositingCoordinator::removeUpdateAtlas(int atlasID)

{

    if (m_isPurging)

        return;

    m_messageClient->removeUpdateAtlas(atlasID);

}

IntRect CompositingCoordinator::visibleContentsRect() const

{

    return m_visibleContentsRect;

}

void CompositingCoordinator::setLayerAnimations(CoordinatedLayerID layerID, const GraphicsLayerAnimations& animations)

{

    m_shouldSyncFrame = true;

    GraphicsLayerAnimations activeAnimations = animations.getActiveAnimations();

    m_messageClient->setLayerAnimations(layerID, activeAnimations);

}

void CompositingCoordinator::setVisibleContentsRect(const IntRect& rect, float scale, const FloatPoint& trajectoryVector)

{

    bool contentsRectDidChange = rect != m_visibleContentsRect;

    bool contentsScaleDidChange = scale != m_contentsScale;

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

    toCoordinatedGraphicsLayer(m_nonCompositedContentLayer.get())->setVisibleContentRectTrajectoryVector(trajectoryVector);

    if (contentsRectDidChange || contentsScaleDidChange) {

        m_visibleContentsRect = rect;

        m_contentsScale = scale;

        HashSet<CoordinatedGraphicsLayer*>::iterator end = m_registeredLayers.end();

        for (HashSet<CoordinatedGraphicsLayer*>::iterator it = m_registeredLayers.begin(); it != end; ++it) {

            if (contentsScaleDidChange)

                (*it)->setContentsScale(scale);

            if (contentsRectDidChange)

                (*it)->adjustVisibleRect();

        }

    }

    if (contentsRectDidChange)

        m_shouldSendScrollPositionUpdate = true;

    scheduleLayerFlush();

}

void CompositingCoordinator::renderNextFrame()

{

    m_waitingForRenderer = false;

    scheduleLayerFlush();

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

        m_updateAtlases[i]->didSwapBuffers();

}

bool CompositingCoordinator::layerTreeTileUpdatesAllowed() const

{

    return !m_isSuspended && !m_waitingForRenderer;

}

void CompositingCoordinator::purgeBackingStores()

{

    TemporaryChange<bool> purgingToggle(m_isPurging, true);

    HashSet<CoordinatedGraphicsLayer*>::iterator end = m_registeredLayers.end();

    for (HashSet<CoordinatedGraphicsLayer*>::iterator it = m_registeredLayers.begin(); it != end; ++it)

        (*it)->purgeBackingStores();

    m_imageBackings.clear();

    m_updateAtlases.clear();

}

PassOwnPtr<GraphicsContext> CompositingCoordinator::beginContentUpdate(const WebCore::IntSize& size, ShareableBitmap::Flags flags, int& atlasID, WebCore::IntPoint& offset)

{

    OwnPtr<GraphicsContext> graphicsContext;

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

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

        if (atlas->flags() == flags) {

            // This will return null if there is no available buffer space.

            graphicsContext = atlas->beginPaintingOnAvailableBuffer(atlasID, size, offset);

            if (graphicsContext)

                return graphicsContext.release();

        }

    }

    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()->beginPaintingOnAvailableBuffer(atlasID, size, offset);

}

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->flags() == ShareableBitmap::NoFlags;

        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 WebKit

#endif // USE(COORDINATED_GRAPHICS)

/*

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

 * Copyright (C) 2012 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 "CompositingCoordinatorClient.h"

#include "CoordinatedGraphicsLayer.h"

#include "CoordinatedImageBacking.h"

#include "UpdateAtlas.h"

#include <WebCore/FloatPoint.h>

#include <WebCore/GraphicsLayerClient.h>

#include <WebCore/GraphicsLayerFactory.h>

#include <WebCore/IntRect.h>

#include <WebCore/Timer.h>

#include <wtf/OwnPtr.h>

#if ENABLE(CSS_SHADERS)

#include <WebCore/FilterOperations.h>

#endif

namespace WebCore {

class Page;

}

namespace WebKit {

class CompositingCoordinator : public WebCore::GraphicsLayerClient

    , public CoordinatedGraphicsLayerClient

    , public CoordinatedImageBacking::Coordinator

    , public UpdateAtlasClient

    , public WebCore::GraphicsLayerFactory {

    WTF_MAKE_NONCOPYABLE(CompositingCoordinator); WTF_MAKE_FAST_ALLOCATED;

public:

    static PassOwnPtr<CompositingCoordinator> create(WebCore::Page*, CompositingCoordinatorClient*, CompositingCoordinatorMessageClient*);

    virtual ~CompositingCoordinator();

    virtual void scheduleLayerFlush();

    virtual void setLayerFlushSchedulingEnabled(bool);

    virtual void setRootCompositingLayer(WebCore::GraphicsLayer*);

    virtual void invalidate();

    virtual void setNeedsDisplayInRect(const WebCore::IntRect&);

    virtual void sizeDidChange(const WebCore::IntSize& newSize);

    void createPageOverlayLayer();

    void destroyPageOverlayLayer();

    void setPageOverlayNeedsDisplay(const WebCore::IntRect&);

    void setPageOverlayOpacity(float);

    virtual void pauseRendering() { m_isSuspended = true; }

    virtual void resumeRendering() { m_isSuspended = false; scheduleLayerFlush(); }

    virtual void forceRepaint();

    virtual void setVisibleContentsRect(const WebCore::IntRect&, float scale, const WebCore::FloatPoint&);

    // CoordinatedGraphicsLayerClient :: CoordinatedTileClient

    virtual void createTile(CoordinatedLayerID, uint32_t tileID, const SurfaceUpdateInfo&, const WebCore::IntRect&);

    virtual void updateTile(CoordinatedLayerID, uint32_t tileID, const SurfaceUpdateInfo&, const WebCore::IntRect&);

    virtual void removeTile(CoordinatedLayerID, uint32_t tileID);

    // CoordinatedGraphicsLayerClient

    virtual WebCore::IntRect visibleContentsRect() const;

    virtual bool layerTreeTileUpdatesAllowed() const;

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

    virtual void syncLayerState(CoordinatedLayerID, const CoordinatedLayerInfo&);

    virtual void syncLayerChildren(CoordinatedLayerID, const Vector<CoordinatedLayerID>&);

#if ENABLE(CSS_FILTERS)

    virtual void syncLayerFilters(CoordinatedLayerID, const WebCore::FilterOperations&);

#endif

#if USE(GRAPHICS_SURFACE)

    virtual void createCanvas(CoordinatedLayerID, WebCore::PlatformLayer*) OVERRIDE;

    virtual void syncCanvas(CoordinatedLayerID, WebCore::PlatformLayer*) OVERRIDE;

    virtual void destroyCanvas(CoordinatedLayerID) OVERRIDE;

#endif

    virtual void setLayerAnimations(CoordinatedLayerID, const WebCore::GraphicsLayerAnimations&);

    virtual void detachLayer(WebCore::CoordinatedGraphicsLayer*);

    virtual void syncFixedLayers();

    virtual PassOwnPtr<WebCore::GraphicsContext> beginContentUpdate(const WebCore::IntSize&, ShareableBitmap::Flags, int& atlasID, WebCore::IntPoint&);

    // UpdateAtlasClient

    virtual void createUpdateAtlas(int atlasID, const ShareableSurface::Handle&);

    virtual void removeUpdateAtlas(int atlasID);

    void renderNextFrame();

    void purgeBackingStores();

    WebCore::GraphicsLayer* rootGraphicsLayer() const { return m_rootLayer.get(); }

private:

    CompositingCoordinator(WebCore::Page*, CompositingCoordinatorClient*, CompositingCoordinatorMessageClient*);

    // 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);

    // CoordinatedImageBacking::Coordinator

    virtual void createImageBacking(CoordinatedImageBackingID) OVERRIDE;

    virtual void updateImageBacking(CoordinatedImageBackingID, const ShareableSurface::Handle&) OVERRIDE;

    virtual void clearImageBackingContents(CoordinatedImageBackingID) OVERRIDE;

    virtual void removeImageBacking(CoordinatedImageBackingID) OVERRIDE;

    void flushPendingImageBackingChanges();

    // GraphicsLayerFactory

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

    // CompositingCoordinator

    bool flushPendingLayerChanges();

    void cancelPendingLayerFlush();

    void performScheduledLayerFlush();

    void syncDisplayState();

    void lockAnimations();

    void unlockAnimations();

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

    void scheduleReleaseInactiveAtlases();

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

    WebCore::Page* m_page;

    CompositingCoordinatorClient* m_client;

    CompositingCoordinatorMessageClient* m_messageClient;

    OwnPtr<WebCore::GraphicsLayer> m_rootLayer;

    // The layer which contains all non-composited content.

    OwnPtr<WebCore::GraphicsLayer> m_nonCompositedContentLayer;

    // The page overlay layer. Will be null if there's no page overlay.

    OwnPtr<WebCore::GraphicsLayer> m_pageOverlayLayer;

    HashSet<WebCore::CoordinatedGraphicsLayer*> m_registeredLayers;

    Vector<CoordinatedLayerID> m_detachedLayers;

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

    ImageBackingMap m_imageBackings;

    Vector<OwnPtr<UpdateAtlas> > m_updateAtlases;

    bool m_isValid;

    // 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_waitingForRenderer;

    bool m_isSuspended;

    WebCore::IntRect m_visibleContentsRect;

    float m_contentsScale;

    bool m_shouldSendScrollPositionUpdate;

    bool m_shouldSyncFrame;

    bool m_shouldSyncRootLayer;

    WebCore::Timer<CompositingCoordinator> m_layerFlushTimer;

    WebCore::Timer<CompositingCoordinator> m_releaseInactiveAtlasesTimer;

    bool m_layerFlushSchedulingEnabled;

    uint64_t m_forceRepaintAsyncCallbackID;

    bool m_animationsLocked;

};

}

#endif

#endif // CompositingCoordinator_h

/*

 * Copyright (C) 2012 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 CompositingCoordinatorClient_h

#define CompositingCoordinatorClient_h

#if USE(COORDINATED_GRAPHICS)

#include "CoordinatedLayerInfo.h"

#include "ShareableSurface.h"

#include "SurfaceUpdateInfo.h"

#include <WebCore/GraphicsLayerAnimation.h>

#include <WebCore/IntRect.h>

#include <WebCore/IntSize.h>

#include <wtf/RefCounted.h>

#if USE(GRAPHICS_SURFACE)

#include <WebCore/GraphicsSurfaceToken.h>

#endif

#if ENABLE(CSS_FILTERS)

#include <WebCore/FilterOperation.h>

#endif

namespace WebKit {

class CompositingCoordinatorMessageClient {

public:

    virtual void setRootCompositingLayer(CoordinatedLayerID) = 0;

    virtual void setCompositingLayerState(CoordinatedLayerID, const CoordinatedLayerInfo&) = 0;

    virtual void setCompositingLayerChildren(CoordinatedLayerID, const Vector<CoordinatedLayerID>&) = 0;

#if ENABLE(CSS_FILTERS)

    virtual void setCompositingLayerFilters(CoordinatedLayerID, const WebCore::FilterOperations&) = 0;

#endif

    virtual void deleteCompositingLayer(CoordinatedLayerID) = 0;

    virtual void createTileForLayer(CoordinatedLayerID, uint32_t tileID, const WebCore::IntRect&, const SurfaceUpdateInfo&) = 0;

    virtual void updateTileForLayer(CoordinatedLayerID, uint32_t tileID, const WebCore::IntRect&, const SurfaceUpdateInfo&) = 0;

    virtual void removeTileForLayer(CoordinatedLayerID, uint32_t tileID) = 0;

    virtual void createUpdateAtlas(int atlasID, const ShareableSurface::Handle&) = 0;

    virtual void removeUpdateAtlas(int atlasID) = 0;

    virtual void createImageBacking(CoordinatedImageBackingID) = 0;

    virtual void updateImageBacking(CoordinatedImageBackingID, const ShareableSurface::Handle&) = 0;

    virtual void clearImageBackingContents(CoordinatedImageBackingID) = 0;

    virtual void removeImageBacking(CoordinatedImageBackingID) = 0;

    virtual void didRenderFrame(const WebCore::IntSize& contentsSize, const WebCore::IntRect& coveredRect) = 0;

    virtual void didChangeScrollPosition(const WebCore::IntPoint& position) = 0;

#if USE(GRAPHICS_SURFACE)

    virtual void createCanvas(CoordinatedLayerID, const WebCore::IntSize&, const WebCore::GraphicsSurfaceToken&) = 0;

    virtual void syncCanvas(CoordinatedLayerID, uint32_t frontBuffer) = 0;

    virtual void destroyCanvas(CoordinatedLayerID) = 0;

#endif

    virtual void setLayerAnimations(CoordinatedLayerID, const WebCore::GraphicsLayerAnimations&) = 0;

    virtual void setAnimationsLocked(bool) = 0;

};

class CompositingCoordinatorClient {

public:

    virtual const WebCore::IntSize& viewSize() const = 0;

    virtual void didPerformScheduledLayerFlush(bool didSync) = 0;

    virtual void layoutIfNeeded() = 0;

    virtual bool isOpaqueContents() = 0;

    virtual void paintContents(WebCore::GraphicsContext&, const WebCore::IntRect& clipRect) = 0;

    virtual void paintOverlayContents(WebCore::GraphicsContext&, const WebCore::IntRect& clipRect) = 0;

};

}

#endif

#endif // CompositingCoordinatorClient_h

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