Attachment 178863 Details for Bug 104360 – Rebase after r137293

[patch] Rebase after r137293

bug-104360-20121212062631.patch (text/plain), 111.45 KB, created by Gwang Yoon Hwang on 2012-12-11 13:29:07 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Gwang Yoon Hwang

Created: 2012-12-11 13:29:07 PST

Size: 111.45 KB

patch

obsolete

>Subversion Revision: 137342
>diff --git a/Source/WebKit2/ChangeLog b/Source/WebKit2/ChangeLog
>index 623284ba14fa5fe38cc42cfa6bb56d9a2f3c4360..e7c2397041321912f5c86ad351bec91a858c88fd 100644
>--- a/Source/WebKit2/ChangeLog
>+++ b/Source/WebKit2/ChangeLog
>@@ -1,3 +1,183 @@
>+2012-12-07  Gwang Yoon Hwang  <ryumiel@company100.net>
>+
>+        Coordinated Graphics: Separate LayerTreeCoordinator into LayerTreeCoordinator and CompositingCoordinator
>+        https://bugs.webkit.org/show_bug.cgi?id=104360
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Internal Review by Huang Dongsung and Jae Hyun Park.
>+
>+        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 creating a new class called CompositingCoordinator, which takes the
>+        responsibility of scheduling compositing tasks in WebProcess,
>+        LayerTreeCoordinator acts like a simple LayerTreeHost.
>+
>+        By extracting interfaces dealing with LayerTreeCoordinatorProxy to
>+        CompositingCoordinatorCommands, CompositingCoordinator is decoupled from
>+        IPC handling.
>+
>+        WebCompositingCoordinatorCommands implements IPC handling for
>+        CompositingCoordinator and LayerTreeCoordinator.
>+        WebCustomFilterProgramProxyClient is responsible 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::initializeRootCompositingLayerIfNeeded):
>+        (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):
>+        (CompositingCoordinatorClient):
>+        This interface provides a way to use LayerTreeCoordinator from
>+        Compositing Coordinator.
>+        * WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinatorCommands.h: Added.
>+        (WebKit):
>+        (CompositingCoordinatorCommands):
>+        This interface provides a way to send messages to renderer.
>+        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.cpp:
>+        (WebKit::CoordinatedLayerTreeHost::~CoordinatedLayerTreeHost):
>+        (WebKit::CoordinatedLayerTreeHost::CoordinatedLayerTreeHost):
>+        (WebKit::CoordinatedLayerTreeHost::setLayerFlushSchedulingEnabled):
>+        (WebKit::CoordinatedLayerTreeHost::scheduleLayerFlush):
>+        (WebKit::CoordinatedLayerTreeHost::setRootCompositingLayer):
>+        (WebKit::CoordinatedLayerTreeHost::invalidate):
>+        (WebKit::CoordinatedLayerTreeHost::setNonCompositedContentsNeedDisplay):
>+        (WebKit::CoordinatedLayerTreeHost::forceRepaint):
>+        (WebKit::CoordinatedLayerTreeHost::sizeDidChange):
>+        (WebKit::CoordinatedLayerTreeHost::didInstallPageOverlay):
>+        (WebKit::CoordinatedLayerTreeHost::didUninstallPageOverlay):
>+        (WebKit::CoordinatedLayerTreeHost::setPageOverlayNeedsDisplay):
>+        (WebKit::CoordinatedLayerTreeHost::setPageOverlayOpacity):
>+        (WebKit::CoordinatedLayerTreeHost::pauseRendering):
>+        (WebKit::CoordinatedLayerTreeHost::resumeRendering):
>+        (WebKit::CoordinatedLayerTreeHost::viewSize):
>+        (WebKit::CoordinatedLayerTreeHost::layoutIfNeeded):
>+        (WebKit::CoordinatedLayerTreeHost::isOpaqueContents):
>+        (WebKit::CoordinatedLayerTreeHost::didPerformScheduledLayerFlush):
>+        (WebKit::CoordinatedLayerTreeHost::paintContents):
>+        (WebKit::CoordinatedLayerTreeHost::paintOverlayContents):
>+        (WebKit::CoordinatedLayerTreeHost::hasPageOverlay):
>+        (WebKit::CoordinatedLayerTreeHost::setVisibleContentsRect):
>+        (WebKit::CoordinatedLayerTreeHost::graphicsLayerFactory):
>+        (WebKit::CoordinatedLayerTreeHost::scheduleAnimation):
>+        (WebKit::CoordinatedLayerTreeHost::renderNextFrame):
>+        (WebKit::CoordinatedLayerTreeHost::purgeBackingStores):
>+        (WebKit::CoordinatedLayerTreeHost::setBackgroundColor):
>+        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h:
>+        (WebCore):
>+        (CoordinatedLayerTreeHost):
>+        * WebProcess/WebPage/CoordinatedGraphics/WebCompositingCoordinatorCommands.cpp:
>+        Added. Manages sends actual IPC messages and manages
>+        WebCustomFilterProgram
>+        (WebKit):
>+        (WebKit::WebCompositingCoordinatorCommands::create):
>+        (WebKit::WebCompositingCoordinatorCommands::~WebCompositingCoordinatorCommands):
>+        (WebKit::WebCompositingCoordinatorCommands::WebCompositingCoordinatorCommands):
>+        (WebKit::WebCompositingCoordinatorCommands::setRootCompositingLayer):
>+        (WebKit::WebCompositingCoordinatorCommands::setCompositingLayerState):
>+        (WebKit::WebCompositingCoordinatorCommands::setCompositingLayerChildren):
>+        (WebKit::WebCompositingCoordinatorCommands::setCompositingLayerFilters):
>+        (WebKit::WebCompositingCoordinatorCommands::deleteCompositingLayer):
>+        (WebKit::WebCompositingCoordinatorCommands::createTileForLayer):
>+        (WebKit::WebCompositingCoordinatorCommands::updateTileForLayer):
>+        (WebKit::WebCompositingCoordinatorCommands::removeTileForLayer):
>+        (WebKit::WebCompositingCoordinatorCommands::createUpdateAtlas):
>+        (WebKit::WebCompositingCoordinatorCommands::removeUpdateAtlas):
>+        (WebKit::WebCompositingCoordinatorCommands::createImageBacking):
>+        (WebKit::WebCompositingCoordinatorCommands::updateImageBacking):
>+        (WebKit::WebCompositingCoordinatorCommands::clearImageBackingContents):
>+        (WebKit::WebCompositingCoordinatorCommands::removeImageBacking):
>+        (WebKit::WebCompositingCoordinatorCommands::didRenderFrame):
>+        (WebKit::WebCompositingCoordinatorCommands::didChangeScrollPosition):
>+        (WebKit::WebCompositingCoordinatorCommands::createCanvas):
>+        (WebKit::WebCompositingCoordinatorCommands::syncCanvas):
>+        (WebKit::WebCompositingCoordinatorCommands::destroyCanvas):
>+        (WebKit::WebCompositingCoordinatorCommands::setLayerAnimations):
>+        (WebKit::WebCompositingCoordinatorCommands::setAnimationsLocked):
>+        (WebKit::WebCompositingCoordinatorCommands::setBackgroundColor):
>+        (WebKit::WebCompositingCoordinatorCommands::requestAnimationFrame):
>+        (WebKit::WebCompositingCoordinatorCommands::invokeForceRepaintAsyncCallback):
>+        (WebKit::WebCompositingCoordinatorCommands::checkCustomFilterProgramProxies):
>+        (WebKit::WebCompositingCoordinatorCommands::removeCustomFilterProgramProxy):
>+        (WebKit::WebCompositingCoordinatorCommands::disconnectCustomFilterPrograms):
>+        * WebProcess/WebPage/CoordinatedGraphics/WebCompositingCoordinatorCommands.h: Added.
>+        (WebKit):
>+        (WebCompositingCoordinatorCommands):
>+
> 2012-12-11  Gwang Yoon Hwang  <ryumiel@company100.net>
> 
>         Coordinated Graphics: Rename LayerTreeCoordinator to CoordinatedLayerTreeHost
>diff --git a/Source/WebKit2/CMakeLists.txt b/Source/WebKit2/CMakeLists.txt
>index 243d90c5ef2457eddb54754e5ca9c9385075e9d9..1561d2a81b41856038c7a230999cdee5899cce01 100644
>--- a/Source/WebKit2/CMakeLists.txt
>+++ b/Source/WebKit2/CMakeLists.txt
>@@ -499,11 +499,13 @@ set(WebKit2_SOURCES
>     WebProcess/WebPage/WebUndoStep.cpp
> 
>     WebProcess/WebPage/CoordinatedGraphics/AreaAllocator.cpp
>+    WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.cpp
>     WebProcess/WebPage/CoordinatedGraphics/CoordinatedImageBacking.cpp
>     WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp
>     WebProcess/WebPage/CoordinatedGraphics/CoordinatedTile.cpp
>     WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.cpp
>     WebProcess/WebPage/CoordinatedGraphics/UpdateAtlas.cpp
>+    WebProcess/WebPage/CoordinatedGraphics/WebCompositingCoordinatorCommands.cpp
> )
> 
> set(WebKit2_MESSAGES_IN_FILES
>diff --git a/Source/WebKit2/Target.pri b/Source/WebKit2/Target.pri
>index 5833896a81100dc44ab8101a01374ac494ecfe52..e5bf2b74f822ba9ad55543d0031a8716338d1d73 100644
>--- a/Source/WebKit2/Target.pri
>+++ b/Source/WebKit2/Target.pri
>@@ -372,11 +372,15 @@ HEADERS += \
>     WebProcess/WebPage/EventDispatcher.h \
>     WebProcess/WebPage/FindController.h \
>     WebProcess/WebPage/CoordinatedGraphics/AreaAllocator.h \
>+    WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.h \
>+    WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinatorClient.h \
>+    WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinatorCommands.h \
>     WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.h \
>     WebProcess/WebPage/CoordinatedGraphics/CoordinatedImageBacking.h \
>     WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h \
>     WebProcess/WebPage/CoordinatedGraphics/CoordinatedTile.h \
>     WebProcess/WebPage/CoordinatedGraphics/UpdateAtlas.h \
>+    WebProcess/WebPage/CoordinatedGraphics/WebCompositingCoordinatorCommands.h \
>     WebProcess/WebPage/TapHighlightController.h \
>     WebProcess/WebPage/PageOverlay.h \
>     WebProcess/WebPage/WebContextMenu.h \
>@@ -758,11 +762,13 @@ SOURCES += \
>     WebProcess/WebPage/EventDispatcher.cpp \
>     WebProcess/WebPage/FindController.cpp \
>     WebProcess/WebPage/CoordinatedGraphics/AreaAllocator.cpp \
>+    WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.cpp \
>     WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp \
>     WebProcess/WebPage/CoordinatedGraphics/CoordinatedImageBacking.cpp \
>     WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.cpp \
>     WebProcess/WebPage/CoordinatedGraphics/CoordinatedTile.cpp \
>     WebProcess/WebPage/CoordinatedGraphics/UpdateAtlas.cpp \
>+    WebProcess/WebPage/CoordinatedGraphics/WebCompositingCoordinatorCommands.cpp \
>     WebProcess/WebPage/TapHighlightController.cpp \
>     WebProcess/WebPage/LayerTreeHost.cpp \
>     WebProcess/WebPage/PageOverlay.cpp \
>diff --git a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.cpp b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..e431061e160b571a580da03541c30b63d968b057
>--- /dev/null
>+++ b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.cpp
>@@ -0,0 +1,684 @@
>+/*
>+ * 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, CompositingCoordinatorCommands* commands)
>+{
>+    return adoptPtr(new CompositingCoordinator(page, client, commands));
>+}
>+
>+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, CompositingCoordinatorCommands* commands)
>+    : m_page(page)
>+    , m_client(client)
>+    , m_commands(commands)
>+    , m_isValid(true)
>+    , m_isPurging(false)
>+    , m_waitingForRenderer(true)
>+    , m_isSuspended(false)
>+    , m_contentsScale(1)
>+    , m_shouldSendScrollPositionUpdate(true)
>+    , m_shouldSyncFrame(false)
>+    , m_didInitializeRootCompositingLayer(false)
>+    , m_layerFlushTimer(this, &CompositingCoordinator::layerFlushTimerFired)
>+    , m_releaseInactiveAtlasesTimer(this, &CompositingCoordinator::releaseInactiveAtlasesTimerFired)
>+    , m_layerFlushSchedulingEnabled(true)
>+    , 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());
>+
>+    if (m_client->hasPageOverlay())
>+        createPageOverlayLayer();
>+
>+    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;
>+
>+    initializeRootCompositingLayerIfNeeded();
>+
>+    m_rootLayer->flushCompositingStateForThisLayerOnly();
>+    m_nonCompositedContentLayer->flushCompositingStateForThisLayerOnly();
>+    if (m_pageOverlayLayer)
>+        m_pageOverlayLayer->flushCompositingStateForThisLayerOnly();
>+
>+    bool didSync = m_page->mainFrame()->view()->flushCompositingStateIncludingSubframes();
>+
>+    flushPendingImageBackingChanges();
>+
>+    for (size_t i = 0; i < m_detachedLayers.size(); ++i)
>+        m_commands->deleteCompositingLayer(m_detachedLayers[i]);
>+    m_detachedLayers.clear();
>+
>+    if (m_shouldSyncFrame) {
>+        didSync = true;
>+
>+        IntSize contentsSize = roundedIntSize(m_nonCompositedContentLayer->size());
>+        IntRect coveredRect = toCoordinatedGraphicsLayer(m_nonCompositedContentLayer.get())->coverRect();
>+        m_commands->didRenderFrame(contentsSize, coveredRect);
>+        m_waitingForRenderer = true;
>+        m_shouldSyncFrame = false;
>+    } else
>+        unlockAnimations();
>+
>+    return didSync;
>+}
>+
>+void CompositingCoordinator::initializeRootCompositingLayerIfNeeded()
>+{
>+    if (m_didInitializeRootCompositingLayer)
>+        return;
>+
>+    m_commands->setRootCompositingLayer(toCoordinatedGraphicsLayer(m_rootLayer.get())->id());
>+    m_didInitializeRootCompositingLayer = true;
>+    m_shouldSyncFrame = true;
>+}
>+
>+void CompositingCoordinator::syncLayerState(CoordinatedLayerID id, const CoordinatedLayerInfo& info)
>+{
>+    if (m_shouldSendScrollPositionUpdate) {
>+        m_commands->didChangeScrollPosition(m_visibleContentsRect.location());
>+        m_shouldSendScrollPositionUpdate = false;
>+    }
>+
>+    m_shouldSyncFrame = true;
>+    m_commands->setCompositingLayerState(id, info);
>+}
>+
>+void CompositingCoordinator::syncLayerChildren(CoordinatedLayerID id, const Vector<CoordinatedLayerID>& children)
>+{
>+    m_shouldSyncFrame = true;
>+    m_commands->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_commands->createCanvas(id, canvasSize, token);
>+}
>+
>+void CompositingCoordinator::syncCanvas(CoordinatedLayerID id, PlatformLayer* canvasPlatformLayer)
>+{
>+    m_shouldSyncFrame = true;
>+    uint32_t frontBuffer = canvasPlatformLayer->copyToGraphicsSurface();
>+    m_commands->syncCanvas(id, frontBuffer);
>+}
>+
>+void CompositingCoordinator::destroyCanvas(CoordinatedLayerID id)
>+{
>+    if (m_isPurging)
>+        return;
>+
>+    m_shouldSyncFrame = true;
>+    m_commands->destroyCanvas(id);
>+}
>+#endif
>+
>+#if ENABLE(CSS_FILTERS)
>+void CompositingCoordinator::syncLayerFilters(CoordinatedLayerID id, const FilterOperations& filters)
>+{
>+    m_shouldSyncFrame = true;
>+    m_commands->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_commands->setAnimationsLocked(true);
>+}
>+
>+void CompositingCoordinator::unlockAnimations()
>+{
>+    if (!m_animationsLocked)
>+        return;
>+
>+    m_animationsLocked = false;
>+    m_commands->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_commands->createImageBacking(imageID);
>+}
>+
>+void CompositingCoordinator::updateImageBacking(CoordinatedImageBackingID imageID, const WebCoordinatedSurface::Handle& handle)
>+{
>+    m_shouldSyncFrame = true;
>+    m_commands->updateImageBacking(imageID, handle);
>+}
>+
>+void CompositingCoordinator::clearImageBackingContents(CoordinatedImageBackingID imageID)
>+{
>+    m_shouldSyncFrame = true;
>+    m_commands->clearImageBackingContents(imageID);
>+}
>+
>+void CompositingCoordinator::removeImageBacking(CoordinatedImageBackingID imageID)
>+{
>+    if (m_isPurging)
>+        return;
>+
>+    ASSERT(m_imageBackings.contains(imageID));
>+    m_shouldSyncFrame = true;
>+    m_imageBackings.remove(imageID);
>+    m_commands->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_commands->createTileForLayer(layerID, tileID, tileRect, updateInfo);
>+}
>+
>+void CompositingCoordinator::updateTile(CoordinatedLayerID layerID, uint32_t tileID, const SurfaceUpdateInfo& updateInfo, const IntRect& tileRect)
>+{
>+    m_shouldSyncFrame = true;
>+    m_commands->updateTileForLayer(layerID, tileID, tileRect, updateInfo);
>+}
>+
>+void CompositingCoordinator::removeTile(CoordinatedLayerID layerID, uint32_t tileID)
>+{
>+    if (m_isPurging)
>+        return;
>+    m_shouldSyncFrame = true;
>+    m_commands->removeTileForLayer(layerID, tileID);
>+}
>+
>+void CompositingCoordinator::createUpdateAtlas(uint32_t atlasID, const WebCoordinatedSurface::Handle& handle)
>+{
>+    m_commands->createUpdateAtlas(atlasID, handle);
>+}
>+
>+void CompositingCoordinator::removeUpdateAtlas(uint32_t atlasID)
>+{
>+    if (m_isPurging)
>+        return;
>+    m_commands->removeUpdateAtlas(atlasID);
>+}
>+
>+FloatRect CompositingCoordinator::visibleContentsRect() const
>+{
>+    return m_visibleContentsRect;
>+}
>+
>+void CompositingCoordinator::setLayerAnimations(CoordinatedLayerID layerID, const GraphicsLayerAnimations& animations)
>+{
>+    m_shouldSyncFrame = true;
>+    GraphicsLayerAnimations activeAnimations = animations.getActiveAnimations();
>+    m_commands->setLayerAnimations(layerID, activeAnimations);
>+}
>+
>+void CompositingCoordinator::setVisibleContentsRect(const FloatRect& 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 IntSize& size, CoordinatedSurface::Flags flags, uint32_t& atlasID, IntPoint& offset)
>+{
>+    OwnPtr<GraphicsContext> graphicsContext;
>+    for (unsigned i = 0; i < m_updateAtlases.size(); ++i) {
>+        UpdateAtlas* atlas = m_updateAtlases[i].get();
>+        if (atlas->supportsAlpha() == (flags & CoordinatedSurface::SupportsAlpha)) {
>+            // 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->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 WebKit
>+
>+#endif // USE(COORDINATED_GRAPHICS)
>diff --git a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.h b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..7381b7d283f4b1a8d80154b13d032fcb05ce3165
>--- /dev/null
>+++ b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.h
>@@ -0,0 +1,194 @@
>+/*
>+ * 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 "CompositingCoordinatorCommands.h"
>+#include "CoordinatedGraphicsLayer.h"
>+#include "CoordinatedImageBacking.h"
>+#include "UpdateAtlas.h"
>+#include "WebCoordinatedSurface.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*, CompositingCoordinatorCommands*);
>+    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::FloatRect&, 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::FloatRect 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&, CoordinatedSurface::Flags, uint32_t& atlasID, WebCore::IntPoint&);
>+
>+    // UpdateAtlasClient
>+    virtual void createUpdateAtlas(uint32_t atlasID, const WebCoordinatedSurface::Handle&);
>+    virtual void removeUpdateAtlas(uint32_t atlasID);
>+
>+    void renderNextFrame();
>+    void purgeBackingStores();
>+
>+    WebCore::GraphicsLayer* rootGraphicsLayer() const { return m_rootLayer.get(); }
>+
>+private:
>+    CompositingCoordinator(WebCore::Page*, CompositingCoordinatorClient*, CompositingCoordinatorCommands*);
>+
>+    // 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 WebCoordinatedSurface::Handle&) OVERRIDE;
>+    virtual void clearImageBackingContents(CoordinatedImageBackingID) OVERRIDE;
>+    virtual void removeImageBacking(CoordinatedImageBackingID) OVERRIDE;
>+
>+    void flushPendingImageBackingChanges();
>+
>+    // GraphicsLayerFactory
>+    virtual PassOwnPtr<WebCore::GraphicsLayer> createGraphicsLayer(WebCore::GraphicsLayerClient*) OVERRIDE;
>+
>+    // CompositingCoordinator
>+    void initializeRootCompositingLayerIfNeeded();
>+    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;
>+    CompositingCoordinatorCommands* m_commands;
>+
>+    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::FloatRect m_visibleContentsRect;
>+    float m_contentsScale;
>+    bool m_shouldSendScrollPositionUpdate;
>+
>+    bool m_shouldSyncFrame;
>+    bool m_didInitializeRootCompositingLayer;
>+    WebCore::Timer<CompositingCoordinator> m_layerFlushTimer;
>+    WebCore::Timer<CompositingCoordinator> m_releaseInactiveAtlasesTimer;
>+    bool m_layerFlushSchedulingEnabled;
>+    bool m_animationsLocked;
>+};
>+
>+}
>+
>+#endif
>+
>+#endif // CompositingCoordinator_h
>diff --git a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinatorClient.h b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinatorClient.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..d06fc503468e7bafc3781be1cfae9529ce93728e
>--- /dev/null
>+++ b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinatorClient.h
>@@ -0,0 +1,59 @@
>+/*
>+ * 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 <WebCore/GraphicsContext.h>
>+#include <WebCore/IntRect.h>
>+#include <wtf/RefCounted.h>
>+
>+#if ENABLE(CSS_FILTERS)
>+#include <WebCore/FilterOperation.h>
>+#endif
>+
>+namespace WebKit {
>+
>+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;
>+
>+    virtual bool hasPageOverlay() const = 0;
>+};
>+
>+}
>+#endif
>+
>+#endif // CompositingCoordinatorClient_h
>diff --git a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinatorCommands.h b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinatorCommands.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..c2b9872c833e75d7556a269514299cfae65d1637
>--- /dev/null
>+++ b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinatorCommands.h
>@@ -0,0 +1,87 @@
>+/*
>+ * 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 CompositingCoordinatorCommands_h
>+#define CompositingCoordinatorCommands_h
>+
>+#if USE(COORDINATED_GRAPHICS)
>+
>+#include "CoordinatedLayerInfo.h"
>+#include "SurfaceUpdateInfo.h"
>+#include "WebCoordinatedSurface.h"
>+#include <WebCore/FloatPoint.h>
>+#include <WebCore/GraphicsLayerAnimation.h>
>+#include <WebCore/IntRect.h>
>+#include <WebCore/IntSize.h>
>+
>+#if USE(GRAPHICS_SURFACE)
>+#include <WebCore/GraphicsSurfaceToken.h>
>+#endif
>+
>+#if ENABLE(CSS_FILTERS)
>+#include <WebCore/FilterOperation.h>
>+#endif
>+
>+namespace WebKit {
>+
>+class CompositingCoordinatorCommands {
>+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(uint32_t atlasID, const WebCoordinatedSurface::Handle&) = 0;
>+    virtual void removeUpdateAtlas(uint32_t atlasID) = 0;
>+
>+    virtual void createImageBacking(CoordinatedImageBackingID) = 0;
>+    virtual void updateImageBacking(CoordinatedImageBackingID, const WebCoordinatedSurface::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::FloatPoint& 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;
>+};
>+
>+}
>+#endif
>+
>+#endif // CompositingCoordinatorCommands_h
>diff --git a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.cpp b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.cpp
>index 9f44ebfc10cba9f7c76f861817aec2f7cd78d54b..718f824d8247328986f2927265ff8b398661ae08 100644
>--- a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.cpp
>+++ b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.cpp
>@@ -30,32 +30,10 @@
> #if USE(COORDINATED_GRAPHICS)
> #include "CoordinatedLayerTreeHost.h"
> 
>-#include "CoordinatedGraphicsArgumentCoders.h"
> #include "CoordinatedGraphicsLayer.h"
>-#include "CoordinatedLayerTreeHostProxyMessages.h"
> #include "DrawingAreaImpl.h"
> #include "GraphicsContext.h"
>-#include "MessageID.h"
>-#include "SurfaceUpdateInfo.h"
>-#include "WebCoreArgumentCoders.h"
> #include "WebPage.h"
>-#include "WebPageProxyMessages.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;
> 
>@@ -68,89 +46,28 @@ PassRefPtr<CoordinatedLayerTreeHost> CoordinatedLayerTreeHost::create(WebPage* w
> 
> CoordinatedLayerTreeHost::~CoordinatedLayerTreeHost()
> {
>-#if ENABLE(CSS_SHADERS)
>-    disconnectCustomFilterPrograms();
>-#endif
>-
>-    // Prevent setCoordinatedGraphicsLayerClient(0) -> detachLayer() from modifying the set while we iterate it.
>-    HashSet<WebCore::CoordinatedGraphicsLayer*> registeredLayers;
>-    registeredLayers.swap(m_registeredLayers);
>-
>-    HashSet<WebCore::CoordinatedGraphicsLayer*>::iterator end = registeredLayers.end();
>-    for (HashSet<WebCore::CoordinatedGraphicsLayer*>::iterator it = registeredLayers.begin(); it != end; ++it)
>-        (*it)->setCoordinator(0);
> }
> 
> CoordinatedLayerTreeHost::CoordinatedLayerTreeHost(WebPage* webPage)
>     : LayerTreeHost(webPage)
>     , m_notifyAfterScheduledLayerFlush(false)
>-    , m_isValid(true)
>-    , m_isPurging(false)
>-    , m_waitingForUIProcess(true)
>-    , m_isSuspended(false)
>-    , m_contentsScale(1)
>-    , m_shouldSendScrollPositionUpdate(true)
>-    , m_shouldSyncFrame(false)
>-    , m_didInitializeRootCompositingLayer(false)
>-    , m_layerFlushTimer(this, &CoordinatedLayerTreeHost::layerFlushTimerFired)
>-    , m_releaseInactiveAtlasesTimer(this, &CoordinatedLayerTreeHost::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("CoordinatedLayerTreeHost root layer");
>-#endif
>-    m_rootLayer->setDrawsContent(false);
>-    m_rootLayer->setSize(m_webPage->size());
>-    m_layerTreeContext.coordinatedLayerID = toCoordinatedGraphicsLayer(coordinatedRootLayer)->id();
>-
>-    m_nonCompositedContentLayer = GraphicsLayer::create(this, this);
>-#ifndef NDEBUG
>-    m_nonCompositedContentLayer->setName("CoordinatedLayerTreeHost non-composited content");
>-#endif
>-    m_nonCompositedContentLayer->setDrawsContent(true);
>-    m_nonCompositedContentLayer->setSize(m_webPage->size());
>-
>-    m_rootLayer->addChild(m_nonCompositedContentLayer.get());
>-
>-    if (m_webPage->hasPageOverlay())
>-        createPageOverlayLayer();
>+{
>+    m_compositingCoordinatorCommands = WebCompositingCoordinatorCommands::create(m_webPage);
>+    m_compositingCoordinator = CompositingCoordinator::create(m_webPage->corePage(), this, m_compositingCoordinatorCommands.get());
> 
>-    scheduleLayerFlush();
>+    CoordinatedGraphicsLayer* rootLayer = toCoordinatedGraphicsLayer(m_compositingCoordinator->rootGraphicsLayer());
>+    m_layerTreeContext.coordinatedLayerID = rootLayer->id();
> }
> 
> void CoordinatedLayerTreeHost::setLayerFlushSchedulingEnabled(bool layerFlushingEnabled)
> {
>-    if (m_layerFlushSchedulingEnabled == layerFlushingEnabled)
>-        return;
>-
>-    m_layerFlushSchedulingEnabled = layerFlushingEnabled;
>-
>-    if (m_layerFlushSchedulingEnabled) {
>-        scheduleLayerFlush();
>-        return;
>-    }
>-
>-    cancelPendingLayerFlush();
>+    m_compositingCoordinator->setLayerFlushSchedulingEnabled(layerFlushingEnabled);
> }
> 
> void CoordinatedLayerTreeHost::scheduleLayerFlush()
> {
>-    if (!m_layerFlushSchedulingEnabled)
>-        return;
>-
>-    if (!m_layerFlushTimer.isActive())
>-        m_layerFlushTimer.startOneShot(0);
>-}
>-
>-void CoordinatedLayerTreeHost::cancelPendingLayerFlush()
>-{
>-    m_layerFlushTimer.stop();
>+    m_compositingCoordinator->scheduleLayerFlush();
> }
> 
> void CoordinatedLayerTreeHost::setShouldNotifyAfterNextScheduledLayerFlush(bool notifyAfterScheduledLayerFlush)
>@@ -160,30 +77,17 @@ void CoordinatedLayerTreeHost::setShouldNotifyAfterNextScheduledLayerFlush(bool
> 
> void CoordinatedLayerTreeHost::setRootCompositingLayer(WebCore::GraphicsLayer* graphicsLayer)
> {
>-    m_nonCompositedContentLayer->removeAllChildren();
>-    m_nonCompositedContentLayer->setContentsOpaque(m_webPage->drawsBackground() && !m_webPage->drawsTransparentBackground());
>-
>-    // Add the accelerated layer tree hierarchy.
>-    if (graphicsLayer)
>-        m_nonCompositedContentLayer->addChild(graphicsLayer);
>+    m_compositingCoordinator->setRootCompositingLayer(graphicsLayer);
> }
> 
> void CoordinatedLayerTreeHost::invalidate()
> {
>-    cancelPendingLayerFlush();
>-
>-    ASSERT(m_isValid);
>-    m_rootLayer = nullptr;
>-    m_isValid = false;
>+    m_compositingCoordinator->invalidate();
> }
> 
> void CoordinatedLayerTreeHost::setNonCompositedContentsNeedDisplay(const WebCore::IntRect& rect)
> {
>-    m_nonCompositedContentLayer->setNeedsDisplayInRect(rect);
>-    if (m_pageOverlayLayer)
>-        m_pageOverlayLayer->setNeedsDisplayInRect(rect);
>-
>-    scheduleLayerFlush();
>+    m_compositingCoordinator->setNeedsDisplayInRect(rect);
> }
> 
> void CoordinatedLayerTreeHost::scrollNonCompositedContents(const WebCore::IntRect& scrollRect, const WebCore::IntSize& /* scrollOffset */)
>@@ -193,14 +97,7 @@ void CoordinatedLayerTreeHost::scrollNonCompositedContents(const WebCore::IntRec
> 
> void CoordinatedLayerTreeHost::forceRepaint()
> {
>-    // 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.
>-    syncDisplayState();
>-
>-    // We need to schedule another flush, otherwise the forced paint might cancel a later expected flush.
>-    // This is aligned with LayerTreeHostCA.
>-    scheduleLayerFlush();
>-    flushPendingLayerChanges();
>+    m_compositingCoordinator->forceRepaint();
> }
> 
> bool CoordinatedLayerTreeHost::forceRepaintAsync(uint64_t callbackID)
>@@ -214,431 +111,82 @@ bool CoordinatedLayerTreeHost::forceRepaintAsync(uint64_t callbackID)
> 
> void CoordinatedLayerTreeHost::sizeDidChange(const WebCore::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();
>+    m_compositingCoordinator->sizeDidChange(newSize);
> }
> 
> void CoordinatedLayerTreeHost::didInstallPageOverlay()
> {
>-    createPageOverlayLayer();
>-    scheduleLayerFlush();
>+    m_compositingCoordinator->createPageOverlayLayer();
> }
> 
> void CoordinatedLayerTreeHost::didUninstallPageOverlay()
> {
>-    destroyPageOverlayLayer();
>-    scheduleLayerFlush();
>+    m_compositingCoordinator->destroyPageOverlayLayer();
> }
> 
> void CoordinatedLayerTreeHost::setPageOverlayNeedsDisplay(const WebCore::IntRect& rect)
> {
>-    ASSERT(m_pageOverlayLayer);
>-    m_pageOverlayLayer->setNeedsDisplayInRect(rect);
>-    scheduleLayerFlush();
>+    m_compositingCoordinator->setPageOverlayNeedsDisplay(rect);
> }
> 
> void CoordinatedLayerTreeHost::setPageOverlayOpacity(float value)
> {
>-    ASSERT(m_pageOverlayLayer);
>-    m_pageOverlayLayer->setOpacity(value);
>-    scheduleLayerFlush();
>-}
>-
>-bool CoordinatedLayerTreeHost::flushPendingLayerChanges()
>-{
>-    if (m_waitingForUIProcess)
>-        return false;
>-
>-    initializeRootCompositingLayerIfNeeded();
>-
>-    m_rootLayer->flushCompositingStateForThisLayerOnly();
>-    m_nonCompositedContentLayer->flushCompositingStateForThisLayerOnly();
>-    if (m_pageOverlayLayer)
>-        m_pageOverlayLayer->flushCompositingStateForThisLayerOnly();
>-
>-    bool didSync = m_webPage->corePage()->mainFrame()->view()->flushCompositingStateIncludingSubframes();
>-
>-    flushPendingImageBackingChanges();
>-
>-    for (size_t i = 0; i < m_detachedLayers.size(); ++i)
>-        m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::DeleteCompositingLayer(m_detachedLayers[i]));
>-    m_detachedLayers.clear();
>-
>-    if (m_shouldSyncFrame) {
>-        didSync = true;
>-
>-        IntSize contentsSize = roundedIntSize(m_nonCompositedContentLayer->size());
>-        IntRect coveredRect = toCoordinatedGraphicsLayer(m_nonCompositedContentLayer.get())->coverRect();
>-        m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::DidRenderFrame(contentsSize, coveredRect));
>-        m_waitingForUIProcess = true;
>-        m_shouldSyncFrame = false;
>-    } else
>-        unlockAnimations();
>-
>-    if (m_forceRepaintAsyncCallbackID) {
>-        m_webPage->send(Messages::WebPageProxy::VoidCallback(m_forceRepaintAsyncCallbackID));
>-        m_forceRepaintAsyncCallbackID = 0;
>-    }
>-
>-    return didSync;
>-}
>-
>-void CoordinatedLayerTreeHost::initializeRootCompositingLayerIfNeeded()
>-{
>-    if (m_didInitializeRootCompositingLayer)
>-        return;
>-
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::SetRootCompositingLayer(toCoordinatedGraphicsLayer(m_rootLayer.get())->id()));
>-    m_didInitializeRootCompositingLayer = true;
>-    m_shouldSyncFrame = true;
>+    m_compositingCoordinator->setPageOverlayOpacity(value);
> }
> 
>-void CoordinatedLayerTreeHost::syncLayerState(CoordinatedLayerID id, const CoordinatedLayerInfo& info)
>+void CoordinatedLayerTreeHost::pauseRendering()
> {
>-    if (m_shouldSendScrollPositionUpdate) {
>-        m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::DidChangeScrollPosition(m_visibleContentsRect.location()));
>-        m_shouldSendScrollPositionUpdate = false;
>-    }
>-
>-    m_shouldSyncFrame = true;
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::SetCompositingLayerState(id, info));
>+    m_compositingCoordinator->pauseRendering();
> }
> 
>-void CoordinatedLayerTreeHost::syncLayerChildren(CoordinatedLayerID id, const Vector<CoordinatedLayerID>& children)
>+void CoordinatedLayerTreeHost::resumeRendering()
> {
>-    m_shouldSyncFrame = true;
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::SetCompositingLayerChildren(id, children));
>+    m_compositingCoordinator->resumeRendering();
> }
> 
>-#if USE(GRAPHICS_SURFACE)
>-void CoordinatedLayerTreeHost::createCanvas(CoordinatedLayerID id, PlatformLayer* canvasPlatformLayer)
>+const IntSize& CoordinatedLayerTreeHost::viewSize() const
> {
>-    m_shouldSyncFrame = true;
>-    GraphicsSurfaceToken token = canvasPlatformLayer->graphicsSurfaceToken();
>-    IntSize canvasSize = canvasPlatformLayer->platformLayerSize();
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::CreateCanvas(id, canvasSize, token));
>+    return m_webPage->size();
> }
> 
>-void CoordinatedLayerTreeHost::syncCanvas(CoordinatedLayerID id, PlatformLayer* canvasPlatformLayer)
>+void CoordinatedLayerTreeHost::layoutIfNeeded()
> {
>-    m_shouldSyncFrame = true;
>-    uint32_t frontBuffer = canvasPlatformLayer->copyToGraphicsSurface();
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::SyncCanvas(id, frontBuffer));
>+    m_webPage->layoutIfNeeded();
> }
> 
>-void CoordinatedLayerTreeHost::destroyCanvas(CoordinatedLayerID id)
>+bool CoordinatedLayerTreeHost::isOpaqueContents()
> {
>-    if (m_isPurging)
>-        return;
>-
>-    m_shouldSyncFrame = true;
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::DestroyCanvas(id));
>+    return m_webPage->drawsBackground() && !m_webPage->drawsTransparentBackground();
> }
>-#endif
> 
>-#if ENABLE(CSS_FILTERS)
>-void CoordinatedLayerTreeHost::syncLayerFilters(CoordinatedLayerID id, const FilterOperations& filters)
>+void CoordinatedLayerTreeHost::didPerformScheduledLayerFlush(bool didSync)
> {
>-    m_shouldSyncFrame = true;
>-#if ENABLE(CSS_SHADERS)
>-    checkCustomFilterProgramProxies(filters);
>-#endif
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::SetCompositingLayerFilters(id, filters));
>-}
>-#endif
>-
>-#if ENABLE(CSS_SHADERS)
>-void CoordinatedLayerTreeHost::checkCustomFilterProgramProxies(const FilterOperations& filters)
>-{
>-    // We need to create the WebCustomFilterProgramProxy objects before we get to serialize the
>-    // custom filters to the other process. That's because WebCustomFilterProgramProxy needs
>-    // to link back to the coordinator, so that we can send a message to the UI process when
>-    // the program is not needed anymore.
>-    // Note that the serialization will only happen at a later time in ArgumentCoder<WebCore::FilterOperations>::encode.
>-    // At that point the program will only be serialized once. All the other times it will only use the ID of the program.
>-    for (size_t i = 0; i < filters.size(); ++i) {
>-        const FilterOperation* operation = filters.at(i);
>-        if (operation->getOperationType() != FilterOperation::VALIDATED_CUSTOM)
>-            continue;
>-        const ValidatedCustomFilterOperation* customOperation = static_cast<const ValidatedCustomFilterOperation*>(operation);
>-        ASSERT(customOperation->validatedProgram()->isInitialized());
>-        TextureMapperPlatformCompiledProgram* program = customOperation->validatedProgram()->platformCompiledProgram();
>-
>-        RefPtr<WebCustomFilterProgramProxy> customFilterProgramProxy;
>-        if (program->client())
>-            customFilterProgramProxy = static_cast<WebCustomFilterProgramProxy*>(program->client());
>-        else {
>-            customFilterProgramProxy = WebCustomFilterProgramProxy::create();
>-            program->setClient(customFilterProgramProxy);
>-        }
>-
>-        if (!customFilterProgramProxy->client()) {
>-            customFilterProgramProxy->setClient(this);
>-            m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::CreateCustomFilterProgram(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);
>-        }
>+    if (m_forceRepaintAsyncCallbackID) {
>+        m_compositingCoordinatorCommands->invokeForceRepaintAsyncCallback(m_forceRepaintAsyncCallbackID);
>+        m_forceRepaintAsyncCallbackID = 0;
>     }
>-}
>-
>-void CoordinatedLayerTreeHost::removeCustomFilterProgramProxy(WebCustomFilterProgramProxy* customFilterProgramProxy)
>-{
>-    // 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_webPage->send(Messages::CoordinatedLayerTreeHostProxy::RemoveCustomFilterProgram(customFilterProgramProxy->id()));
>-}
>-
>-void CoordinatedLayerTreeHost::disconnectCustomFilterPrograms()
>-{
>-    // Make sure that WebCore will not call into this coordinator anymore.
>-    HashSet<WebCustomFilterProgramProxy*>::iterator iter = m_customFilterPrograms.begin();
>-    for (; iter != m_customFilterPrograms.end(); ++iter)
>-        (*iter)->setClient(0);
>-}
>-#endif
>-
>-void CoordinatedLayerTreeHost::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 CoordinatedLayerTreeHost::syncFixedLayers()
>-{
>-    if (!m_webPage->corePage()->settings() || !m_webPage->corePage()->settings()->acceleratedCompositingForFixedPositionEnabled())
>-        return;
>-
>-    if (!m_webPage->mainFrame()->view()->hasViewportConstrainedObjects())
>-        return;
>-
>-    RenderLayer* rootRenderLayer = m_webPage->mainFrame()->contentRenderer()->compositor()->rootRenderLayer();
>-    ASSERT(rootRenderLayer);
>-    if (rootRenderLayer->firstChild())
>-        updateOffsetFromViewportForLayer(rootRenderLayer->firstChild());
>-}
>-
>-void CoordinatedLayerTreeHost::lockAnimations()
>-{
>-    m_animationsLocked = true;
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::SetAnimationsLocked(true));
>-}
>-
>-void CoordinatedLayerTreeHost::unlockAnimations()
>-{
>-    if (!m_animationsLocked)
>-        return;
>-
>-    m_animationsLocked = false;
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::SetAnimationsLocked(false));
>-}
>-
>-void CoordinatedLayerTreeHost::performScheduledLayerFlush()
>-{
>-    if (m_isSuspended || m_waitingForUIProcess)
>-        return;
>-
>-    // We lock the animations while performing layout, to avoid flickers caused by animations continuing in the UI process 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;
>-
>-    if (flushPendingLayerChanges())
>-        didPerformScheduledLayerFlush();
>-}
>-
>-void CoordinatedLayerTreeHost::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_webPage->corePage()->mainFrame()->view()->serviceScriptedAnimations(convertSecondsToDOMTimeStamp(currentTime()));
>-#endif
>-
>-    m_webPage->layoutIfNeeded();
>-}
>-
>-void CoordinatedLayerTreeHost::didPerformScheduledLayerFlush()
>-{
>-    if (m_notifyAfterScheduledLayerFlush) {
>+    if (didSync && m_notifyAfterScheduledLayerFlush) {
>         static_cast<DrawingAreaImpl*>(m_webPage->drawingArea())->layerHostDidFlushLayers();
>         m_notifyAfterScheduledLayerFlush = false;
>     }
> }
> 
>-void CoordinatedLayerTreeHost::layerFlushTimerFired(Timer<CoordinatedLayerTreeHost>*)
>-{
>-    performScheduledLayerFlush();
>-}
>-
>-void CoordinatedLayerTreeHost::createPageOverlayLayer()
>-{
>-    ASSERT(!m_pageOverlayLayer);
>-
>-    m_pageOverlayLayer = GraphicsLayer::create(this, this);
>-#ifndef NDEBUG
>-    m_pageOverlayLayer->setName("CoordinatedLayerTreeHost page overlay content");
>-#endif
>-
>-    m_pageOverlayLayer->setDrawsContent(true);
>-    m_pageOverlayLayer->setSize(m_webPage->size());
>-
>-    m_rootLayer->addChild(m_pageOverlayLayer.get());
>-}
>-
>-void CoordinatedLayerTreeHost::destroyPageOverlayLayer()
>-{
>-    ASSERT(m_pageOverlayLayer);
>-    m_pageOverlayLayer->removeFromParent();
>-    m_pageOverlayLayer = nullptr;
>-}
>-
>-PassRefPtr<CoordinatedImageBacking> CoordinatedLayerTreeHost::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 CoordinatedLayerTreeHost::createImageBacking(CoordinatedImageBackingID imageID)
>-{
>-    m_shouldSyncFrame = true;
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::CreateImageBacking(imageID));
>-}
>-
>-void CoordinatedLayerTreeHost::updateImageBacking(CoordinatedImageBackingID imageID, const WebCoordinatedSurface::Handle& handle)
>-{
>-    m_shouldSyncFrame = true;
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::UpdateImageBacking(imageID, handle));
>-}
>-
>-void CoordinatedLayerTreeHost::clearImageBackingContents(CoordinatedImageBackingID imageID)
>-{
>-    m_shouldSyncFrame = true;
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::ClearImageBackingContents(imageID));
>-}
>-
>-void CoordinatedLayerTreeHost::removeImageBacking(CoordinatedImageBackingID imageID)
>-{
>-    if (m_isPurging)
>-        return;
>-
>-    ASSERT(m_imageBackings.contains(imageID));
>-    m_shouldSyncFrame = true;
>-    m_imageBackings.remove(imageID);
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::RemoveImageBacking(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::paintContents(WebCore::GraphicsContext& graphicsContext, const IntRect& clipRect)
> {
>+    m_webPage->drawRect(graphicsContext, clipRect);
> }
> 
>-void CoordinatedLayerTreeHost::notifyFlushRequired(const WebCore::GraphicsLayer*)
>+void CoordinatedLayerTreeHost::paintOverlayContents(WebCore::GraphicsContext& graphicsContext, const IntRect& clipRect)
> {
>+    // Overlays contain transparent contents and won't clear the context as part of their rendering, so we do it here.
>+    graphicsContext.clearRect(clipRect);
>+    m_webPage->drawPageOverlay(graphicsContext, clipRect);
> }
> 
>-void CoordinatedLayerTreeHost::paintContents(const WebCore::GraphicsLayer* graphicsLayer, WebCore::GraphicsContext& graphicsContext, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& clipRect)
>-{
>-    if (graphicsLayer == m_nonCompositedContentLayer) {
>-        m_webPage->drawRect(graphicsContext, clipRect);
>-        return;
>-    }
>-
>-    if (graphicsLayer == m_pageOverlayLayer) {
>-        // Overlays contain transparent contents and won't clear the context as part of their rendering, so we do it here.
>-        graphicsContext.clearRect(clipRect);
>-        m_webPage->drawPageOverlay(graphicsContext, clipRect);
>-        return;
>-    }
>-}
>-
>-PassOwnPtr<GraphicsLayer> CoordinatedLayerTreeHost::createGraphicsLayer(GraphicsLayerClient* client)
>+bool CoordinatedLayerTreeHost::hasPageOverlay() const
> {
>-    CoordinatedGraphicsLayer* layer = new CoordinatedGraphicsLayer(client);
>-    layer->setCoordinator(this);
>-    m_registeredLayers.add(layer);
>-    layer->setContentsScale(m_contentsScale);
>-    layer->adjustVisibleRect();
>-    return adoptPtr(layer);
>+    return m_webPage->hasPageOverlay();
> }
> 
> bool LayerTreeHost::supportsAcceleratedCompositing()
>@@ -646,103 +194,26 @@ bool LayerTreeHost::supportsAcceleratedCompositing()
>     return true;
> }
> 
>-void CoordinatedLayerTreeHost::createTile(CoordinatedLayerID layerID, uint32_t tileID, const SurfaceUpdateInfo& updateInfo, const WebCore::IntRect& tileRect)
>-{
>-    m_shouldSyncFrame = true;
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::CreateTileForLayer(layerID, tileID, tileRect, updateInfo));
>-}
>-
>-void CoordinatedLayerTreeHost::updateTile(CoordinatedLayerID layerID, uint32_t tileID, const SurfaceUpdateInfo& updateInfo, const WebCore::IntRect& tileRect)
>-{
>-    m_shouldSyncFrame = true;
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::UpdateTileForLayer(layerID, tileID, tileRect, updateInfo));
>-}
>-
>-void CoordinatedLayerTreeHost::removeTile(CoordinatedLayerID layerID, uint32_t tileID)
>-{
>-    if (m_isPurging)
>-        return;
>-    m_shouldSyncFrame = true;
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::RemoveTileForLayer(layerID, tileID));
>-}
>-
>-void CoordinatedLayerTreeHost::createUpdateAtlas(uint32_t atlasID, const WebCoordinatedSurface::Handle& handle)
>-{
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::CreateUpdateAtlas(atlasID, handle));
>-}
>-
>-void CoordinatedLayerTreeHost::removeUpdateAtlas(uint32_t atlasID)
>-{
>-    if (m_isPurging)
>-        return;
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::RemoveUpdateAtlas(atlasID));
>-}
>-
>-WebCore::FloatRect CoordinatedLayerTreeHost::visibleContentsRect() const
>-{
>-    return m_visibleContentsRect;
>-}
>-
>-
>-void CoordinatedLayerTreeHost::setLayerAnimations(CoordinatedLayerID layerID, const GraphicsLayerAnimations& animations)
>-{
>-    m_shouldSyncFrame = true;
>-    GraphicsLayerAnimations activeAnimations = animations.getActiveAnimations();
>-#if ENABLE(CSS_SHADERS)
>-    for (size_t i = 0; i < activeAnimations.animations().size(); ++i) {
>-        const KeyframeValueList& keyframes = animations.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(i));
>-            checkCustomFilterProgramProxies(*filterValue->value());
>-        }
>-    }
>-#endif
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::SetLayerAnimations(layerID, activeAnimations));
>-}
>-
> void CoordinatedLayerTreeHost::setVisibleContentsRect(const FloatRect& 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;
>+    m_compositingCoordinator->setVisibleContentsRect(rect, scale, trajectoryVector);
> 
>-        HashSet<WebCore::CoordinatedGraphicsLayer*>::iterator end = m_registeredLayers.end();
>-        for (HashSet<WebCore::CoordinatedGraphicsLayer*>::iterator it = m_registeredLayers.begin(); it != end; ++it) {
>-            if (contentsScaleDidChange)
>-                (*it)->setContentsScale(scale);
>-            if (contentsRectDidChange)
>-                (*it)->adjustVisibleRect();
>-        }
>-    }
>-
>-    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));
>     }
>-
>-    if (contentsRectDidChange)
>-        m_shouldSendScrollPositionUpdate = true;
> }
> 
> GraphicsLayerFactory* CoordinatedLayerTreeHost::graphicsLayerFactory()
> {
>-    return this;
>+    return m_compositingCoordinator.get();
> }
> 
> #if ENABLE(REQUEST_ANIMATION_FRAME)
> void CoordinatedLayerTreeHost::scheduleAnimation()
> {
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::RequestAnimationFrame());
>+    m_compositingCoordinatorCommands->requestAnimationFrame();
> }
> 
> void CoordinatedLayerTreeHost::animationFrameReady()
>@@ -753,84 +224,17 @@ void CoordinatedLayerTreeHost::animationFrameReady()
> 
> void CoordinatedLayerTreeHost::renderNextFrame()
> {
>-    m_waitingForUIProcess = false;
>-    scheduleLayerFlush();
>-    for (unsigned i = 0; i < m_updateAtlases.size(); ++i)
>-        m_updateAtlases[i]->didSwapBuffers();
>-}
>-
>-bool CoordinatedLayerTreeHost::layerTreeTileUpdatesAllowed() const
>-{
>-    return !m_isSuspended && !m_waitingForUIProcess;
>+    m_compositingCoordinator->renderNextFrame();
> }
> 
> void CoordinatedLayerTreeHost::purgeBackingStores()
> {
>-    TemporaryChange<bool> purgingToggle(m_isPurging, true);
>-
>-    HashSet<WebCore::CoordinatedGraphicsLayer*>::iterator end = m_registeredLayers.end();
>-    for (HashSet<WebCore::CoordinatedGraphicsLayer*>::iterator it = m_registeredLayers.begin(); it != end; ++it)
>-        (*it)->purgeBackingStores();
>-
>-    m_imageBackings.clear();
>-    m_updateAtlases.clear();
>-}
>-
>-PassOwnPtr<GraphicsContext> CoordinatedLayerTreeHost::beginContentUpdate(const IntSize& size, CoordinatedSurface::Flags flags, uint32_t& atlasID, IntPoint& offset)
>-{
>-    OwnPtr<GraphicsContext> graphicsContext;
>-    for (unsigned i = 0; i < m_updateAtlases.size(); ++i) {
>-        UpdateAtlas* atlas = m_updateAtlases[i].get();
>-        if (atlas->supportsAlpha() == (flags & CoordinatedSurface::SupportsAlpha)) {
>-            // 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 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();
>+    m_compositingCoordinator->purgeBackingStores();
> }
> 
> void CoordinatedLayerTreeHost::setBackgroundColor(const WebCore::Color& color)
> {
>-    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::SetBackgroundColor(color));
>+    m_compositingCoordinatorCommands->setBackgroundColor(color);
> }
> 
> } // namespace WebKit
>diff --git a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h
>index 0c68bb51e17f4b38019d4d7896b60de450538eaa..aff9af9555b14d01b8b061faccfd89d48b56655c 100644
>--- a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h
>+++ b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h
>@@ -1,5 +1,6 @@
> /*
>     Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies)
>+    Copyright (C) 2012 Company 100, Inc. All rights reserved.
> 
>     This library is free software; you can redistribute it and/or
>     modify it under the terms of the GNU Library General Public
>@@ -22,39 +23,27 @@
> 
> #if USE(COORDINATED_GRAPHICS)
> 
>-#include "CoordinatedGraphicsLayer.h"
>-#include "CoordinatedImageBacking.h"
>+#include "CompositingCoordinator.h"
> #include "LayerTreeContext.h"
> #include "LayerTreeHost.h"
>-#include "Timer.h"
>-#include "UpdateAtlas.h"
>-#include "WebCoordinatedSurface.h"
>-#include <WebCore/GraphicsLayerClient.h>
>-#include <WebCore/GraphicsLayerFactory.h>
>+#include "WebCompositingCoordinatorCommands.h"
> #include <wtf/OwnPtr.h>
>+#include <wtf/RefPtr.h>
> 
>-#if ENABLE(CSS_SHADERS)
>-#include "WebCustomFilterProgramProxy.h"
>-#endif
>+namespace WebCore {
>+class GraphicsLayerFactory;
>+}
> 
> namespace WebKit {
> 
>-class UpdateInfo;
> class WebPage;
> 
>-class CoordinatedLayerTreeHost : public LayerTreeHost, WebCore::GraphicsLayerClient
>-    , public CoordinatedGraphicsLayerClient
>-    , public CoordinatedImageBacking::Coordinator
>-    , public UpdateAtlasClient
>-    , public WebCore::GraphicsLayerFactory
>-#if ENABLE(CSS_SHADERS)
>-    , WebCustomFilterProgramProxyClient
>-#endif
>-{
>+class CoordinatedLayerTreeHost : public LayerTreeHost, public CompositingCoordinatorClient {
> public:
>     static PassRefPtr<CoordinatedLayerTreeHost> create(WebPage*);
>     virtual ~CoordinatedLayerTreeHost();
> 
>+    // Reimplementations from LayerTreeHost
>     virtual const LayerTreeContext& layerTreeContext() { return m_layerTreeContext; }
>     virtual void setLayerFlushSchedulingEnabled(bool);
>     virtual void scheduleLayerFlush();
>@@ -74,133 +63,44 @@ public:
>     virtual void setPageOverlayOpacity(float);
>     virtual bool pageOverlayShouldApplyFadeWhenPainting() const { return false; }
> 
>-    virtual void pauseRendering() { m_isSuspended = true; }
>-    virtual void resumeRendering() { m_isSuspended = false; scheduleLayerFlush(); }
>+    virtual void pauseRendering();
>+    virtual void resumeRendering();
>     virtual void deviceScaleFactorDidChange() { }
>-    virtual PassRefPtr<CoordinatedImageBacking> createImageBackingIfNeeded(WebCore::Image*) OVERRIDE;
> 
>-    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);
>-    virtual WebCore::FloatRect visibleContentsRect() const;
>     virtual void renderNextFrame();
>     virtual void purgeBackingStores();
>-    virtual bool layerTreeTileUpdatesAllowed() const;
>     virtual void setVisibleContentsRect(const WebCore::FloatRect&, float scale, const WebCore::FloatPoint&);
>     virtual void didReceiveCoordinatedLayerTreeHostMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::MessageDecoder&);
>     virtual WebCore::GraphicsLayerFactory* graphicsLayerFactory() OVERRIDE;
>-
>-    virtual void syncLayerState(CoordinatedLayerID, const CoordinatedLayerInfo&);
>-    virtual void syncLayerChildren(CoordinatedLayerID, const Vector<CoordinatedLayerID>&);
>-    virtual void setLayerAnimations(CoordinatedLayerID, const WebCore::GraphicsLayerAnimations&);
>-#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 detachLayer(WebCore::CoordinatedGraphicsLayer*);
>-    virtual void syncFixedLayers();
>-
>-    virtual PassOwnPtr<WebCore::GraphicsContext> beginContentUpdate(const WebCore::IntSize&, CoordinatedSurface::Flags, uint32_t& atlasID, WebCore::IntPoint&);
>-
>-    // UpdateAtlasClient
>-    virtual void createUpdateAtlas(uint32_t atlasID, const WebCoordinatedSurface::Handle&);
>-    virtual void removeUpdateAtlas(uint32_t atlasID);
>-
> #if ENABLE(REQUEST_ANIMATION_FRAME)
>     virtual void scheduleAnimation() OVERRIDE;
> #endif
>     virtual void setBackgroundColor(const WebCore::Color&) OVERRIDE;
> 
>+    // Reimplementations from CompositingCoordinatorClient
>+    virtual const WebCore::IntSize& viewSize() const OVERRIDE;
>+    virtual void didPerformScheduledLayerFlush(bool didSync) OVERRIDE;
>+    virtual bool isOpaqueContents() OVERRIDE;
>+    virtual void layoutIfNeeded() OVERRIDE;
>+    virtual void paintContents(WebCore::GraphicsContext&, const WebCore::IntRect& clipRect) OVERRIDE;
>+    virtual void paintOverlayContents(WebCore::GraphicsContext&, const WebCore::IntRect& clipRect) OVERRIDE;
>+    virtual bool hasPageOverlay() const OVERRIDE;
>+
> 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);
>-
>-    // CoordinatedImageBacking::Coordinator
>-    virtual void createImageBacking(CoordinatedImageBackingID) OVERRIDE;
>-    virtual void updateImageBacking(CoordinatedImageBackingID, const WebCoordinatedSurface::Handle&) OVERRIDE;
>-    virtual void clearImageBackingContents(CoordinatedImageBackingID) OVERRIDE;
>-    virtual void removeImageBacking(CoordinatedImageBackingID) OVERRIDE;
>-
>-    void flushPendingImageBackingChanges();
>-
>-    // GraphicsLayerFactory
>-    virtual PassOwnPtr<WebCore::GraphicsLayer> createGraphicsLayer(WebCore::GraphicsLayerClient*) OVERRIDE;
>-
>-    // CoordinatedLayerTreeHost
>-    void initializeRootCompositingLayerIfNeeded();
>-    void createPageOverlayLayer();
>-    void destroyPageOverlayLayer();
>-    bool flushPendingLayerChanges();
>-    void cancelPendingLayerFlush();
>-    void performScheduledLayerFlush();
>-    void didPerformScheduledLayerFlush();
>-    void syncDisplayState();
>-    void lockAnimations();
>-    void unlockAnimations();
>-
>-    void layerFlushTimerFired(WebCore::Timer<CoordinatedLayerTreeHost>*);
>-
>-    void scheduleReleaseInactiveAtlases();
> #if ENABLE(REQUEST_ANIMATION_FRAME)
>     void animationFrameReady();
> #endif
> 
>-    void releaseInactiveAtlasesTimerFired(WebCore::Timer<CoordinatedLayerTreeHost>*);
>-
>-#if ENABLE(CSS_SHADERS)
>-    // WebCustomFilterProgramProxyClient
>-    void removeCustomFilterProgramProxy(WebCustomFilterProgramProxy*);
>-
>-    void checkCustomFilterProgramProxies(const WebCore::FilterOperations&);
>-    void disconnectCustomFilterPrograms();
>-#endif
>-
>-    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;
>-
>-#if ENABLE(CSS_SHADERS)
>-    HashSet<WebCustomFilterProgramProxy*> m_customFilterPrograms;
>-#endif
>+    RefPtr<WebCompositingCoordinatorCommands> m_compositingCoordinatorCommands;
>+    OwnPtr<CompositingCoordinator> m_compositingCoordinator;
> 
>     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_waitingForUIProcess;
>-    bool m_isSuspended;
>-    WebCore::FloatRect m_visibleContentsRect;
>-    float m_contentsScale;
>-    bool m_shouldSendScrollPositionUpdate;
> 
>     LayerTreeContext m_layerTreeContext;
>-    bool m_shouldSyncFrame;
>-    bool m_didInitializeRootCompositingLayer;
>-    WebCore::Timer<CoordinatedLayerTreeHost> m_layerFlushTimer;
>-    WebCore::Timer<CoordinatedLayerTreeHost> m_releaseInactiveAtlasesTimer;
>-    bool m_layerFlushSchedulingEnabled;
>     uint64_t m_forceRepaintAsyncCallbackID;
>-    bool m_animationsLocked;
> };
> 
> }
>diff --git a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/WebCompositingCoordinatorCommands.cpp b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/WebCompositingCoordinatorCommands.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..b314176382aeba31f5494b6c030ebe65ab3c23ad
>--- /dev/null
>+++ b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/WebCompositingCoordinatorCommands.cpp
>@@ -0,0 +1,263 @@
>+/*
>+ * 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 "WebCompositingCoordinatorCommands.h"
>+
>+#include "CoordinatedGraphicsArgumentCoders.h"
>+#include "CoordinatedLayerTreeHostProxyMessages.h"
>+#include "MessageID.h"
>+#include "SurfaceUpdateInfo.h"
>+#include "WebCoreArgumentCoders.h"
>+#include "WebPage.h"
>+#include "WebPageProxyMessages.h"
>+
>+#if ENABLE(CSS_SHADERS)
>+#include "CustomFilterValidatedProgram.h"
>+#include "ValidatedCustomFilterOperation.h"
>+#endif
>+
>+using namespace WebCore;
>+
>+namespace WebKit {
>+
>+PassRefPtr<WebCompositingCoordinatorCommands> WebCompositingCoordinatorCommands::create(WebPage* webPage)
>+{
>+    return adoptRef(new WebCompositingCoordinatorCommands(webPage));
>+}
>+
>+WebCompositingCoordinatorCommands::~WebCompositingCoordinatorCommands()
>+{
>+#if ENABLE(CSS_SHADERS)
>+    disconnectCustomFilterPrograms();
>+#endif
>+}
>+
>+WebCompositingCoordinatorCommands::WebCompositingCoordinatorCommands(WebPage* webPage)
>+    : m_webPage(webPage)
>+{
>+
>+}
>+
>+void WebCompositingCoordinatorCommands::setRootCompositingLayer(CoordinatedLayerID id)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::SetRootCompositingLayer(id));
>+}
>+
>+void WebCompositingCoordinatorCommands::setCompositingLayerState(CoordinatedLayerID id, const CoordinatedLayerInfo& info)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::SetCompositingLayerState(id, info));
>+}
>+
>+void WebCompositingCoordinatorCommands::setCompositingLayerChildren(CoordinatedLayerID id, const Vector<CoordinatedLayerID>& children)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::SetCompositingLayerChildren(id, children));
>+}
>+
>+#if ENABLE(CSS_FILTERS)
>+void WebCompositingCoordinatorCommands::setCompositingLayerFilters(CoordinatedLayerID id, const FilterOperations& filters)
>+{
>+#if ENABLE(CSS_SHADERS)
>+    checkCustomFilterProgramProxies(filters);
>+#endif
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::SetCompositingLayerFilters(id, filters));
>+}
>+#endif
>+
>+void WebCompositingCoordinatorCommands::deleteCompositingLayer(CoordinatedLayerID id)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::DeleteCompositingLayer(id));
>+}
>+
>+void WebCompositingCoordinatorCommands::createTileForLayer(CoordinatedLayerID layerID, uint32_t tileID, const IntRect& tileRect, const SurfaceUpdateInfo& updateInfo)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::CreateTileForLayer(layerID, tileID, tileRect, updateInfo));
>+}
>+
>+void WebCompositingCoordinatorCommands::updateTileForLayer(CoordinatedLayerID layerID, uint32_t tileID, const IntRect& tileRect, const SurfaceUpdateInfo& updateInfo)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::UpdateTileForLayer(layerID, tileID, tileRect, updateInfo));
>+}
>+
>+void WebCompositingCoordinatorCommands::removeTileForLayer(CoordinatedLayerID layerID, uint32_t tileID)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::RemoveTileForLayer(layerID, tileID));
>+}
>+
>+void WebCompositingCoordinatorCommands::createUpdateAtlas(uint32_t atlasID, const WebCoordinatedSurface::Handle& handle)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::CreateUpdateAtlas(atlasID, handle));
>+}
>+
>+void WebCompositingCoordinatorCommands::removeUpdateAtlas(uint32_t atlasID)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::RemoveUpdateAtlas(atlasID));
>+}
>+
>+void WebCompositingCoordinatorCommands::createImageBacking(CoordinatedImageBackingID imageID)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::CreateImageBacking(imageID));
>+}
>+
>+void WebCompositingCoordinatorCommands::updateImageBacking(CoordinatedImageBackingID imageID, const WebCoordinatedSurface::Handle& handle)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::UpdateImageBacking(imageID, handle));
>+}
>+
>+void WebCompositingCoordinatorCommands::clearImageBackingContents(CoordinatedImageBackingID imageID)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::ClearImageBackingContents(imageID));
>+}
>+
>+void WebCompositingCoordinatorCommands::removeImageBacking(CoordinatedImageBackingID imageID)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::RemoveImageBacking(imageID));
>+}
>+
>+void WebCompositingCoordinatorCommands::didRenderFrame(const IntSize& contentsSize, const IntRect& coveredRect)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::DidRenderFrame(contentsSize, coveredRect));
>+}
>+
>+void WebCompositingCoordinatorCommands::didChangeScrollPosition(const FloatPoint& position)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::DidChangeScrollPosition(position));
>+}
>+
>+#if USE(GRAPHICS_SURFACE)
>+void WebCompositingCoordinatorCommands::createCanvas(CoordinatedLayerID id, const IntSize& canvasSize, const GraphicsSurfaceToken& token)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::CreateCanvas(id, canvasSize, token));
>+}
>+
>+void WebCompositingCoordinatorCommands::syncCanvas(CoordinatedLayerID id, uint32_t frontBuffer)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::SyncCanvas(id, frontBuffer));
>+}
>+
>+void WebCompositingCoordinatorCommands::destroyCanvas(CoordinatedLayerID id)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::DestroyCanvas(id));
>+}
>+#endif
>+
>+void WebCompositingCoordinatorCommands::setLayerAnimations(CoordinatedLayerID layerID, const GraphicsLayerAnimations& activeAnimations)
>+{
>+#if ENABLE(CSS_SHADERS)
>+    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(i));
>+            checkCustomFilterProgramProxies(*filterValue->value());
>+        }
>+    }
>+#endif
>+
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::SetLayerAnimations(layerID, activeAnimations));
>+}
>+
>+void WebCompositingCoordinatorCommands::setAnimationsLocked(bool isLocked)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::SetAnimationsLocked(isLocked));
>+}
>+
>+void WebCompositingCoordinatorCommands::setBackgroundColor(const WebCore::Color& color)
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::SetBackgroundColor(color));
>+}
>+
>+#if ENABLE(REQUEST_ANIMATION_FRAME)
>+void WebCompositingCoordinatorCommands::requestAnimationFrame()
>+{
>+    m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::RequestAnimationFrame());
>+}
>+#endif
>+
>+void WebCompositingCoordinatorCommands::invokeForceRepaintAsyncCallback(uint64_t callbackID)
>+{
>+    m_webPage->send(Messages::WebPageProxy::VoidCallback(callbackID));
>+}
>+
>+#if ENABLE(CSS_SHADERS)
>+void WebCompositingCoordinatorCommands::checkCustomFilterProgramProxies(const FilterOperations& filters)
>+{
>+    // We need to create the WebCustomFilterProgramProxy objects before we get to serialize the
>+    // custom filters to the other process. That's because WebCustomFilterProgramProxy needs
>+    // to link back to the coordinator, so that we can send a message to the UI process when
>+    // the program is not needed anymore.
>+    // Note that the serialization will only happen at a later time in ArgumentCoder<WebCore::FilterOperations>::encode.
>+    // At that point the program will only be serialized once. All the other times it will only use the ID of the program.
>+    for (size_t i = 0; i < filters.size(); ++i) {
>+        const FilterOperation* operation = filters.at(i);
>+        if (operation->getOperationType() != FilterOperation::VALIDATED_CUSTOM)
>+            continue;
>+        const ValidatedCustomFilterOperation* customOperation = static_cast<const ValidatedCustomFilterOperation*>(operation);
>+        ASSERT(customOperation->validatedProgram()->isInitialized());
>+        TextureMapperPlatformCompiledProgram* program = customOperation->validatedProgram()->platformCompiledProgram();
>+
>+        RefPtr<WebCustomFilterProgramProxy> customFilterProgramProxy;
>+        if (program->client())
>+            customFilterProgramProxy = static_cast<WebCustomFilterProgramProxy*>(program->client());
>+        else {
>+            customFilterProgramProxy = WebCustomFilterProgramProxy::create();
>+            program->setClient(customFilterProgramProxy);
>+        }
>+
>+        if (!customFilterProgramProxy->client()) {
>+            customFilterProgramProxy->setClient(this);
>+            m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::CreateCustomFilterProgram(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);
>+        }
>+    }
>+}
>+
>+void WebCompositingCoordinatorCommands::removeCustomFilterProgramProxy(WebCustomFilterProgramProxy* customFilterProgramProxy)
>+{
>+    // 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_webPage->send(Messages::CoordinatedLayerTreeHostProxy::RemoveCustomFilterProgram(customFilterProgramProxy->id()));
>+}
>+
>+void WebCompositingCoordinatorCommands::disconnectCustomFilterPrograms()
>+{
>+    // Make sure that WebCore will not call into this coordinator anymore.
>+    HashSet<WebCustomFilterProgramProxy*>::iterator iter = m_customFilterPrograms.begin();
>+    for (; iter != m_customFilterPrograms.end(); ++iter)
>+        (*iter)->setClient(0);
>+}
>+#endif
>+
>+} // namespace WebKit
>+
>+#endif // USE(COORDINATED_GRAPHICS)
>diff --git a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/WebCompositingCoordinatorCommands.h b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/WebCompositingCoordinatorCommands.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..b6499da082a5e1afa45645a751e8aea16de8dcc4
>--- /dev/null
>+++ b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/WebCompositingCoordinatorCommands.h
>@@ -0,0 +1,116 @@
>+/*
>+ * 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 WebCompositingCoordinatorCommands_h
>+#define WebCompositingCoordinatorCommands_h
>+
>+#if USE(COORDINATED_GRAPHICS)
>+
>+#include "CompositingCoordinatorCommands.h"
>+
>+#if ENABLE(CSS_SHADERS)
>+#include "WebCustomFilterProgramProxy.h"
>+#endif
>+
>+namespace WebKit {
>+
>+class WebPage;
>+
>+class WebCompositingCoordinatorCommands : public RefCounted<WebCompositingCoordinatorCommands>
>+    , public CompositingCoordinatorCommands
>+#if ENABLE(CSS_SHADERS)
>+    , WebCustomFilterProgramProxyClient
>+#endif
>+{
>+    WTF_MAKE_NONCOPYABLE(WebCompositingCoordinatorCommands); WTF_MAKE_FAST_ALLOCATED;
>+public:
>+    static PassRefPtr<WebCompositingCoordinatorCommands> create(WebPage*);
>+
>+    ~WebCompositingCoordinatorCommands();
>+
>+    // CompositingCoordinatorCommands
>+    virtual void setRootCompositingLayer(CoordinatedLayerID) OVERRIDE;
>+    virtual void setCompositingLayerState(CoordinatedLayerID, const CoordinatedLayerInfo&) OVERRIDE;
>+    virtual void setCompositingLayerChildren(CoordinatedLayerID, const Vector<CoordinatedLayerID>&) OVERRIDE;
>+#if ENABLE(CSS_FILTERS)
>+    virtual void setCompositingLayerFilters(CoordinatedLayerID, const WebCore::FilterOperations&) OVERRIDE;
>+#endif
>+    virtual void deleteCompositingLayer(CoordinatedLayerID) OVERRIDE;
>+
>+    virtual void createTileForLayer(CoordinatedLayerID, uint32_t tileID, const WebCore::IntRect&, const SurfaceUpdateInfo&) OVERRIDE;
>+    virtual void updateTileForLayer(CoordinatedLayerID, uint32_t tileID, const WebCore::IntRect&, const SurfaceUpdateInfo&) OVERRIDE;
>+    virtual void removeTileForLayer(CoordinatedLayerID, uint32_t tileID) OVERRIDE;
>+
>+    virtual void createUpdateAtlas(uint32_t atlasID, const WebCoordinatedSurface::Handle&) OVERRIDE;
>+    virtual void removeUpdateAtlas(uint32_t atlasID) OVERRIDE;
>+
>+    virtual void createImageBacking(CoordinatedImageBackingID) OVERRIDE;
>+    virtual void updateImageBacking(CoordinatedImageBackingID, const WebCoordinatedSurface::Handle&) OVERRIDE;
>+    virtual void clearImageBackingContents(CoordinatedImageBackingID) OVERRIDE;
>+    virtual void removeImageBacking(CoordinatedImageBackingID) OVERRIDE;
>+
>+    virtual void didRenderFrame(const WebCore::IntSize& contentsSize, const WebCore::IntRect& coveredRect) OVERRIDE;
>+    virtual void didChangeScrollPosition(const WebCore::FloatPoint& position) OVERRIDE;
>+
>+#if USE(GRAPHICS_SURFACE)
>+    virtual void createCanvas(CoordinatedLayerID, const WebCore::IntSize&, const WebCore::GraphicsSurfaceToken&) OVERRIDE;
>+    virtual void syncCanvas(CoordinatedLayerID, uint32_t frontBuffer) OVERRIDE;
>+    virtual void destroyCanvas(CoordinatedLayerID) OVERRIDE;
>+#endif
>+
>+    virtual void setLayerAnimations(CoordinatedLayerID, const WebCore::GraphicsLayerAnimations&) OVERRIDE;
>+    virtual void setAnimationsLocked(bool) OVERRIDE;
>+
>+    void setBackgroundColor(const WebCore::Color&);
>+
>+#if ENABLE(REQUEST_ANIMATION_FRAME)
>+    void requestAnimationFrame();
>+#endif
>+    void invokeForceRepaintAsyncCallback(uint64_t callbackID);
>+
>+private:
>+    explicit WebCompositingCoordinatorCommands(WebPage*);
>+
>+#if ENABLE(CSS_SHADERS)
>+    // WebCustomFilterProgramProxyClient
>+    void removeCustomFilterProgramProxy(WebCustomFilterProgramProxy*);
>+
>+    void checkCustomFilterProgramProxies(const WebCore::FilterOperations& filters) OVERRIDE;
>+    void disconnectCustomFilterPrograms();
>+#endif
>+
>+    WebPage* m_webPage;
>+
>+#if ENABLE(CSS_SHADERS)
>+    HashSet<WebCustomFilterProgramProxy*> m_customFilterPrograms;
>+#endif
>+};
>+
>+} // namespace WebKit
>+
>+#endif
>+
>+#endif // WebCompositingCoordinatorCommands_h

Actions: View | Formatted Diff | Diff

Attachments on bug 104360: 178194 | 178339 | 178512 | 178863 | 182305 | 192909 | 193083 | 203804 | 203920 | 204012 | 204024 | 204029 | 205472 | 205548 | 205715