Attachment 177914 Details for Bug 103983 – Patch

[patch] Patch

bug-103983-20121205200832.patch (text/plain), 60.56 KB, created by Jae Hyun Park on 2012-12-05 20:10:17 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Jae Hyun Park

Created: 2012-12-05 20:10:17 PST

Size: 60.56 KB

patch

obsolete

>Subversion Revision: 136706
>diff --git a/Source/WebKit2/ChangeLog b/Source/WebKit2/ChangeLog
>index ba07bff22d6f673dca2ec943751247d3fc122e2e..873eeb89b9746212228ce67b6d2becbeddc3881f 100644
>--- a/Source/WebKit2/ChangeLog
>+++ b/Source/WebKit2/ChangeLog
>@@ -1,3 +1,116 @@
>+2012-12-05  Jae Hyun Park  <jae.park@company100.net>
>+
>+        Coordinated Graphics: Rename WebLayerTreeInfo to CoordinatedLayerInfo
>+        https://bugs.webkit.org/show_bug.cgi?id=103983
>+
>+        Reviewed by Noam Rosenthal.
>+
>+        This patch refactors WebLayerTreeInfo in 2 areas.
>+
>+        1. WebLayerTreeInfo is only used by Coordinated Graphics. So, the file
>+        should be located in WebKit2/Shared/CoordinatedGraphics instead of
>+        WebKit2/Shared.
>+
>+        2. The name of WebLayerTreeInfo is incorrect. Currently,
>+        WebLayerTreeInfo only has WebLayerInfo struct. Also, it is hard to know
>+        what WebLayer is since we don't use that name anymore. More appropriate
>+        name for WebLayerInfo would be CoordinatedLayerInfo.
>+
>+        No new test, because no behavioral change.
>+
>+        * CMakeLists.txt:
>+        * Scripts/webkit2/messages.py:
>+        (headers_for_type):
>+        * Shared/CoordinatedGraphics/CoordinatedLayerInfo.cpp: Renamed from Source/WebKit2/Shared/WebLayerTreeInfo.cpp.
>+        (WebKit):
>+        (WebKit::CoordinatedLayerInfo::encode):
>+        (WebKit::CoordinatedLayerInfo::decode):
>+        * Shared/CoordinatedGraphics/CoordinatedLayerInfo.h: Renamed from Source/WebKit2/Shared/WebLayerTreeInfo.h.
>+        (WebKit):
>+        (WebKit::CoordinatedLayerInfo::CoordinatedLayerInfo):
>+        (CoordinatedLayerInfo):
>+        * Shared/LayerTreeContext.h:
>+        (LayerTreeContext):
>+        * Shared/efl/LayerTreeContextEfl.cpp:
>+        (WebKit::LayerTreeContext::LayerTreeContext):
>+        (WebKit::LayerTreeContext::encode):
>+        (WebKit::LayerTreeContext::decode):
>+        (WebKit::LayerTreeContext::isEmpty):
>+        (WebKit::operator==):
>+        * Shared/qt/LayerTreeContextQt.cpp:
>+        (WebKit::LayerTreeContext::LayerTreeContext):
>+        (WebKit::LayerTreeContext::encode):
>+        (WebKit::LayerTreeContext::decode):
>+        (WebKit::LayerTreeContext::isEmpty):
>+        (WebKit::operator==):
>+        * Target.pri:
>+        * UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.cpp:
>+        (WebKit::LayerTreeCoordinatorProxy::createTileForLayer):
>+        (WebKit::LayerTreeCoordinatorProxy::updateTileForLayer):
>+        (WebKit::LayerTreeCoordinatorProxy::removeTileForLayer):
>+        (WebKit::LayerTreeCoordinatorProxy::deleteCompositingLayer):
>+        (WebKit::LayerTreeCoordinatorProxy::setRootCompositingLayer):
>+        (WebKit::LayerTreeCoordinatorProxy::setCompositingLayerState):
>+        (WebKit::LayerTreeCoordinatorProxy::setCompositingLayerChildren):
>+        (WebKit::LayerTreeCoordinatorProxy::setCompositingLayerFilters):
>+        (WebKit::LayerTreeCoordinatorProxy::setLayerAnimations):
>+        (WebKit::LayerTreeCoordinatorProxy::createCanvas):
>+        (WebKit::LayerTreeCoordinatorProxy::syncCanvas):
>+        (WebKit::LayerTreeCoordinatorProxy::destroyCanvas):
>+        * UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.h:
>+        (WebKit):
>+        (LayerTreeCoordinatorProxy):
>+        * UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.messages.in:
>+        * UIProcess/CoordinatedGraphics/LayerTreeRenderer.cpp:
>+        (WebKit::LayerTreeRenderer::LayerTreeRenderer):
>+        (WebKit::LayerTreeRenderer::createLayer):
>+        (WebKit::LayerTreeRenderer::createCanvas):
>+        (WebKit::LayerTreeRenderer::syncCanvas):
>+        (WebKit::LayerTreeRenderer::destroyCanvas):
>+        (WebKit::LayerTreeRenderer::setLayerChildren):
>+        (WebKit::LayerTreeRenderer::setLayerFilters):
>+        (WebKit::LayerTreeRenderer::setLayerState):
>+        (WebKit::LayerTreeRenderer::deleteLayer):
>+        (WebKit::LayerTreeRenderer::ensureLayer):
>+        (WebKit::LayerTreeRenderer::setRootLayerID):
>+        (WebKit::LayerTreeRenderer::createTile):
>+        (WebKit::LayerTreeRenderer::removeTile):
>+        (WebKit::LayerTreeRenderer::updateTile):
>+        (WebKit::LayerTreeRenderer::ensureRootLayer):
>+        (WebKit::LayerTreeRenderer::purgeGLResources):
>+        (WebKit::LayerTreeRenderer::setLayerAnimations):
>+        * UIProcess/CoordinatedGraphics/LayerTreeRenderer.h:
>+        (WebKit):
>+        (LayerTreeRenderer):
>+        (WebKit::LayerTreeRenderer::layerByID):
>+        * UIProcess/DrawingAreaProxy.h:
>+        (WebKit):
>+        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp:
>+        (WebCore::layerByIDMap):
>+        (WebCore::toCoordinatedLayerID):
>+        (WebCore::CoordinatedGraphicsLayer::CoordinatedGraphicsLayer):
>+        (WebCore::CoordinatedGraphicsLayer::id):
>+        (WebCore::CoordinatedGraphicsLayer::syncChildren):
>+        (WebCore::CoordinatedGraphicsLayer::syncLayerState):
>+        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.h:
>+        (CoordinatedGraphicsLayerClient):
>+        (CoordinatedGraphicsLayer):
>+        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedImageBacking.h:
>+        * WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp:
>+        (WebKit::LayerTreeCoordinator::LayerTreeCoordinator):
>+        (WebKit::LayerTreeCoordinator::syncLayerState):
>+        (WebKit::LayerTreeCoordinator::syncLayerChildren):
>+        (WebKit::LayerTreeCoordinator::createCanvas):
>+        (WebKit::LayerTreeCoordinator::syncCanvas):
>+        (WebKit::LayerTreeCoordinator::destroyCanvas):
>+        (WebKit::LayerTreeCoordinator::syncLayerFilters):
>+        (WebKit::LayerTreeCoordinator::createTile):
>+        (WebKit::LayerTreeCoordinator::updateTile):
>+        (WebKit::LayerTreeCoordinator::removeTile):
>+        (WebKit::LayerTreeCoordinator::setLayerAnimations):
>+        * WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.h:
>+        (LayerTreeCoordinator):
>+
> 2012-12-05  Christophe Dumez  <christophe.dumez@intel.com>
> 
>         [EFL][WK2] EWK2UnitTestBase.ewk_favicon_database_async_icon_get is crashing with new Ewk_Context
>diff --git a/Source/WebKit2/CMakeLists.txt b/Source/WebKit2/CMakeLists.txt
>index 003396a657fd45b8be2c8250e092ce2d3f6fd220..027a743079e832ecd92b01f87db501430da7c998 100644
>--- a/Source/WebKit2/CMakeLists.txt
>+++ b/Source/WebKit2/CMakeLists.txt
>@@ -175,7 +175,6 @@ SET(WebKit2_SOURCES
>     Shared/WebImage.cpp
>     Shared/WebIntentServiceInfo.cpp
>     Shared/WebKeyboardEvent.cpp
>-    Shared/WebLayerTreeInfo.cpp
>     Shared/WebMemorySampler.cpp
>     Shared/WebMouseEvent.cpp
>     Shared/WebNetworkInfo.cpp
>@@ -218,6 +217,7 @@ SET(WebKit2_SOURCES
>     Shared/API/c/WKUserContentURLPattern.cpp
> 
>     Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.cpp
>+    Shared/CoordinatedGraphics/CoordinatedLayerInfo.cpp
>     Shared/CoordinatedGraphics/WebCustomFilterProgramProxy.cpp
> 
>     Shared/Plugins/NPIdentifierData.cpp
>diff --git a/Source/WebKit2/Scripts/webkit2/messages.py b/Source/WebKit2/Scripts/webkit2/messages.py
>index 0c9b941167bb0e0a0dcbd628d0c13efa1bf12c55..559478ca9cd3e37ae05145ec23969691d4d5bea2 100644
>--- a/Source/WebKit2/Scripts/webkit2/messages.py
>+++ b/Source/WebKit2/Scripts/webkit2/messages.py
>@@ -396,11 +396,10 @@ def headers_for_type(type):
>         'WebCore::PluginInfo': ['<WebCore/PluginData.h>'],
>         'WebCore::TextCheckingResult': ['<WebCore/TextCheckerClient.h>'],
>         'WebCore::ViewportAttributes': ['<WebCore/ViewportArguments.h>'],
>+        'WebKit::CoordinatedLayerID': ['"CoordinatedLayerInfo.h"'],
>         'WebKit::InjectedBundleUserMessageEncoder': [],
>         'WebKit::WebContextUserMessageEncoder': [],
>         'WebKit::WebGestureEvent': ['"WebEvent.h"'],
>-        'WebKit::WebLayerID': ['"WebLayerTreeInfo.h"'],
>-        'WebKit::WebLayerInfo': ['"WebLayerTreeInfo.h"'],
>         'WebKit::WebKeyboardEvent': ['"WebEvent.h"'],
>         'WebKit::WebMouseEvent': ['"WebEvent.h"'],
>         'WebKit::WebTouchEvent': ['"WebEvent.h"'],
>diff --git a/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedLayerInfo.cpp b/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedLayerInfo.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..cd86e62974fe38538d636f71d074d232846a45a7
>--- /dev/null
>+++ b/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedLayerInfo.cpp
>@@ -0,0 +1,43 @@
>+/*
>+ Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
>+
>+ This library is free software; you can redistribute it and/or
>+ modify it under the terms of the GNU Library General Public
>+ License as published by the Free Software Foundation; either
>+ version 2 of the License, or (at your option) any later version.
>+
>+ This library is distributed in the hope that it will be useful,
>+ but WITHOUT ANY WARRANTY; without even the implied warranty of
>+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>+ Library General Public License for more details.
>+
>+ You should have received a copy of the GNU Library General Public License
>+ along with this library; see the file COPYING.LIB.  If not, write to
>+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
>+ Boston, MA 02110-1301, USA.
>+ */
>+
>+#include "config.h"
>+
>+#if USE(COORDINATED_GRAPHICS)
>+#include "CoordinatedLayerInfo.h"
>+
>+#include "ArgumentCoders.h"
>+#include "Arguments.h"
>+#include "SharedMemory.h"
>+
>+using namespace CoreIPC;
>+
>+namespace WebKit {
>+
>+void CoordinatedLayerInfo::encode(CoreIPC::ArgumentEncoder& encoder) const
>+{
>+    SimpleArgumentCoder<CoordinatedLayerInfo>::encode(encoder, *this);
>+}
>+
>+bool CoordinatedLayerInfo::decode(CoreIPC::ArgumentDecoder* decoder, CoordinatedLayerInfo& info)
>+{
>+    return SimpleArgumentCoder<CoordinatedLayerInfo>::decode(decoder, info);
>+}
>+}
>+#endif // USE(COORDINATED_GRAPHICS)
>diff --git a/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedLayerInfo.h b/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedLayerInfo.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..27c816b687469b9b900df8706df934c50f880d7d
>--- /dev/null
>+++ b/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedLayerInfo.h
>@@ -0,0 +1,82 @@
>+/*
>+ Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
>+
>+ This library is free software; you can redistribute it and/or
>+ modify it under the terms of the GNU Library General Public
>+ License as published by the Free Software Foundation; either
>+ version 2 of the License, or (at your option) any later version.
>+
>+ This library is distributed in the hope that it will be useful,
>+ but WITHOUT ANY WARRANTY; without even the implied warranty of
>+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>+ Library General Public License for more details.
>+
>+ You should have received a copy of the GNU Library General Public License
>+ along with this library; see the file COPYING.LIB.  If not, write to
>+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
>+ Boston, MA 02110-1301, USA.
>+ */
>+
>+#ifndef CoordinatedLayerInfo_h
>+#define CoordinatedLayerInfo_h
>+
>+#if USE(COORDINATED_GRAPHICS)
>+
>+#include "ArgumentDecoder.h"
>+#include "ArgumentEncoder.h"
>+#include "FloatRect.h"
>+#include "FloatSize.h"
>+#include "GraphicsLayer.h"
>+
>+namespace WebKit {
>+
>+typedef uint32_t CoordinatedLayerID;
>+enum { InvalidCoordinatedLayerID = 0 };
>+
>+typedef uint64_t CoordinatedImageBackingID;
>+enum { InvalidCoordinatedImageBackingID = 0 };
>+
>+// NOTE: CoordinatedLayerInfo should only use POD types, as to make serialization faster.
>+struct CoordinatedLayerInfo {
>+    CoordinatedLayerInfo()
>+        : replica(InvalidCoordinatedLayerID)
>+        , mask(InvalidCoordinatedLayerID)
>+        , imageID(InvalidCoordinatedImageBackingID)
>+        , opacity(0)
>+        , flags(0) { }
>+
>+    CoordinatedLayerID replica;
>+    CoordinatedLayerID mask;
>+    CoordinatedImageBackingID imageID;
>+
>+    WebCore::FloatPoint pos;
>+    WebCore::FloatPoint3D anchorPoint;
>+    WebCore::FloatSize size;
>+    WebCore::TransformationMatrix transform;
>+    WebCore::TransformationMatrix childrenTransform;
>+    WebCore::IntRect contentsRect;
>+    float opacity;
>+
>+    union {
>+        struct {
>+            bool contentsOpaque : 1;
>+            bool drawsContent : 1;
>+            bool contentsVisible : 1;
>+            bool backfaceVisible : 1;
>+            bool masksToBounds : 1;
>+            bool preserves3D : 1;
>+            bool isRootLayer: 1;
>+            bool fixedToViewport : 1;
>+        };
>+        unsigned flags;
>+    };
>+
>+    void encode(CoreIPC::ArgumentEncoder&) const;
>+    static bool decode(CoreIPC::ArgumentDecoder*, CoordinatedLayerInfo&);
>+};
>+
>+}
>+
>+#endif // USE(COORDINATED_GRAPHICS)
>+
>+#endif // CoordinatedLayerInfo_h
>diff --git a/Source/WebKit2/Shared/LayerTreeContext.h b/Source/WebKit2/Shared/LayerTreeContext.h
>index f8e2fce61f33d2acf747f0e9cc5ee63ebc7efea9..3ff7cb4a35b1dc2a252dcacac74afa20ff819324 100644
>--- a/Source/WebKit2/Shared/LayerTreeContext.h
>+++ b/Source/WebKit2/Shared/LayerTreeContext.h
>@@ -57,11 +57,11 @@ public:
> #elif PLATFORM(WIN)
>     HWND window;
> #elif PLATFORM(QT)
>-    uint32_t webLayerID;
>+    uint32_t coordinatedLayerID;
> #elif PLATFORM(GTK)
>     uint64_t windowHandle;
> #elif PLATFORM(EFL)
>-    uint32_t webLayerID;
>+    uint32_t coordinatedLayerID;
> #endif
> };
> 
>diff --git a/Source/WebKit2/Shared/WebLayerTreeInfo.cpp b/Source/WebKit2/Shared/WebLayerTreeInfo.cpp
>deleted file mode 100644
>index d1b131feabd36051c9698c956cff357127936a79..0000000000000000000000000000000000000000
>--- a/Source/WebKit2/Shared/WebLayerTreeInfo.cpp
>+++ /dev/null
>@@ -1,43 +0,0 @@
>-/*
>- Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
>-
>- This library is free software; you can redistribute it and/or
>- modify it under the terms of the GNU Library General Public
>- License as published by the Free Software Foundation; either
>- version 2 of the License, or (at your option) any later version.
>-
>- This library is distributed in the hope that it will be useful,
>- but WITHOUT ANY WARRANTY; without even the implied warranty of
>- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>- Library General Public License for more details.
>-
>- You should have received a copy of the GNU Library General Public License
>- along with this library; see the file COPYING.LIB.  If not, write to
>- the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
>- Boston, MA 02110-1301, USA.
>- */
>-
>-#include "config.h"
>-
>-#if USE(COORDINATED_GRAPHICS)
>-#include "WebLayerTreeInfo.h"
>-
>-#include "ArgumentCoders.h"
>-#include "Arguments.h"
>-#include "SharedMemory.h"
>-
>-using namespace CoreIPC;
>-
>-namespace WebKit {
>-
>-void WebLayerInfo::encode(CoreIPC::ArgumentEncoder& encoder) const
>-{
>-    SimpleArgumentCoder<WebLayerInfo>::encode(encoder, *this);
>-}
>-
>-bool WebLayerInfo::decode(CoreIPC::ArgumentDecoder* decoder, WebLayerInfo& info)
>-{
>-    return SimpleArgumentCoder<WebLayerInfo>::decode(decoder, info);
>-}
>-}
>-#endif
>diff --git a/Source/WebKit2/Shared/WebLayerTreeInfo.h b/Source/WebKit2/Shared/WebLayerTreeInfo.h
>deleted file mode 100644
>index cf32371afcf741fdf4a560694a7b201223ea4a0a..0000000000000000000000000000000000000000
>--- a/Source/WebKit2/Shared/WebLayerTreeInfo.h
>+++ /dev/null
>@@ -1,82 +0,0 @@
>-/*
>- Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
>-
>- This library is free software; you can redistribute it and/or
>- modify it under the terms of the GNU Library General Public
>- License as published by the Free Software Foundation; either
>- version 2 of the License, or (at your option) any later version.
>-
>- This library is distributed in the hope that it will be useful,
>- but WITHOUT ANY WARRANTY; without even the implied warranty of
>- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>- Library General Public License for more details.
>-
>- You should have received a copy of the GNU Library General Public License
>- along with this library; see the file COPYING.LIB.  If not, write to
>- the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
>- Boston, MA 02110-1301, USA.
>- */
>-
>-#ifndef WebLayerTreeInfo_h
>-#define WebLayerTreeInfo_h
>-
>-#if USE(COORDINATED_GRAPHICS)
>-
>-#include "ArgumentDecoder.h"
>-#include "ArgumentEncoder.h"
>-#include "FloatRect.h"
>-#include "FloatSize.h"
>-#include "GraphicsLayer.h"
>-
>-namespace WebKit {
>-
>-typedef uint32_t WebLayerID;
>-enum { InvalidWebLayerID = 0 };
>-
>-typedef uint64_t CoordinatedImageBackingID;
>-enum { InvalidCoordinatedImageBackingID = 0 };
>-
>-// NOTE: WebLayerInfo should only use POD types, as to make serialization faster.
>-struct WebLayerInfo {
>-    WebLayerInfo()
>-        : replica(InvalidWebLayerID)
>-        , mask(InvalidWebLayerID)
>-        , imageID(InvalidCoordinatedImageBackingID)
>-        , opacity(0)
>-        , flags(0) { }
>-
>-    WebLayerID replica;
>-    WebLayerID mask;
>-    CoordinatedImageBackingID imageID;
>-
>-    WebCore::FloatPoint pos;
>-    WebCore::FloatPoint3D anchorPoint;
>-    WebCore::FloatSize size;
>-    WebCore::TransformationMatrix transform;
>-    WebCore::TransformationMatrix childrenTransform;
>-    WebCore::IntRect contentsRect;
>-    float opacity;
>-
>-    union {
>-        struct {
>-            bool contentsOpaque : 1;
>-            bool drawsContent : 1;
>-            bool contentsVisible : 1;
>-            bool backfaceVisible : 1;
>-            bool masksToBounds : 1;
>-            bool preserves3D : 1;
>-            bool isRootLayer: 1;
>-            bool fixedToViewport : 1;
>-        };
>-        unsigned int flags;
>-    };
>-
>-    void encode(CoreIPC::ArgumentEncoder&) const;
>-    static bool decode(CoreIPC::ArgumentDecoder*, WebLayerInfo&);
>-};
>-
>-}
>-
>-#endif // USE(ACCELERATED_COMPOSITING)
>-
>-#endif // WebLayerTreeInfo_h
>diff --git a/Source/WebKit2/Shared/efl/LayerTreeContextEfl.cpp b/Source/WebKit2/Shared/efl/LayerTreeContextEfl.cpp
>index 32fa970a8e495f0d365bac818adad4cdfd49aa6d..1fa635d83d1a3392ef7e40155d6da992fdeb643e 100644
>--- a/Source/WebKit2/Shared/efl/LayerTreeContextEfl.cpp
>+++ b/Source/WebKit2/Shared/efl/LayerTreeContextEfl.cpp
>@@ -32,7 +32,7 @@
> namespace WebKit {
> 
> LayerTreeContext::LayerTreeContext()
>-    : webLayerID(0)
>+    : coordinatedLayerID(0)
> {
> }
> 
>@@ -42,22 +42,22 @@ LayerTreeContext::~LayerTreeContext()
> 
> void LayerTreeContext::encode(CoreIPC::ArgumentEncoder& encoder) const
> {
>-    encoder.encode(webLayerID);
>+    encoder.encode(coordinatedLayerID);
> }
> 
> bool LayerTreeContext::decode(CoreIPC::ArgumentDecoder* decoder, LayerTreeContext& context)
> {
>-    return decoder->decode(context.webLayerID);
>+    return decoder->decode(context.coordinatedLayerID);
> }
> 
> bool LayerTreeContext::isEmpty() const
> {
>-    return !webLayerID;
>+    return !coordinatedLayerID;
> }
> 
> bool operator==(const LayerTreeContext& a, const LayerTreeContext& b)
> {
>-    return a.webLayerID == b.webLayerID;
>+    return a.coordinatedLayerID == b.coordinatedLayerID;
> }
> 
> } // namespace WebKit
>diff --git a/Source/WebKit2/Shared/qt/LayerTreeContextQt.cpp b/Source/WebKit2/Shared/qt/LayerTreeContextQt.cpp
>index 00ea8735fafebcc3711ee1354b89023b4930102a..9fc416352cf1a52670f12d23733cf61cc29013e3 100644
>--- a/Source/WebKit2/Shared/qt/LayerTreeContextQt.cpp
>+++ b/Source/WebKit2/Shared/qt/LayerTreeContextQt.cpp
>@@ -32,7 +32,7 @@
> namespace WebKit {
> 
> LayerTreeContext::LayerTreeContext()
>-    : webLayerID(0)
>+    : coordinatedLayerID(0)
> {
> }
> 
>@@ -42,22 +42,22 @@ LayerTreeContext::~LayerTreeContext()
> 
> void LayerTreeContext::encode(CoreIPC::ArgumentEncoder& encoder) const
> {
>-    encoder.encode(webLayerID);
>+    encoder.encode(coordinatedLayerID);
> }
> 
> bool LayerTreeContext::decode(CoreIPC::ArgumentDecoder* decoder, LayerTreeContext& context)
> {
>-    return decoder->decode(context.webLayerID);
>+    return decoder->decode(context.coordinatedLayerID);
> }
> 
> bool LayerTreeContext::isEmpty() const
> {
>-    return !webLayerID;
>+    return !coordinatedLayerID;
> }
> 
> bool operator==(const LayerTreeContext& a, const LayerTreeContext& b)
> {
>-    return a.webLayerID == b.webLayerID;
>+    return a.coordinatedLayerID == b.coordinatedLayerID;
> }
> 
> } // namespace WebKit
>diff --git a/Source/WebKit2/Target.pri b/Source/WebKit2/Target.pri
>index 098b5b9543f5fdfb9b8a931a1282791e6a975691..2dd36e39840c6f5114e025798e5a55ca3e236603 100644
>--- a/Source/WebKit2/Target.pri
>+++ b/Source/WebKit2/Target.pri
>@@ -120,7 +120,6 @@ HEADERS += \
>     Shared/WebHitTestResult.h \
>     Shared/WebImage.h \
>     Shared/WebIntentServiceInfo.h \
>-    Shared/WebLayerTreeInfo.h \
>     Shared/WebNavigationDataStore.h \
>     Shared/WebNumber.h \
>     Shared/WebOpenPanelParameters.h \
>@@ -135,6 +134,7 @@ HEADERS += \
>     Shared/WebURLResponse.h \
>     Shared/WebUserContentURLPattern.h \
>     Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.h \
>+    Shared/CoordinatedGraphics/CoordinatedLayerInfo.h \
>     Shared/CoordinatedGraphics/WebCustomFilterProgram.h \
>     Shared/Plugins/Netscape/NetscapePluginModule.h \
>     Shared/Plugins/NPRemoteObjectMap.h \
>@@ -486,7 +486,6 @@ SOURCES += \
>     Shared/WebKeyboardEvent.cpp \
>     Shared/WebImage.cpp \
>     Shared/WebIntentServiceInfo.cpp \
>-    Shared/WebLayerTreeInfo.cpp \
>     Shared/WebMouseEvent.cpp \
>     Shared/WebNetworkInfo.cpp \
>     Shared/WebOpenPanelParameters.cpp \
>@@ -503,6 +502,7 @@ SOURCES += \
>     Shared/WebURLResponse.cpp \
>     Shared/WebWheelEvent.cpp \
>     Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.cpp \
>+    Shared/CoordinatedGraphics/CoordinatedLayerInfo.cpp \
>     Shared/CoordinatedGraphics/WebCustomFilterProgramProxy.cpp \
>     Shared/qt/ArgumentCodersQt.cpp \
>     Shared/qt/LayerTreeContextQt.cpp \
>diff --git a/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.cpp b/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.cpp
>index 8435e61234779e17780bdd98ad6e92939b18249f..2b61eb90c53f977482d3b4df428a91303e207764 100644
>--- a/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.cpp
>+++ b/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.cpp
>@@ -22,11 +22,11 @@
> #if USE(COORDINATED_GRAPHICS)
> #include "LayerTreeCoordinatorProxy.h"
> 
>+#include "CoordinatedLayerInfo.h"
> #include "LayerTreeCoordinatorMessages.h"
> #include "LayerTreeRenderer.h"
> #include "UpdateInfo.h"
> #include "WebCoreArgumentCoders.h"
>-#include "WebLayerTreeInfo.h"
> #include "WebPageProxy.h"
> #include "WebProcessProxy.h"
> #include <WebCore/GraphicsSurface.h>
>@@ -61,20 +61,20 @@ void LayerTreeCoordinatorProxy::dispatchUpdate(const Function<void()>& function)
>     m_renderer->appendUpdate(function);
> }
> 
>-void LayerTreeCoordinatorProxy::createTileForLayer(WebLayerID layerID, uint32_t tileID, const WebCore::IntRect& tileRect, const WebKit::SurfaceUpdateInfo& updateInfo)
>+void LayerTreeCoordinatorProxy::createTileForLayer(CoordinatedLayerID layerID, uint32_t tileID, const WebCore::IntRect& tileRect, const WebKit::SurfaceUpdateInfo& updateInfo)
> {
>     dispatchUpdate(bind(&LayerTreeRenderer::createTile, m_renderer.get(), layerID, tileID, updateInfo.scaleFactor));
>     updateTileForLayer(layerID, tileID, tileRect, updateInfo);
> }
> 
>-void LayerTreeCoordinatorProxy::updateTileForLayer(WebLayerID layerID, uint32_t tileID, const IntRect& tileRect, const WebKit::SurfaceUpdateInfo& updateInfo)
>+void LayerTreeCoordinatorProxy::updateTileForLayer(CoordinatedLayerID layerID, uint32_t tileID, const IntRect& tileRect, const WebKit::SurfaceUpdateInfo& updateInfo)
> {
>     SurfaceMap::iterator it = m_surfaces.find(updateInfo.atlasID);
>     ASSERT(it != m_surfaces.end());
>     dispatchUpdate(bind(&LayerTreeRenderer::updateTile, m_renderer.get(), layerID, tileID, LayerTreeRenderer::TileUpdate(updateInfo.updateRect, tileRect, it->value, updateInfo.surfaceOffset)));
> }
> 
>-void LayerTreeCoordinatorProxy::removeTileForLayer(WebLayerID layerID, uint32_t tileID)
>+void LayerTreeCoordinatorProxy::removeTileForLayer(CoordinatedLayerID layerID, uint32_t tileID)
> {
>     dispatchUpdate(bind(&LayerTreeRenderer::removeTile, m_renderer.get(), layerID, tileID));
> }
>@@ -91,28 +91,28 @@ void LayerTreeCoordinatorProxy::removeUpdateAtlas(int atlasID)
>     m_surfaces.remove(atlasID);
> }
> 
>-void LayerTreeCoordinatorProxy::deleteCompositingLayer(WebLayerID id)
>+void LayerTreeCoordinatorProxy::deleteCompositingLayer(CoordinatedLayerID id)
> {
>     dispatchUpdate(bind(&LayerTreeRenderer::deleteLayer, m_renderer.get(), id));
> }
> 
>-void LayerTreeCoordinatorProxy::setRootCompositingLayer(WebLayerID id)
>+void LayerTreeCoordinatorProxy::setRootCompositingLayer(CoordinatedLayerID id)
> {
>     dispatchUpdate(bind(&LayerTreeRenderer::setRootLayerID, m_renderer.get(), id));
> }
> 
>-void LayerTreeCoordinatorProxy::setCompositingLayerState(WebLayerID id, const WebLayerInfo& info)
>+void LayerTreeCoordinatorProxy::setCompositingLayerState(CoordinatedLayerID id, const CoordinatedLayerInfo& info)
> {
>     dispatchUpdate(bind(&LayerTreeRenderer::setLayerState, m_renderer.get(), id, info));
> }
> 
>-void LayerTreeCoordinatorProxy::setCompositingLayerChildren(WebLayerID id, const Vector<WebLayerID>& children)
>+void LayerTreeCoordinatorProxy::setCompositingLayerChildren(CoordinatedLayerID id, const Vector<CoordinatedLayerID>& children)
> {
>     dispatchUpdate(bind(&LayerTreeRenderer::setLayerChildren, m_renderer.get(), id, children));
> }
> 
> #if ENABLE(CSS_FILTERS)
>-void LayerTreeCoordinatorProxy::setCompositingLayerFilters(WebLayerID id, const FilterOperations& filters)
>+void LayerTreeCoordinatorProxy::setCompositingLayerFilters(CoordinatedLayerID id, const FilterOperations& filters)
> {
>     dispatchUpdate(bind(&LayerTreeRenderer::setLayerFilters, m_renderer.get(), id, filters));
> }
>@@ -166,7 +166,7 @@ void LayerTreeCoordinatorProxy::setContentsSize(const FloatSize& contentsSize)
>     dispatchUpdate(bind(&LayerTreeRenderer::setContentsSize, m_renderer.get(), contentsSize));
> }
> 
>-void LayerTreeCoordinatorProxy::setLayerAnimations(WebLayerID id, const GraphicsLayerAnimations& animations)
>+void LayerTreeCoordinatorProxy::setLayerAnimations(CoordinatedLayerID id, const GraphicsLayerAnimations& animations)
> {
>     dispatchUpdate(bind(&LayerTreeRenderer::setLayerAnimations, m_renderer.get(), id, animations));
> }
>@@ -216,18 +216,18 @@ void LayerTreeCoordinatorProxy::didChangeScrollPosition(const IntPoint& position
> }
> 
> #if USE(GRAPHICS_SURFACE)
>-void LayerTreeCoordinatorProxy::createCanvas(WebLayerID id, const IntSize& canvasSize, const GraphicsSurfaceToken& token)
>+void LayerTreeCoordinatorProxy::createCanvas(CoordinatedLayerID id, const IntSize& canvasSize, const GraphicsSurfaceToken& token)
> {
>     GraphicsSurface::Flags surfaceFlags = GraphicsSurface::SupportsTextureTarget | GraphicsSurface::SupportsSharing;
>     dispatchUpdate(bind(&LayerTreeRenderer::createCanvas, m_renderer.get(), id, canvasSize, GraphicsSurface::create(canvasSize, surfaceFlags, token)));
> }
> 
>-void LayerTreeCoordinatorProxy::syncCanvas(WebLayerID id, uint32_t frontBuffer)
>+void LayerTreeCoordinatorProxy::syncCanvas(CoordinatedLayerID id, uint32_t frontBuffer)
> {
>     dispatchUpdate(bind(&LayerTreeRenderer::syncCanvas, m_renderer.get(), id, frontBuffer));
> }
> 
>-void LayerTreeCoordinatorProxy::destroyCanvas(WebLayerID id)
>+void LayerTreeCoordinatorProxy::destroyCanvas(CoordinatedLayerID id)
> {
>     dispatchUpdate(bind(&LayerTreeRenderer::destroyCanvas, m_renderer.get(), id));
> }
>diff --git a/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.h b/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.h
>index 2305ffdc2fd30d7146569cb5bf8c1e54166193b6..daf3882bf37f741d83047862acb3cd4072ee1ad5 100644
>--- a/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.h
>+++ b/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.h
>@@ -24,11 +24,11 @@
> 
> #include "BackingStore.h"
> #include "CoordinatedGraphicsArgumentCoders.h"
>+#include "CoordinatedLayerInfo.h"
> #include "DrawingAreaProxy.h"
> #include "Region.h"
> #include "ShareableSurface.h"
> #include "SurfaceUpdateInfo.h"
>-#include "WebLayerTreeInfo.h"
> #include <WebCore/GraphicsContext.h>
> #include <WebCore/GraphicsLayer.h>
> #include <WebCore/GraphicsLayerAnimation.h>
>@@ -42,9 +42,9 @@
> 
> namespace WebKit {
> 
>-class WebLayerInfo;
>+class CoordinatedLayerInfo;
> class LayerTreeRenderer;
>-class WebLayerUpdateInfo;
>+class CoordinatedLayerUpdateInfo;
> 
> class LayerTreeCoordinatorProxy {
>     WTF_MAKE_NONCOPYABLE(LayerTreeCoordinatorProxy);
>@@ -52,23 +52,23 @@ class LayerTreeCoordinatorProxy {
> public:
>     explicit LayerTreeCoordinatorProxy(DrawingAreaProxy*);
>     ~LayerTreeCoordinatorProxy();
>-    void setCompositingLayerState(WebLayerID, const WebLayerInfo&);
>-    void setCompositingLayerChildren(WebLayerID, const Vector<WebLayerID>&);
>+    void setCompositingLayerState(CoordinatedLayerID, const CoordinatedLayerInfo&);
>+    void setCompositingLayerChildren(CoordinatedLayerID, const Vector<CoordinatedLayerID>&);
> #if ENABLE(CSS_FILTERS)
>-    void setCompositingLayerFilters(WebLayerID, const WebCore::FilterOperations&);
>+    void setCompositingLayerFilters(CoordinatedLayerID, const WebCore::FilterOperations&);
> #endif
> #if ENABLE(CSS_SHADERS)
>     void createCustomFilterProgram(int id, const WebCore::CustomFilterProgramInfo&);
>     void removeCustomFilterProgram(int id);
> #endif
>-    void deleteCompositingLayer(WebLayerID);
>-    void setRootCompositingLayer(WebLayerID);
>+    void deleteCompositingLayer(CoordinatedLayerID);
>+    void setRootCompositingLayer(CoordinatedLayerID);
>     void setContentsSize(const WebCore::FloatSize&);
>     void setVisibleContentsRect(const WebCore::FloatRect&, float scale, const WebCore::FloatPoint& trajectoryVector);
>     void didRenderFrame(const WebCore::IntSize& contentsSize, const WebCore::IntRect& coveredRect);
>-    void createTileForLayer(WebLayerID, uint32_t tileID, const WebCore::IntRect&, const SurfaceUpdateInfo&);
>-    void updateTileForLayer(WebLayerID, uint32_t tileID, const WebCore::IntRect&, const SurfaceUpdateInfo&);
>-    void removeTileForLayer(WebLayerID, uint32_t tileID);
>+    void createTileForLayer(CoordinatedLayerID, uint32_t tileID, const WebCore::IntRect&, const SurfaceUpdateInfo&);
>+    void updateTileForLayer(CoordinatedLayerID, uint32_t tileID, const WebCore::IntRect&, const SurfaceUpdateInfo&);
>+    void removeTileForLayer(CoordinatedLayerID, uint32_t tileID);
>     void createUpdateAtlas(int atlasID, const ShareableSurface::Handle&);
>     void removeUpdateAtlas(int atlasID);
>     void createImageBacking(CoordinatedImageBackingID);
>@@ -80,13 +80,13 @@ public:
>     void renderNextFrame();
>     void didChangeScrollPosition(const WebCore::IntPoint& position);
> #if USE(GRAPHICS_SURFACE)
>-    void createCanvas(WebLayerID, const WebCore::IntSize&, const WebCore::GraphicsSurfaceToken&);
>-    void syncCanvas(WebLayerID, uint32_t frontBuffer);
>-    void destroyCanvas(WebLayerID);
>+    void createCanvas(CoordinatedLayerID, const WebCore::IntSize&, const WebCore::GraphicsSurfaceToken&);
>+    void syncCanvas(CoordinatedLayerID, uint32_t frontBuffer);
>+    void destroyCanvas(CoordinatedLayerID);
> #endif
>     void purgeBackingStores();
>     LayerTreeRenderer* layerTreeRenderer() const { return m_renderer.get(); }
>-    void setLayerAnimations(WebLayerID, const WebCore::GraphicsLayerAnimations&);
>+    void setLayerAnimations(CoordinatedLayerID, const WebCore::GraphicsLayerAnimations&);
>     void setAnimationsLocked(bool);
> #if ENABLE(REQUEST_ANIMATION_FRAME)
>     void requestAnimationFrame();
>diff --git a/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.messages.in b/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.messages.in
>index 35c19fff860c59e95485f8cb5d36e41169f998c3..8f7ac5a3706a73c5c376a321ce694e9f0c26b5c8 100644
>--- a/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.messages.in
>+++ b/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.messages.in
>@@ -19,7 +19,7 @@
> 
> #if USE(COORDINATED_GRAPHICS)
> messages -> LayerTreeCoordinatorProxy {
>-    SetCompositingLayerState(uint32_t id, WebKit::WebLayerInfo layerInfo)
>+    SetCompositingLayerState(uint32_t id, WebKit::CoordinatedLayerInfo layerInfo)
>     SetCompositingLayerChildren(uint32_t id, Vector<uint32_t> children)
> #if ENABLE(CSS_FILTERS)
>     SetCompositingLayerFilters(uint32_t id, WebCore::FilterOperations filters)
>diff --git a/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeRenderer.cpp b/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeRenderer.cpp
>index 91f66c289d5d224fc00dc450e7ecf1349503497d..3d9d7829799eeaceb57b28a2817c997ea12ecb49 100644
>--- a/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeRenderer.cpp
>+++ b/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeRenderer.cpp
>@@ -74,7 +74,7 @@ static bool layerShouldHaveBackingStore(GraphicsLayer* layer)
> LayerTreeRenderer::LayerTreeRenderer(LayerTreeCoordinatorProxy* layerTreeCoordinatorProxy)
>     : m_layerTreeCoordinatorProxy(layerTreeCoordinatorProxy)
>     , m_isActive(false)
>-    , m_rootLayerID(InvalidWebLayerID)
>+    , m_rootLayerID(InvalidCoordinatedLayerID)
>     , m_animationsLocked(false)
> #if ENABLE(REQUEST_ANIMATION_FRAME)
>     , m_animationFrameRequested(false)
>@@ -89,7 +89,7 @@ LayerTreeRenderer::~LayerTreeRenderer()
> {
> }
> 
>-PassOwnPtr<GraphicsLayer> LayerTreeRenderer::createLayer(WebLayerID)
>+PassOwnPtr<GraphicsLayer> LayerTreeRenderer::createLayer(CoordinatedLayerID)
> {
>     GraphicsLayerTextureMapper* newLayer = new GraphicsLayerTextureMapper(this);
>     newLayer->setHasOwnBackingStore(false);
>@@ -227,7 +227,7 @@ void LayerTreeRenderer::didChangeScrollPosition(const IntPoint& position)
> }
> 
> #if USE(GRAPHICS_SURFACE)
>-void LayerTreeRenderer::createCanvas(WebLayerID id, const WebCore::IntSize& canvasSize, PassRefPtr<GraphicsSurface> surface)
>+void LayerTreeRenderer::createCanvas(CoordinatedLayerID id, const WebCore::IntSize& canvasSize, PassRefPtr<GraphicsSurface> surface)
> {
>     ASSERT(m_textureMapper);
>     GraphicsLayer* layer = layerByID(id);
>@@ -241,7 +241,7 @@ void LayerTreeRenderer::createCanvas(WebLayerID id, const WebCore::IntSize& canv
>     layer->setContentsToMedia(canvasBackingStore.get());
> }
> 
>-void LayerTreeRenderer::syncCanvas(WebLayerID id, uint32_t frontBuffer)
>+void LayerTreeRenderer::syncCanvas(CoordinatedLayerID id, uint32_t frontBuffer)
> {
>     ASSERT(m_textureMapper);
>     ASSERT(m_surfaceBackingStores.contains(id));
>@@ -252,7 +252,7 @@ void LayerTreeRenderer::syncCanvas(WebLayerID id, uint32_t frontBuffer)
>     canvasBackingStore->swapBuffersIfNeeded(frontBuffer);
> }
> 
>-void LayerTreeRenderer::destroyCanvas(WebLayerID id)
>+void LayerTreeRenderer::destroyCanvas(CoordinatedLayerID id)
> {
>     ASSERT(m_textureMapper);
>     GraphicsLayer* layer = layerByID(id);
>@@ -264,13 +264,13 @@ void LayerTreeRenderer::destroyCanvas(WebLayerID id)
> }
> #endif
> 
>-void LayerTreeRenderer::setLayerChildren(WebLayerID id, const Vector<WebLayerID>& childIDs)
>+void LayerTreeRenderer::setLayerChildren(CoordinatedLayerID id, const Vector<CoordinatedLayerID>& childIDs)
> {
>     GraphicsLayer* layer = ensureLayer(id);
>     Vector<GraphicsLayer*> children;
> 
>     for (size_t i = 0; i < childIDs.size(); ++i) {
>-        WebLayerID childID = childIDs[i];
>+        CoordinatedLayerID childID = childIDs[i];
>         GraphicsLayer* child = layerByID(childID);
>         if (!child) {
>             OwnPtr<GraphicsLayer*> newChild = createLayer(childID);
>@@ -283,7 +283,7 @@ void LayerTreeRenderer::setLayerChildren(WebLayerID id, const Vector<WebLayerID>
> }
> 
> #if ENABLE(CSS_FILTERS)
>-void LayerTreeRenderer::setLayerFilters(WebLayerID id, const FilterOperations& filters)
>+void LayerTreeRenderer::setLayerFilters(CoordinatedLayerID id, const FilterOperations& filters)
> {
>     GraphicsLayer* layer = ensureLayer(id);
> 
>@@ -326,7 +326,7 @@ void LayerTreeRenderer::removeCustomFilterProgram(int id)
> }
> #endif // ENABLE(CSS_SHADERS)
> 
>-void LayerTreeRenderer::setLayerState(WebLayerID id, const WebLayerInfo& layerInfo)
>+void LayerTreeRenderer::setLayerState(CoordinatedLayerID id, const CoordinatedLayerInfo& layerInfo)
> {
>     GraphicsLayer* layer = ensureLayer(id);
> 
>@@ -361,7 +361,7 @@ void LayerTreeRenderer::setLayerState(WebLayerID id, const WebLayerInfo& layerIn
>         setRootLayerID(id);
> }
> 
>-void LayerTreeRenderer::deleteLayer(WebLayerID layerID)
>+void LayerTreeRenderer::deleteLayer(CoordinatedLayerID layerID)
> {
>     OwnPtr<GraphicsLayer> layer = m_layers.take(layerID);
>     if (!layer)
>@@ -376,7 +376,7 @@ void LayerTreeRenderer::deleteLayer(WebLayerID layerID)
> }
> 
> 
>-WebCore::GraphicsLayer* LayerTreeRenderer::ensureLayer(WebLayerID id)
>+WebCore::GraphicsLayer* LayerTreeRenderer::ensureLayer(CoordinatedLayerID id)
> {
>     LayerMap::iterator it = m_layers.find(id);
>     if (it != m_layers.end())
>@@ -389,7 +389,7 @@ WebCore::GraphicsLayer* LayerTreeRenderer::ensureLayer(WebLayerID id)
>     return layer;
> }
> 
>-void LayerTreeRenderer::setRootLayerID(WebLayerID layerID)
>+void LayerTreeRenderer::setRootLayerID(CoordinatedLayerID layerID)
> {
>     if (layerID == m_rootLayerID)
>         return;
>@@ -484,7 +484,7 @@ void LayerTreeRenderer::resetBackingStoreSizeToLayerSize(GraphicsLayer* graphics
>     backingStore->setSize(graphicsLayer->size());
> }
> 
>-void LayerTreeRenderer::createTile(WebLayerID layerID, uint32_t tileID, float scale)
>+void LayerTreeRenderer::createTile(CoordinatedLayerID layerID, uint32_t tileID, float scale)
> {
>     GraphicsLayer* layer = layerByID(layerID);
>     ASSERT(layer);
>@@ -494,7 +494,7 @@ void LayerTreeRenderer::createTile(WebLayerID layerID, uint32_t tileID, float sc
>     resetBackingStoreSizeToLayerSize(layer);
> }
> 
>-void LayerTreeRenderer::removeTile(WebLayerID layerID, uint32_t tileID)
>+void LayerTreeRenderer::removeTile(CoordinatedLayerID layerID, uint32_t tileID)
> {
>     GraphicsLayer* layer = layerByID(layerID);
>     ASSERT(layer);
>@@ -507,7 +507,7 @@ void LayerTreeRenderer::removeTile(WebLayerID layerID, uint32_t tileID)
>     m_backingStoresWithPendingBuffers.add(backingStore);
> }
> 
>-void LayerTreeRenderer::updateTile(WebLayerID layerID, uint32_t tileID, const TileUpdate& update)
>+void LayerTreeRenderer::updateTile(CoordinatedLayerID layerID, uint32_t tileID, const TileUpdate& update)
> {
>     GraphicsLayer* layer = layerByID(layerID);
>     ASSERT(layer);
>@@ -619,7 +619,7 @@ void LayerTreeRenderer::ensureRootLayer()
>     if (m_rootLayer)
>         return;
> 
>-    m_rootLayer = createLayer(InvalidWebLayerID);
>+    m_rootLayer = createLayer(InvalidCoordinatedLayerID);
>     m_rootLayer->setMasksToBounds(false);
>     m_rootLayer->setDrawsContent(false);
>     m_rootLayer->setAnchorPoint(FloatPoint3D(0, 0, 0));
>@@ -662,7 +662,7 @@ void LayerTreeRenderer::purgeGLResources()
> 
>     m_rootLayer->removeAllChildren();
>     m_rootLayer.clear();
>-    m_rootLayerID = InvalidWebLayerID;
>+    m_rootLayerID = InvalidCoordinatedLayerID;
>     m_layers.clear();
>     m_fixedLayers.clear();
>     m_textureMapper.clear();
>@@ -679,7 +679,7 @@ void LayerTreeRenderer::purgeBackingStores()
>         m_layerTreeCoordinatorProxy->purgeBackingStores();
> }
> 
>-void LayerTreeRenderer::setLayerAnimations(WebLayerID id, const GraphicsLayerAnimations& animations)
>+void LayerTreeRenderer::setLayerAnimations(CoordinatedLayerID id, const GraphicsLayerAnimations& animations)
> {
>     GraphicsLayerTextureMapper* layer = toGraphicsLayerTextureMapper(layerByID(id));
>     if (!layer)
>diff --git a/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeRenderer.h b/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeRenderer.h
>index a03c9820ccf473a5d906a38f2aba28504c9d6b90..99123f027c3ae29557e5560999925fd0a3879c8b 100644
>--- a/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeRenderer.h
>+++ b/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeRenderer.h
>@@ -22,10 +22,10 @@
> 
> #if USE(COORDINATED_GRAPHICS)
> #include "BackingStore.h"
>+#include "CoordinatedLayerInfo.h"
> #include "ShareableSurface.h"
> #include "TextureMapper.h"
> #include "TextureMapperBackingStore.h"
>-#include "WebLayerTreeInfo.h"
> #include <WebCore/GraphicsContext.h>
> #include <WebCore/GraphicsLayer.h>
> #include <WebCore/GraphicsLayerAnimation.h>
>@@ -48,8 +48,8 @@ namespace WebKit {
> 
> class CoordinatedBackingStore;
> class LayerTreeCoordinatorProxy;
>-class WebLayerInfo;
>-class WebLayerUpdateInfo;
>+class CoordinatedLayerInfo;
>+class CoordinatedLayerUpdateInfo;
> 
> class LayerTreeRenderer : public ThreadSafeRefCounted<LayerTreeRenderer>, public WebCore::GraphicsLayerClient {
> public:
>@@ -74,9 +74,9 @@ public:
>     void setVisibleContentsRect(const WebCore::FloatRect&);
>     void didChangeScrollPosition(const WebCore::IntPoint& position);
> #if USE(GRAPHICS_SURFACE)
>-    void createCanvas(WebLayerID, const WebCore::IntSize&, PassRefPtr<WebCore::GraphicsSurface>);
>-    void syncCanvas(WebLayerID, uint32_t frontBuffer);
>-    void destroyCanvas(WebLayerID);
>+    void createCanvas(CoordinatedLayerID, const WebCore::IntSize&, PassRefPtr<WebCore::GraphicsSurface>);
>+    void syncCanvas(CoordinatedLayerID, uint32_t frontBuffer);
>+    void destroyCanvas(CoordinatedLayerID);
> #endif
> 
>     void detach();
>@@ -87,12 +87,12 @@ public:
>     void purgeGLResources();
>     void setActive(bool);
> 
>-    void deleteLayer(WebLayerID);
>-    void setRootLayerID(WebLayerID);
>-    void setLayerChildren(WebLayerID, const Vector<WebLayerID>&);
>-    void setLayerState(WebLayerID, const WebLayerInfo&);
>+    void deleteLayer(CoordinatedLayerID);
>+    void setRootLayerID(CoordinatedLayerID);
>+    void setLayerChildren(CoordinatedLayerID, const Vector<CoordinatedLayerID>&);
>+    void setLayerState(CoordinatedLayerID, const CoordinatedLayerInfo&);
> #if ENABLE(CSS_FILTERS)
>-    void setLayerFilters(WebLayerID, const WebCore::FilterOperations&);
>+    void setLayerFilters(CoordinatedLayerID, const WebCore::FilterOperations&);
> #endif
> #if ENABLE(CSS_SHADERS)
>     void injectCachedCustomFilterPrograms(const WebCore::FilterOperations& filters) const;
>@@ -100,15 +100,15 @@ public:
>     void removeCustomFilterProgram(int id);
> #endif
> 
>-    void createTile(WebLayerID, uint32_t tileID, float scale);
>-    void removeTile(WebLayerID, uint32_t tileID);
>-    void updateTile(WebLayerID, uint32_t tileID, const TileUpdate&);
>+    void createTile(CoordinatedLayerID, uint32_t tileID, float scale);
>+    void removeTile(CoordinatedLayerID, uint32_t tileID);
>+    void updateTile(CoordinatedLayerID, uint32_t tileID, const TileUpdate&);
>     void flushLayerChanges();
>     void createImageBacking(CoordinatedImageBackingID);
>     void updateImageBacking(CoordinatedImageBackingID, PassRefPtr<ShareableSurface>);
>     void clearImageBackingContents(CoordinatedImageBackingID);
>     void removeImageBacking(CoordinatedImageBackingID);
>-    void setLayerAnimations(WebLayerID, const WebCore::GraphicsLayerAnimations&);
>+    void setLayerAnimations(CoordinatedLayerID, const WebCore::GraphicsLayerAnimations&);
>     void setAnimationsLocked(bool);
>     void setBackgroundColor(const WebCore::Color&);
>     void setDrawsBackground(bool enable) { m_setDrawsBackground = enable; }
>@@ -118,9 +118,9 @@ public:
> #endif
> 
> private:
>-    PassOwnPtr<WebCore::GraphicsLayer> createLayer(WebLayerID);
>+    PassOwnPtr<WebCore::GraphicsLayer> createLayer(CoordinatedLayerID);
> 
>-    WebCore::GraphicsLayer* layerByID(WebLayerID id) { return (id == InvalidWebLayerID) ? 0 : m_layers.get(id); }
>+    WebCore::GraphicsLayer* layerByID(CoordinatedLayerID id) { return (id == InvalidCoordinatedLayerID) ? 0 : m_layers.get(id); }
>     WebCore::GraphicsLayer* rootLayer() { return m_rootLayer.get(); }
> 
>     void syncRemoteContent();
>@@ -142,7 +142,7 @@ private:
>     void assignImageBackingToLayer(WebCore::GraphicsLayer*, CoordinatedImageBackingID);
>     void removeReleasedImageBackingsIfNeeded();
>     void ensureRootLayer();
>-    WebCore::GraphicsLayer* ensureLayer(WebLayerID);
>+    WebCore::GraphicsLayer* ensureLayer(CoordinatedLayerID);
>     void commitPendingBackingStoreOperations();
> 
>     CoordinatedBackingStore* getBackingStore(WebCore::GraphicsLayer*);
>@@ -170,7 +170,7 @@ private:
>     HashSet<RefPtr<CoordinatedBackingStore> > m_backingStoresWithPendingBuffers;
> 
> #if USE(GRAPHICS_SURFACE)
>-    typedef HashMap<WebLayerID, RefPtr<WebCore::TextureMapperSurfaceBackingStore> > SurfaceBackingStoreMap;
>+    typedef HashMap<CoordinatedLayerID, RefPtr<WebCore::TextureMapperSurfaceBackingStore> > SurfaceBackingStoreMap;
>     SurfaceBackingStoreMap m_surfaceBackingStores;
> #endif
> 
>@@ -180,11 +180,11 @@ private:
> 
>     OwnPtr<WebCore::GraphicsLayer> m_rootLayer;
> 
>-    typedef HashMap<WebLayerID, OwnPtr<WebCore::GraphicsLayer> > LayerMap;
>+    typedef HashMap<CoordinatedLayerID, OwnPtr<WebCore::GraphicsLayer> > LayerMap;
>     LayerMap m_layers;
>-    typedef HashMap<WebLayerID, WebCore::GraphicsLayer*> LayerRawPtrMap;
>+    typedef HashMap<CoordinatedLayerID, WebCore::GraphicsLayer*> LayerRawPtrMap;
>     LayerRawPtrMap m_fixedLayers;
>-    WebLayerID m_rootLayerID;
>+    CoordinatedLayerID m_rootLayerID;
>     WebCore::IntPoint m_renderedContentsScrollPosition;
>     WebCore::IntPoint m_pendingRenderedContentsScrollPosition;
>     bool m_animationsLocked;
>diff --git a/Source/WebKit2/UIProcess/DrawingAreaProxy.h b/Source/WebKit2/UIProcess/DrawingAreaProxy.h
>index c4ed068b4124cf2fd8eff707115301d9b69dc684..d6799dd5be90bba32c13e1795ae5143f01f9ec06 100644
>--- a/Source/WebKit2/UIProcess/DrawingAreaProxy.h
>+++ b/Source/WebKit2/UIProcess/DrawingAreaProxy.h
>@@ -50,8 +50,6 @@ namespace WebKit {
> class LayerTreeContext;
> class LayerTreeCoordinatorProxy;
> class UpdateInfo;
>-class WebLayerTreeInfo;
>-class WebLayerUpdateInfo;
> class WebPageProxy;
> 
> class DrawingAreaProxy {
>diff --git a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp
>index cda0f43ea30186d96056ba73e71ce93bbafd2b8e..9d3cf2481c468c64b7eebda72ce40415f18861b7 100644
>--- a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp
>+++ b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp
>@@ -42,13 +42,13 @@ using namespace WebKit;
> 
> namespace WebCore {
> 
>-static HashMap<WebLayerID, CoordinatedGraphicsLayer*>& layerByIDMap()
>+static HashMap<CoordinatedLayerID, CoordinatedGraphicsLayer*>& layerByIDMap()
> {
>-    static HashMap<WebLayerID, CoordinatedGraphicsLayer*> globalMap;
>+    static HashMap<CoordinatedLayerID, CoordinatedGraphicsLayer*> globalMap;
>     return globalMap;
> }
> 
>-static WebLayerID toWebLayerID(GraphicsLayer* layer)
>+static CoordinatedLayerID toCoordinatedLayerID(GraphicsLayer* layer)
> {
>     return layer ? toCoordinatedGraphicsLayer(layer)->id() : 0;
> }
>@@ -124,7 +124,7 @@ CoordinatedGraphicsLayer::CoordinatedGraphicsLayer(GraphicsLayerClient* client)
>     , m_canvasPlatformLayer(0)
>     , m_animationStartedTimer(this, &CoordinatedGraphicsLayer::animationStartedTimerFired)
> {
>-    static WebLayerID nextLayerID = 1;
>+    static CoordinatedLayerID nextLayerID = 1;
>     m_id = nextLayerID++;
>     layerByIDMap().add(id(), this);
> }
>@@ -431,7 +431,7 @@ void CoordinatedGraphicsLayer::setNeedsDisplayInRect(const FloatRect& rect)
>     didChangeLayerState();
> }
> 
>-WebLayerID CoordinatedGraphicsLayer::id() const
>+CoordinatedLayerID CoordinatedGraphicsLayer::id() const
> {
>     return m_id;
> }
>@@ -462,9 +462,9 @@ void CoordinatedGraphicsLayer::syncChildren()
>     if (!m_shouldSyncChildren)
>         return;
>     m_shouldSyncChildren = false;
>-    Vector<WebLayerID> childIDs;
>+    Vector<CoordinatedLayerID> childIDs;
>     for (size_t i = 0; i < children().size(); ++i)
>-        childIDs.append(toWebLayerID(children()[i]));
>+        childIDs.append(toCoordinatedLayerID(children()[i]));
> 
>     m_coordinator->syncLayerChildren(m_id, childIDs);
> }
>@@ -521,12 +521,12 @@ void CoordinatedGraphicsLayer::syncLayerState()
>     m_layerInfo.contentsRect = contentsRect();
>     m_layerInfo.drawsContent = drawsContent();
>     m_layerInfo.contentsVisible = contentsAreVisible();
>-    m_layerInfo.mask = toWebLayerID(maskLayer());
>+    m_layerInfo.mask = toCoordinatedLayerID(maskLayer());
>     m_layerInfo.masksToBounds = masksToBounds();
>     m_layerInfo.opacity = opacity();
>     m_layerInfo.pos = position();
>     m_layerInfo.preserves3D = preserves3D();
>-    m_layerInfo.replica = toWebLayerID(replicaLayer());
>+    m_layerInfo.replica = toCoordinatedLayerID(replicaLayer());
>     m_layerInfo.size = size();
>     m_layerInfo.transform = transform();
>     m_coordinator->syncLayerState(m_id, m_layerInfo);
>diff --git a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.h b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.h
>index f7b7286b3be05d24d4afe2b61e68825bf525df06..d93a3b70597034786bcc168cb02ddb5b4855a051 100644
>--- a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.h
>+++ b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.h
>@@ -22,6 +22,7 @@
> #define CoordinatedGraphicsLayer_h
> 
> #include "CoordinatedImageBacking.h"
>+#include "CoordinatedLayerInfo.h"
> #include "CoordinatedTile.h"
> #include "FloatPoint3D.h"
> #include "GraphicsLayer.h"
>@@ -34,7 +35,6 @@
> #include "TiledBackingStoreClient.h"
> #include "TransformationMatrix.h"
> #include "UpdateInfo.h"
>-#include "WebLayerTreeInfo.h"
> #include "WebProcess.h"
> #if USE(GRAPHICS_SURFACE)
> #include <WebCore/GraphicsSurfaceToken.h>
>@@ -53,25 +53,25 @@ namespace WebKit {
> class CoordinatedGraphicsLayerClient {
> public:
>     // CoordinatedTileClient
>-    virtual void createTile(WebLayerID, uint32_t tileID, const SurfaceUpdateInfo&, const WebCore::IntRect&) = 0;
>-    virtual void updateTile(WebLayerID, uint32_t tileID, const SurfaceUpdateInfo&, const WebCore::IntRect&) = 0;
>-    virtual void removeTile(WebLayerID, uint32_t tileID) = 0;
>+    virtual void createTile(CoordinatedLayerID, uint32_t tileID, const SurfaceUpdateInfo&, const WebCore::IntRect&) = 0;
>+    virtual void updateTile(CoordinatedLayerID, uint32_t tileID, const SurfaceUpdateInfo&, const WebCore::IntRect&) = 0;
>+    virtual void removeTile(CoordinatedLayerID, uint32_t tileID) = 0;
> 
>     virtual WebCore::IntRect visibleContentsRect() const = 0;
>     virtual bool layerTreeTileUpdatesAllowed() const = 0;
>     virtual PassRefPtr<CoordinatedImageBacking> createImageBackingIfNeeded(WebCore::Image*) = 0;
>-    virtual void syncLayerState(WebLayerID, const WebLayerInfo&) = 0;
>-    virtual void syncLayerChildren(WebLayerID, const Vector<WebLayerID>&) = 0;
>+    virtual void syncLayerState(CoordinatedLayerID, const CoordinatedLayerInfo&) = 0;
>+    virtual void syncLayerChildren(CoordinatedLayerID, const Vector<CoordinatedLayerID>&) = 0;
> #if ENABLE(CSS_FILTERS)
>-    virtual void syncLayerFilters(WebLayerID, const WebCore::FilterOperations&) = 0;
>+    virtual void syncLayerFilters(CoordinatedLayerID, const WebCore::FilterOperations&) = 0;
> #endif
> #if USE(GRAPHICS_SURFACE)
>-    virtual void createCanvas(WebLayerID, WebCore::PlatformLayer*) = 0;
>-    virtual void syncCanvas(WebLayerID, WebCore::PlatformLayer*) = 0;
>-    virtual void destroyCanvas(WebLayerID) = 0;
>+    virtual void createCanvas(CoordinatedLayerID, WebCore::PlatformLayer*) = 0;
>+    virtual void syncCanvas(CoordinatedLayerID, WebCore::PlatformLayer*) = 0;
>+    virtual void destroyCanvas(CoordinatedLayerID) = 0;
> #endif
> 
>-    virtual void setLayerAnimations(WebLayerID, const WebCore::GraphicsLayerAnimations&) = 0;
>+    virtual void setLayerAnimations(CoordinatedLayerID, const WebCore::GraphicsLayerAnimations&) = 0;
> 
>     virtual void detachLayer(WebCore::CoordinatedGraphicsLayer*) = 0;
>     virtual void syncFixedLayers() = 0;
>@@ -134,7 +134,7 @@ public:
> 
>     void setRootLayer(bool);
> 
>-    WebKit::WebLayerID id() const;
>+    WebKit::CoordinatedLayerID id() const;
> 
>     void setFixedToViewport(bool isFixed) { m_fixedToViewport = isFixed; }
> 
>@@ -205,8 +205,8 @@ private:
> 
>     void animationStartedTimerFired(Timer<CoordinatedGraphicsLayer>*);
> 
>-    WebKit::WebLayerID m_id;
>-    WebKit::WebLayerInfo m_layerInfo;
>+    WebKit::CoordinatedLayerID m_id;
>+    WebKit::CoordinatedLayerInfo m_layerInfo;
>     GraphicsLayerTransform m_layerTransform;
>     TransformationMatrix m_cachedInverseTransform;
>     bool m_inUpdateMode : 1;
>diff --git a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedImageBacking.h b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedImageBacking.h
>index 76266a4b4140b9437b1172537570a7f2007910dd..65e824672b939f8ac85cf0ae465db82c3739069a 100644
>--- a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedImageBacking.h
>+++ b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedImageBacking.h
>@@ -28,9 +28,9 @@
> #define CoordinatedImageBacking_h
> 
> #if USE(COORDINATED_GRAPHICS)
>+#include "CoordinatedLayerInfo.h"
> #include "Image.h"
> #include "ShareableSurface.h"
>-#include "WebLayerTreeInfo.h"
> #include <WebCore/Timer.h>
> #include <wtf/RefCounted.h>
> #include <wtf/Vector.h>
>diff --git a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp
>index abc2c0f13f4e3d52a74ec275f63fa60f5e052037..c985d11b3a6e006c3ff2600ad23d0bc909a70426 100644
>--- a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp
>+++ b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp
>@@ -1,4 +1,4 @@
>-    /*
>+/*
>  * Copyright (C) 2011 Apple Inc. All rights reserved.
>  * Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
>  *
>@@ -99,14 +99,14 @@ LayerTreeCoordinator::LayerTreeCoordinator(WebPage* webPage)
> {
>     // Create a root layer.
>     m_rootLayer = GraphicsLayer::create(this, this);
>-    CoordinatedGraphicsLayer* webRootLayer = toCoordinatedGraphicsLayer(m_rootLayer.get());
>-    webRootLayer->setRootLayer(true);
>+    CoordinatedGraphicsLayer* coordinatedRootLayer = toCoordinatedGraphicsLayer(m_rootLayer.get());
>+    coordinatedRootLayer->setRootLayer(true);
> #ifndef NDEBUG
>     m_rootLayer->setName("LayerTreeCoordinator root layer");
> #endif
>     m_rootLayer->setDrawsContent(false);
>     m_rootLayer->setSize(m_webPage->size());
>-    m_layerTreeContext.webLayerID = toCoordinatedGraphicsLayer(webRootLayer)->id();
>+    m_layerTreeContext.coordinatedLayerID = toCoordinatedGraphicsLayer(coordinatedRootLayer)->id();
> 
>     m_nonCompositedContentLayer = GraphicsLayer::create(this, this);
> #ifndef NDEBUG
>@@ -306,7 +306,7 @@ bool LayerTreeCoordinator::flushPendingLayerChanges()
>     return didSync;
> }
> 
>-void LayerTreeCoordinator::syncLayerState(WebLayerID id, const WebLayerInfo& info)
>+void LayerTreeCoordinator::syncLayerState(CoordinatedLayerID id, const CoordinatedLayerInfo& info)
> {
>     if (m_shouldSendScrollPositionUpdate) {
>         m_webPage->send(Messages::LayerTreeCoordinatorProxy::DidChangeScrollPosition(m_visibleContentsRect.location()));
>@@ -317,14 +317,14 @@ void LayerTreeCoordinator::syncLayerState(WebLayerID id, const WebLayerInfo& inf
>     m_webPage->send(Messages::LayerTreeCoordinatorProxy::SetCompositingLayerState(id, info));
> }
> 
>-void LayerTreeCoordinator::syncLayerChildren(WebLayerID id, const Vector<WebLayerID>& children)
>+void LayerTreeCoordinator::syncLayerChildren(CoordinatedLayerID id, const Vector<CoordinatedLayerID>& children)
> {
>     m_shouldSyncFrame = true;
>     m_webPage->send(Messages::LayerTreeCoordinatorProxy::SetCompositingLayerChildren(id, children));
> }
> 
> #if USE(GRAPHICS_SURFACE)
>-void LayerTreeCoordinator::createCanvas(WebLayerID id, PlatformLayer* canvasPlatformLayer)
>+void LayerTreeCoordinator::createCanvas(CoordinatedLayerID id, PlatformLayer* canvasPlatformLayer)
> {
>     m_shouldSyncFrame = true;
>     GraphicsSurfaceToken token = canvasPlatformLayer->graphicsSurfaceToken();
>@@ -332,14 +332,14 @@ void LayerTreeCoordinator::createCanvas(WebLayerID id, PlatformLayer* canvasPlat
>     m_webPage->send(Messages::LayerTreeCoordinatorProxy::CreateCanvas(id, canvasSize, token));
> }
> 
>-void LayerTreeCoordinator::syncCanvas(WebLayerID id, PlatformLayer* canvasPlatformLayer)
>+void LayerTreeCoordinator::syncCanvas(CoordinatedLayerID id, PlatformLayer* canvasPlatformLayer)
> {
>     m_shouldSyncFrame = true;
>     uint32_t frontBuffer = canvasPlatformLayer->copyToGraphicsSurface();
>     m_webPage->send(Messages::LayerTreeCoordinatorProxy::SyncCanvas(id, frontBuffer));
> }
> 
>-void LayerTreeCoordinator::destroyCanvas(WebLayerID id)
>+void LayerTreeCoordinator::destroyCanvas(CoordinatedLayerID id)
> {
>     if (m_isPurging)
>         return;
>@@ -350,7 +350,7 @@ void LayerTreeCoordinator::destroyCanvas(WebLayerID id)
> #endif
> 
> #if ENABLE(CSS_FILTERS)
>-void LayerTreeCoordinator::syncLayerFilters(WebLayerID id, const FilterOperations& filters)
>+void LayerTreeCoordinator::syncLayerFilters(CoordinatedLayerID id, const FilterOperations& filters)
> {
>     m_shouldSyncFrame = true;
> #if ENABLE(CSS_SHADERS)
>@@ -639,19 +639,19 @@ bool LayerTreeHost::supportsAcceleratedCompositing()
>     return true;
> }
> 
>-void LayerTreeCoordinator::createTile(WebLayerID layerID, uint32_t tileID, const SurfaceUpdateInfo& updateInfo, const WebCore::IntRect& tileRect)
>+void LayerTreeCoordinator::createTile(CoordinatedLayerID layerID, uint32_t tileID, const SurfaceUpdateInfo& updateInfo, const WebCore::IntRect& tileRect)
> {
>     m_shouldSyncFrame = true;
>     m_webPage->send(Messages::LayerTreeCoordinatorProxy::CreateTileForLayer(layerID, tileID, tileRect, updateInfo));
> }
> 
>-void LayerTreeCoordinator::updateTile(WebLayerID layerID, uint32_t tileID, const SurfaceUpdateInfo& updateInfo, const WebCore::IntRect& tileRect)
>+void LayerTreeCoordinator::updateTile(CoordinatedLayerID layerID, uint32_t tileID, const SurfaceUpdateInfo& updateInfo, const WebCore::IntRect& tileRect)
> {
>     m_shouldSyncFrame = true;
>     m_webPage->send(Messages::LayerTreeCoordinatorProxy::UpdateTileForLayer(layerID, tileID, tileRect, updateInfo));
> }
> 
>-void LayerTreeCoordinator::removeTile(WebLayerID layerID, uint32_t tileID)
>+void LayerTreeCoordinator::removeTile(CoordinatedLayerID layerID, uint32_t tileID)
> {
>     if (m_isPurging)
>         return;
>@@ -677,7 +677,7 @@ WebCore::IntRect LayerTreeCoordinator::visibleContentsRect() const
> }
> 
> 
>-void LayerTreeCoordinator::setLayerAnimations(WebLayerID layerID, const GraphicsLayerAnimations& animations)
>+void LayerTreeCoordinator::setLayerAnimations(CoordinatedLayerID layerID, const GraphicsLayerAnimations& animations)
> {
>     m_shouldSyncFrame = true;
>     GraphicsLayerAnimations activeAnimations = animations.getActiveAnimations();
>diff --git a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.h b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.h
>index 4d295239b7d3812f198b44c167057019be61b146..268a8a91c24d26f3c2e9e972d8b5e74e927f485f 100644
>--- a/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.h
>+++ b/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.h
>@@ -78,9 +78,9 @@ public:
>     virtual void deviceScaleFactorDidChange() { }
>     virtual PassRefPtr<CoordinatedImageBacking> createImageBackingIfNeeded(WebCore::Image*) OVERRIDE;
> 
>-    virtual void createTile(WebLayerID, uint32_t tileID, const SurfaceUpdateInfo&, const WebCore::IntRect&);
>-    virtual void updateTile(WebLayerID, uint32_t tileID, const SurfaceUpdateInfo&, const WebCore::IntRect&);
>-    virtual void removeTile(WebLayerID, uint32_t tileID);
>+    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::IntRect visibleContentsRect() const;
>     virtual void renderNextFrame();
>     virtual void purgeBackingStores();
>@@ -89,16 +89,16 @@ public:
>     virtual void didReceiveLayerTreeCoordinatorMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::MessageDecoder&);
>     virtual WebCore::GraphicsLayerFactory* graphicsLayerFactory() OVERRIDE;
> 
>-    virtual void syncLayerState(WebLayerID, const WebLayerInfo&);
>-    virtual void syncLayerChildren(WebLayerID, const Vector<WebLayerID>&);
>-    virtual void setLayerAnimations(WebLayerID, const WebCore::GraphicsLayerAnimations&);
>+    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(WebLayerID, const WebCore::FilterOperations&);
>+    virtual void syncLayerFilters(CoordinatedLayerID, const WebCore::FilterOperations&);
> #endif
> #if USE(GRAPHICS_SURFACE)
>-    virtual void createCanvas(WebLayerID, WebCore::PlatformLayer*) OVERRIDE;
>-    virtual void syncCanvas(WebLayerID, WebCore::PlatformLayer*) OVERRIDE;
>-    virtual void destroyCanvas(WebLayerID) OVERRIDE;
>+    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();
>@@ -171,7 +171,7 @@ private:
>     OwnPtr<WebCore::GraphicsLayer> m_pageOverlayLayer;
> 
>     HashSet<WebCore::CoordinatedGraphicsLayer*> m_registeredLayers;
>-    Vector<WebLayerID> m_detachedLayers;
>+    Vector<CoordinatedLayerID> m_detachedLayers;
>     typedef HashMap<CoordinatedImageBackingID, RefPtr<CoordinatedImageBacking> > ImageBackingMap;
>     ImageBackingMap m_imageBackings;
>     Vector<OwnPtr<UpdateAtlas> > m_updateAtlases;

Actions: View | Formatted Diff | Diff

Attachments on bug 103983: 177444 | 177695 | 177914 | 178111