[Qt] UI_SIDE_COMPOSITING code has confusing names
authornoam.rosenthal@nokia.com <noam.rosenthal@nokia.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 4 Aug 2012 17:52:35 +0000 (17:52 +0000)
committernoam.rosenthal@nokia.com <noam.rosenthal@nokia.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 4 Aug 2012 17:52:35 +0000 (17:52 +0000)
https://bugs.webkit.org/show_bug.cgi?id=93164

Reviewed by Kenneth Rohde Christiansen.

Source/WebKit2:

Renamed and consolidated code guarded under UI_SIDE_COMPOSITING, now under
USE(COORDINATED_GRAPHICS) guard and CoordinatedGraphics folders.

* CMakeLists.txt:
* DerivedSources.pri:
* Shared/WebCoreArgumentCoders.cpp:
(CoreIPC):
* Shared/WebCoreArgumentCoders.h:
* Shared/WebLayerTreeInfo.cpp:
* Shared/WebLayerTreeInfo.h:
* Target.pri:
* UIProcess/API/qt/qquickwebpage.cpp:
(QQuickWebPage::updatePaintNode):
* UIProcess/API/qt/raw/qrawwebview.cpp:
(QRawWebView::paint):
* UIProcess/CoordinatedGraphics/CoordinatedBackingStore.cpp: Renamed from Source/WebKit2/UIProcess/texmap/LayerBackingStore.cpp.
* UIProcess/CoordinatedGraphics/CoordinatedBackingStore.h: Renamed from Source/WebKit2/UIProcess/texmap/LayerBackingStore.h.
* UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.cpp: Renamed from Source/WebKit2/UIProcess/LayerTreeCoordinatorProxy.cpp.
* UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.h: Renamed from Source/WebKit2/UIProcess/LayerTreeCoordinatorProxy.h.
* UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.messages.in: Renamed from Source/WebKit2/UIProcess/LayerTreeCoordinatorProxy.messages.in.
* UIProcess/CoordinatedGraphics/LayerTreeRenderer.cpp: Renamed from Source/WebKit2/UIProcess/WebLayerTreeRenderer.cpp.
* UIProcess/CoordinatedGraphics/LayerTreeRenderer.h: Renamed from Source/WebKit2/UIProcess/WebLayerTreeRenderer.h.
* UIProcess/DrawingAreaProxy.cpp:
(WebKit):
* UIProcess/DrawingAreaProxy.h:
(DrawingAreaProxy):
* UIProcess/DrawingAreaProxyImpl.cpp:
(WebKit::DrawingAreaProxyImpl::DrawingAreaProxyImpl):
(WebKit::DrawingAreaProxyImpl::enterAcceleratedCompositingMode):
(WebKit):
* UIProcess/DrawingAreaProxyImpl.h:
(DrawingAreaProxyImpl):
* UIProcess/WebPageProxy.cpp:
(WebKit::WebPageProxy::didReceiveMessage):
* UIProcess/qt/QtWebPageSGNode.cpp:
(WebKit::ContentsSGNode::ContentsSGNode):
(WebKit::ContentsSGNode::layerTreeRenderer):
(ContentsSGNode):
(WebKit::QtWebPageSGNode::setRenderer):
* UIProcess/qt/QtWebPageSGNode.h:
(WebKit):
(QtWebPageSGNode):
* WebKit2.pri:
* WebProcess/WebCoreSupport/WebChromeClient.cpp:
(WebKit::WebChromeClient::scheduleAnimation):
* WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp: Renamed from Source/WebKit2/WebProcess/WebPage/LayerTreeCoordinator/WebGraphicsLayer.cpp.
* WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.h: Renamed from Source/WebKit2/WebProcess/WebPage/LayerTreeCoordinator/WebGraphicsLayer.h.
* WebProcess/WebPage/CoordinatedGraphics/CoordinatedTile.cpp: Renamed from Source/WebKit2/WebProcess/WebPage/TiledBackingStoreRemoteTile.cpp.
* WebProcess/WebPage/CoordinatedGraphics/CoordinatedTile.h: Renamed from Source/WebKit2/WebProcess/WebPage/TiledBackingStoreRemoteTile.h.
* WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp: Renamed from Source/WebKit2/WebProcess/WebPage/LayerTreeCoordinator/LayerTreeCoordinator.cpp.
* WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.h: Renamed from Source/WebKit2/WebProcess/WebPage/LayerTreeCoordinator/LayerTreeCoordinator.h.
* WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.messages.in: Renamed from Source/WebKit2/WebProcess/WebPage/LayerTreeCoordinator/LayerTreeCoordinator.messages.in.
* WebProcess/WebPage/DrawingArea.h:
(DrawingArea):
* WebProcess/WebPage/DrawingAreaImpl.cpp:
(WebKit):
* WebProcess/WebPage/DrawingAreaImpl.h:
(DrawingAreaImpl):
* WebProcess/WebPage/LayerTreeHost.h:
(LayerTreeHost):
* WebProcess/WebPage/UpdateAtlas.cpp:
* WebProcess/WebPage/UpdateAtlas.h:
* WebProcess/qt/WebProcessMainQt.cpp:
(WebKit::WebProcessMainQt):

Source/WTF:

Renamed UI_SIDE_COMPOSITING to COORDINATED_GRAPHICS.

* wtf/Platform.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@124701 268f45cc-cd09-0410-ab3c-d52691b4dbfc

43 files changed:
Source/WTF/ChangeLog
Source/WTF/wtf/Platform.h
Source/WebKit2/CMakeLists.txt
Source/WebKit2/ChangeLog
Source/WebKit2/DerivedSources.pri
Source/WebKit2/GNUmakefile.list.am
Source/WebKit2/Shared/WebCoreArgumentCoders.cpp
Source/WebKit2/Shared/WebCoreArgumentCoders.h
Source/WebKit2/Shared/WebLayerTreeInfo.cpp
Source/WebKit2/Shared/WebLayerTreeInfo.h
Source/WebKit2/Target.pri
Source/WebKit2/UIProcess/API/qt/qquickwebpage.cpp
Source/WebKit2/UIProcess/API/qt/raw/qrawwebview.cpp
Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.cpp [moved from Source/WebKit2/UIProcess/texmap/LayerBackingStore.cpp with 68% similarity]
Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.h [moved from Source/WebKit2/UIProcess/texmap/LayerBackingStore.h with 81% similarity]
Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.cpp [moved from Source/WebKit2/UIProcess/LayerTreeCoordinatorProxy.cpp with 75% similarity]
Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.h [moved from Source/WebKit2/UIProcess/LayerTreeCoordinatorProxy.h with 94% similarity]
Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.messages.in [moved from Source/WebKit2/UIProcess/LayerTreeCoordinatorProxy.messages.in with 96% similarity]
Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeRenderer.cpp [moved from Source/WebKit2/UIProcess/WebLayerTreeRenderer.cpp with 79% similarity]
Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeRenderer.h [moved from Source/WebKit2/UIProcess/WebLayerTreeRenderer.h with 91% similarity]
Source/WebKit2/UIProcess/DrawingAreaProxy.cpp
Source/WebKit2/UIProcess/DrawingAreaProxy.h
Source/WebKit2/UIProcess/DrawingAreaProxyImpl.cpp
Source/WebKit2/UIProcess/DrawingAreaProxyImpl.h
Source/WebKit2/UIProcess/WebPageProxy.cpp
Source/WebKit2/UIProcess/qt/QtWebPageSGNode.cpp
Source/WebKit2/UIProcess/qt/QtWebPageSGNode.h
Source/WebKit2/WebKit2.pri
Source/WebKit2/WebProcess/WebCoreSupport/WebChromeClient.cpp
Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp [moved from Source/WebKit2/WebProcess/WebPage/LayerTreeCoordinator/WebGraphicsLayer.cpp with 56% similarity]
Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.h [moved from Source/WebKit2/WebProcess/WebPage/LayerTreeCoordinator/WebGraphicsLayer.h with 87% similarity]
Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedTile.cpp [moved from Source/WebKit2/WebProcess/WebPage/TiledBackingStoreRemoteTile.cpp with 73% similarity]
Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedTile.h [moved from Source/WebKit2/WebProcess/WebPage/TiledBackingStoreRemoteTile.h with 73% similarity]
Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp [moved from Source/WebKit2/WebProcess/WebPage/LayerTreeCoordinator/LayerTreeCoordinator.cpp with 92% similarity]
Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.h [moved from Source/WebKit2/WebProcess/WebPage/LayerTreeCoordinator/LayerTreeCoordinator.h with 94% similarity]
Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.messages.in [moved from Source/WebKit2/WebProcess/WebPage/LayerTreeCoordinator/LayerTreeCoordinator.messages.in with 97% similarity]
Source/WebKit2/WebProcess/WebPage/DrawingArea.h
Source/WebKit2/WebProcess/WebPage/DrawingAreaImpl.cpp
Source/WebKit2/WebProcess/WebPage/DrawingAreaImpl.h
Source/WebKit2/WebProcess/WebPage/LayerTreeHost.h
Source/WebKit2/WebProcess/WebPage/UpdateAtlas.cpp
Source/WebKit2/WebProcess/WebPage/UpdateAtlas.h
Source/WebKit2/WebProcess/qt/WebProcessMainQt.cpp

index 3805100..d1b22e4 100644 (file)
@@ -1,3 +1,14 @@
+2012-08-04  No'am Rosenthal  <noam.rosenthal@nokia.com>
+
+        [Qt] UI_SIDE_COMPOSITING code has confusing names
+        https://bugs.webkit.org/show_bug.cgi?id=93164
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        Renamed UI_SIDE_COMPOSITING to COORDINATED_GRAPHICS.
+
+        * wtf/Platform.h:
+
 2012-08-03  Michael Saboff  <msaboff@apple.com>
 
         Convert HTML parser to handle 8-bit resources without converting to UChar*
index 50710b1..b7383b2 100644 (file)
 
 /* Compositing on the UI-process in WebKit2 */
 #if PLATFORM(QT)
-#define WTF_USE_UI_SIDE_COMPOSITING 1
+#define WTF_USE_COORDINATED_GRAPHICS 1
 #endif
 
 #if PLATFORM(MAC) || PLATFORM(IOS)
index 63a8ca7..22d6f46 100644 (file)
@@ -220,7 +220,7 @@ SET(WebKit2_SOURCES
     UIProcess/FindIndicator.cpp
     UIProcess/GeolocationPermissionRequestManagerProxy.cpp
     UIProcess/GeolocationPermissionRequestProxy.cpp
-    UIProcess/LayerTreeCoordinatorProxy.cpp
+
     UIProcess/ResponsivenessTimer.cpp
     UIProcess/VisitedLinkProvider.cpp
     UIProcess/WebApplicationCacheManagerProxy.cpp
@@ -254,7 +254,7 @@ SET(WebKit2_SOURCES
     UIProcess/WebInspectorProxy.cpp
     UIProcess/WebIntentData.cpp
     UIProcess/WebKeyValueStorageManagerProxy.cpp
-    UIProcess/WebLayerTreeRenderer.cpp
+
     UIProcess/WebLoaderClient.cpp
     UIProcess/WebMediaCacheManagerProxy.cpp
     UIProcess/WebNavigationData.cpp
@@ -323,6 +323,9 @@ SET(WebKit2_SOURCES
     UIProcess/Authentication/WebCredential.cpp
     UIProcess/Authentication/WebProtectionSpace.cpp
 
+    UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.cpp
+    UIProcess/CoordinatedGraphics/LayerTreeRenderer.cpp
+    
     UIProcess/Downloads/DownloadProxy.cpp
 
     UIProcess/InspectorServer/WebInspectorServer.cpp
@@ -454,11 +457,10 @@ SET(WebKit2_SOURCES
     WebProcess/WebPage/EncoderAdapter.cpp
     WebProcess/WebPage/EventDispatcher.cpp
     WebProcess/WebPage/FindController.cpp
-    WebProcess/WebPage/LayerTreeCoordinator/WebGraphicsLayer.cpp
+
     WebProcess/WebPage/LayerTreeHost.cpp
     WebProcess/WebPage/PageOverlay.cpp
     WebProcess/WebPage/TapHighlightController.cpp
-    WebProcess/WebPage/TiledBackingStoreRemoteTile.cpp
     WebProcess/WebPage/WebBackForwardListProxy.cpp
     WebProcess/WebPage/WebContextMenu.cpp
     WebProcess/WebPage/WebFrame.cpp
@@ -467,6 +469,9 @@ SET(WebKit2_SOURCES
     WebProcess/WebPage/WebPage.cpp
     WebProcess/WebPage/WebPageGroupProxy.cpp
     WebProcess/WebPage/WebUndoStep.cpp
+
+    WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp
+    WebProcess/WebPage/CoordinatedGraphics/CoordinatedTile.cpp
 )
 
 SET(WebKit2_MESSAGES_IN_FILES
@@ -477,7 +482,6 @@ SET(WebKit2_MESSAGES_IN_FILES
     Shared/Plugins/NPObjectMessageReceiver.messages.in
 
     UIProcess/DrawingAreaProxy.messages.in
-    UIProcess/LayerTreeCoordinatorProxy.messages.in
     UIProcess/WebApplicationCacheManagerProxy.messages.in
     UIProcess/WebBatteryManagerProxy.messages.in
     UIProcess/WebContext.messages.in
@@ -495,6 +499,9 @@ SET(WebKit2_MESSAGES_IN_FILES
     UIProcess/WebResourceCacheManagerProxy.messages.in
     UIProcess/WebVibrationProxy.messages.in
 
+
+    UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.messages.in
+    
     UIProcess/Downloads/DownloadProxy.messages.in
 
     UIProcess/Notifications/WebNotificationManagerProxy.messages.in
@@ -534,9 +541,10 @@ SET(WebKit2_MESSAGES_IN_FILES
 
     WebProcess/WebPage/DrawingArea.messages.in
     WebProcess/WebPage/EventDispatcher.messages.in
-    WebProcess/WebPage/LayerTreeCoordinator/LayerTreeCoordinator.messages.in
     WebProcess/WebPage/WebInspector.messages.in
     WebProcess/WebPage/WebPage.messages.in
+
+    WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.messages.in
 )
 
 SET(WebProcess_EXECUTABLE_NAME WebProcess)
index 68468ef..93495d1 100644 (file)
@@ -1,3 +1,75 @@
+2012-08-04  No'am Rosenthal  <noam.rosenthal@nokia.com>
+
+        [Qt] UI_SIDE_COMPOSITING code has confusing names
+        https://bugs.webkit.org/show_bug.cgi?id=93164
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        Renamed and consolidated code guarded under UI_SIDE_COMPOSITING, now under
+        USE(COORDINATED_GRAPHICS) guard and CoordinatedGraphics folders.
+
+        * CMakeLists.txt:
+        * DerivedSources.pri:
+        * Shared/WebCoreArgumentCoders.cpp:
+        (CoreIPC):
+        * Shared/WebCoreArgumentCoders.h:
+        * Shared/WebLayerTreeInfo.cpp:
+        * Shared/WebLayerTreeInfo.h:
+        * Target.pri:
+        * UIProcess/API/qt/qquickwebpage.cpp:
+        (QQuickWebPage::updatePaintNode):
+        * UIProcess/API/qt/raw/qrawwebview.cpp:
+        (QRawWebView::paint):
+        * UIProcess/CoordinatedGraphics/CoordinatedBackingStore.cpp: Renamed from Source/WebKit2/UIProcess/texmap/LayerBackingStore.cpp.
+        * UIProcess/CoordinatedGraphics/CoordinatedBackingStore.h: Renamed from Source/WebKit2/UIProcess/texmap/LayerBackingStore.h.
+        * UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.cpp: Renamed from Source/WebKit2/UIProcess/LayerTreeCoordinatorProxy.cpp.
+        * UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.h: Renamed from Source/WebKit2/UIProcess/LayerTreeCoordinatorProxy.h.
+        * UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.messages.in: Renamed from Source/WebKit2/UIProcess/LayerTreeCoordinatorProxy.messages.in.
+        * UIProcess/CoordinatedGraphics/LayerTreeRenderer.cpp: Renamed from Source/WebKit2/UIProcess/WebLayerTreeRenderer.cpp.
+        * UIProcess/CoordinatedGraphics/LayerTreeRenderer.h: Renamed from Source/WebKit2/UIProcess/WebLayerTreeRenderer.h.
+        * UIProcess/DrawingAreaProxy.cpp:
+        (WebKit):
+        * UIProcess/DrawingAreaProxy.h:
+        (DrawingAreaProxy):
+        * UIProcess/DrawingAreaProxyImpl.cpp:
+        (WebKit::DrawingAreaProxyImpl::DrawingAreaProxyImpl):
+        (WebKit::DrawingAreaProxyImpl::enterAcceleratedCompositingMode):
+        (WebKit):
+        * UIProcess/DrawingAreaProxyImpl.h:
+        (DrawingAreaProxyImpl):
+        * UIProcess/WebPageProxy.cpp:
+        (WebKit::WebPageProxy::didReceiveMessage):
+        * UIProcess/qt/QtWebPageSGNode.cpp:
+        (WebKit::ContentsSGNode::ContentsSGNode):
+        (WebKit::ContentsSGNode::layerTreeRenderer):
+        (ContentsSGNode):
+        (WebKit::QtWebPageSGNode::setRenderer):
+        * UIProcess/qt/QtWebPageSGNode.h:
+        (WebKit):
+        (QtWebPageSGNode):
+        * WebKit2.pri:
+        * WebProcess/WebCoreSupport/WebChromeClient.cpp:
+        (WebKit::WebChromeClient::scheduleAnimation):
+        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp: Renamed from Source/WebKit2/WebProcess/WebPage/LayerTreeCoordinator/WebGraphicsLayer.cpp.
+        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.h: Renamed from Source/WebKit2/WebProcess/WebPage/LayerTreeCoordinator/WebGraphicsLayer.h.
+        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedTile.cpp: Renamed from Source/WebKit2/WebProcess/WebPage/TiledBackingStoreRemoteTile.cpp.
+        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedTile.h: Renamed from Source/WebKit2/WebProcess/WebPage/TiledBackingStoreRemoteTile.h.
+        * WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp: Renamed from Source/WebKit2/WebProcess/WebPage/LayerTreeCoordinator/LayerTreeCoordinator.cpp.
+        * WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.h: Renamed from Source/WebKit2/WebProcess/WebPage/LayerTreeCoordinator/LayerTreeCoordinator.h.
+        * WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.messages.in: Renamed from Source/WebKit2/WebProcess/WebPage/LayerTreeCoordinator/LayerTreeCoordinator.messages.in.
+        * WebProcess/WebPage/DrawingArea.h:
+        (DrawingArea):
+        * WebProcess/WebPage/DrawingAreaImpl.cpp:
+        (WebKit):
+        * WebProcess/WebPage/DrawingAreaImpl.h:
+        (DrawingAreaImpl):
+        * WebProcess/WebPage/LayerTreeHost.h:
+        (LayerTreeHost):
+        * WebProcess/WebPage/UpdateAtlas.cpp:
+        * WebProcess/WebPage/UpdateAtlas.h:
+        * WebProcess/qt/WebProcessMainQt.cpp:
+        (WebKit::WebProcessMainQt):
+
 2012-08-04  Christophe Dumez  <christophe.dumez@intel.com>
 
         [WK2] Move WebIntentData from Shared to UIProcess
index 42fa665..26cbb2b 100644 (file)
@@ -51,8 +51,10 @@ VPATH = \
     WebProcess/ResourceCache \
     WebProcess/WebCoreSupport \
     WebProcess/WebPage \
+    WebProcess/WebPage/CoordinatedGraphics \
     WebProcess \
     UIProcess \
+    UIProcess/CoordinatedGraphics \
     UIProcess/Downloads \
     UIProcess/Notifications \
     UIProcess/Plugins \
@@ -93,10 +95,10 @@ MESSAGE_RECEIVERS = \
     WebNotificationManager.messages.in \
     WebFullScreenManager.messages.in \
     WebFullScreenManagerProxy.messages.in \
-    WebPage/DrawingArea.messages.in \
-    WebPage/LayerTreeCoordinator/LayerTreeCoordinator.messages.in \
-    WebPage/WebInspector.messages.in \
-    WebPage/WebPage.messages.in \
+    DrawingArea.messages.in \
+    LayerTreeCoordinator.messages.in \
+    WebInspector.messages.in \
+    WebPage.messages.in \
     WebPageProxy.messages.in \
     WebProcess.messages.in \
     WebProcessConnection.messages.in \
index eefd5a0..b3005c0 100644 (file)
@@ -140,8 +140,6 @@ webkit2_built_sources += \
        DerivedSources/WebKit2/DrawingAreaProxyMessages.h \
        DerivedSources/WebKit2/EventDispatcherMessageReceiver.cpp \
        DerivedSources/WebKit2/EventDispatcherMessages.h \
-       DerivedSources/WebKit2/LayerTreeCoordinatorProxyMessageReceiver.cpp \
-       DerivedSources/WebKit2/LayerTreeCoordinatorProxyMessages.h \
        DerivedSources/WebKit2/NPObjectMessageReceiverMessageReceiver.cpp \
        DerivedSources/WebKit2/NPObjectMessageReceiverMessages.h \
        DerivedSources/WebKit2/PluginControllerProxyMessageReceiver.cpp \
index 9b0448a..99563f4 100644 (file)
@@ -46,7 +46,7 @@
 #include <WebCore/WindowFeatures.h>
 #include <wtf/text/StringHash.h>
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 #include <WebCore/Animation.h>
 #include <WebCore/FloatPoint3D.h>
 #include <WebCore/TransformationMatrix.h>
@@ -652,7 +652,7 @@ bool ArgumentCoder<KURL>::decode(ArgumentDecoder* decoder, KURL& result)
     return true;
 }
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 void ArgumentCoder<FloatPoint3D>::encode(ArgumentEncoder* encoder, const FloatPoint3D& floatPoint3D)
 {
     SimpleArgumentCoder<FloatPoint3D>::encode(encoder, floatPoint3D);
index db2b8f7..b7678c5 100644 (file)
@@ -86,7 +86,7 @@ namespace WebCore {
 }
 #endif
 
-#if USE(UI_SIDE_COMPOSITING) && ENABLE(CSS_FILTERS)
+#if USE(COORDINATED_GRAPHICS) && ENABLE(CSS_FILTERS)
 namespace WebCore {
     class FilterOperations;
 }
@@ -240,7 +240,7 @@ template<> struct ArgumentCoder<WebCore::KURL> {
     static bool decode(ArgumentDecoder*, WebCore::KURL&);
 };
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 template<> struct ArgumentCoder<WebCore::FloatPoint3D> {
     static void encode(ArgumentEncoder*, const WebCore::FloatPoint3D&);
     static bool decode(ArgumentDecoder*, WebCore::FloatPoint3D&);
index ffdea52..e083640 100644 (file)
@@ -19,7 +19,7 @@
 
 #include "config.h"
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 #include "WebLayerTreeInfo.h"
 
 #include "ArgumentCoders.h"
index d5d7233..df44778 100644 (file)
@@ -20,7 +20,7 @@
 #ifndef WebLayerTreeInfo_h
 #define WebLayerTreeInfo_h
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 
 #include "ArgumentDecoder.h"
 #include "ArgumentEncoder.h"
index 71f027b..cfd5708 100644 (file)
@@ -214,6 +214,9 @@ HEADERS += \
     UIProcess/Authentication/WebProtectionSpace.h \
     UIProcess/BackingStore.h \
     UIProcess/Downloads/DownloadProxy.h \
+    UIProcess/CoordinatedGraphics/CoordinatedBackingStore.h \
+    UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.h \
+    UIProcess/CoordinatedGraphics/LayerTreeRenderer.h \
     UIProcess/DrawingAreaProxy.h \
     UIProcess/DrawingAreaProxyImpl.h \
     UIProcess/FindIndicator.h \
@@ -222,7 +225,6 @@ HEADERS += \
     UIProcess/GeolocationPermissionRequestProxy.h \
     UIProcess/Launcher/ProcessLauncher.h \
     UIProcess/Launcher/ThreadLauncher.h \
-    UIProcess/LayerTreeCoordinatorProxy.h \
     UIProcess/Notifications/NotificationPermissionRequest.h \
     UIProcess/Notifications/NotificationPermissionRequestManagerProxy.h \
     UIProcess/Notifications/WebNotification.h \
@@ -268,7 +270,6 @@ HEADERS += \
     UIProcess/WebInspectorProxy.h \
     UIProcess/WebIntentData.h \
     UIProcess/WebKeyValueStorageManagerProxy.h \
-    UIProcess/WebLayerTreeRenderer.h \
     UIProcess/WebLoaderClient.h \
     UIProcess/WebMediaCacheManagerProxy.h \
     UIProcess/WebNavigationData.h \
@@ -304,7 +305,6 @@ HEADERS += \
     UIProcess/qt/WebContextMenuProxyQt.h \
     UIProcess/qt/WebGeolocationProviderQt.h \
     UIProcess/qt/WebPopupMenuProxyQt.h \
-    UIProcess/texmap/LayerBackingStore.h \
     WebProcess/ApplicationCache/WebApplicationCacheManager.h \
     WebProcess/Authentication/AuthenticationManager.h \
     WebProcess/Battery/WebBatteryManager.h \
@@ -385,8 +385,9 @@ HEADERS += \
     WebProcess/WebPage/DrawingAreaImpl.h \
     WebProcess/WebPage/EventDispatcher.h \
     WebProcess/WebPage/FindController.h \
-    WebProcess/WebPage/LayerTreeCoordinator/LayerTreeCoordinator.h \
-    WebProcess/WebPage/LayerTreeCoordinator/WebGraphicsLayer.h \
+    WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.h \
+    WebProcess/WebPage/CoordinatedGraphics/CoordinatedTile.h \
+    WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.h \
     WebProcess/WebPage/TapHighlightController.h \
     WebProcess/WebPage/PageOverlay.h \
     WebProcess/WebPage/UpdateAtlas.h \
@@ -584,6 +585,9 @@ SOURCES += \
     UIProcess/Authentication/WebProtectionSpace.cpp \
     UIProcess/BackingStore.cpp \
     UIProcess/qt/BackingStoreQt.cpp \
+    UIProcess/CoordinatedGraphics/CoordinatedBackingStore.cpp \
+    UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.cpp \
+    UIProcess/CoordinatedGraphics/LayerTreeRenderer.cpp \
     UIProcess/Downloads/DownloadProxy.cpp \
     UIProcess/DrawingAreaProxy.cpp \
     UIProcess/DrawingAreaProxyImpl.cpp \
@@ -595,7 +599,6 @@ SOURCES += \
     UIProcess/Launcher/ThreadLauncher.cpp \
     UIProcess/Launcher/qt/ProcessLauncherQt.cpp \
     UIProcess/Launcher/qt/ThreadLauncherQt.cpp \
-    UIProcess/LayerTreeCoordinatorProxy.cpp \
     UIProcess/Notifications/NotificationPermissionRequest.cpp \
     UIProcess/Notifications/NotificationPermissionRequestManagerProxy.cpp \
     UIProcess/Notifications/WebNotification.cpp \
@@ -639,7 +642,6 @@ SOURCES += \
     UIProcess/WebInspectorProxy.cpp \
     UIProcess/WebIntentData.cpp \
     UIProcess/WebKeyValueStorageManagerProxy.cpp \
-    UIProcess/WebLayerTreeRenderer.cpp \
     UIProcess/WebLoaderClient.cpp \
     UIProcess/WebMediaCacheManagerProxy.cpp \
     UIProcess/WebNavigationData.cpp \
@@ -682,7 +684,6 @@ SOURCES += \
     UIProcess/qt/WebPopupMenuProxyQt.cpp \
     UIProcess/qt/WebPreferencesQt.cpp \
     UIProcess/qt/QtWebIconDatabaseClient.cpp \
-    UIProcess/texmap/LayerBackingStore.cpp \
     WebProcess/ApplicationCache/WebApplicationCacheManager.cpp \
     WebProcess/Authentication/AuthenticationManager.cpp \
     WebProcess/Battery/WebBatteryManager.cpp \
@@ -781,12 +782,12 @@ SOURCES += \
     WebProcess/WebPage/EncoderAdapter.cpp \
     WebProcess/WebPage/EventDispatcher.cpp \
     WebProcess/WebPage/FindController.cpp \
-    WebProcess/WebPage/LayerTreeCoordinator/LayerTreeCoordinator.cpp \
-    WebProcess/WebPage/LayerTreeCoordinator/WebGraphicsLayer.cpp \
+    WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp \
+    WebProcess/WebPage/CoordinatedGraphics/CoordinatedTile.cpp \
+    WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp \
     WebProcess/WebPage/TapHighlightController.cpp \
     WebProcess/WebPage/LayerTreeHost.cpp \
     WebProcess/WebPage/PageOverlay.cpp \
-    WebProcess/WebPage/TiledBackingStoreRemoteTile.cpp \
     WebProcess/WebPage/UpdateAtlas.cpp \
     WebProcess/WebPage/WebBackForwardListProxy.cpp \
     WebProcess/WebPage/WebContextMenu.cpp \
index 99c5ffb..7911f16 100644 (file)
 #include "qquickwebpage_p.h"
 
 #include "LayerTreeCoordinatorProxy.h"
+#include "LayerTreeRenderer.h"
 #include "QtWebPageEventHandler.h"
 #include "QtWebPageSGNode.h"
 #include "TransformationMatrix.h"
-#include "WebLayerTreeRenderer.h"
 #include "WebPageProxy.h"
 #include "qquickwebpage_p_p.h"
 #include "qquickwebview_p.h"
@@ -82,7 +82,7 @@ QSGNode* QQuickWebPage::updatePaintNode(QSGNode* oldNode, UpdatePaintNodeData*)
         return oldNode;
 
     LayerTreeCoordinatorProxy* layerTreeCoordinatorProxy = d->webPageProxy->drawingArea()->layerTreeCoordinatorProxy();
-    WebLayerTreeRenderer* renderer = layerTreeCoordinatorProxy->layerTreeRenderer();
+    LayerTreeRenderer* renderer = layerTreeCoordinatorProxy->layerTreeRenderer();
 
     QtWebPageSGNode* node = static_cast<QtWebPageSGNode*>(oldNode);
     if (!node)
index 121f90d..0aed5d9 100644 (file)
@@ -23,6 +23,7 @@
 #include "Cursor.h"
 #include "DrawingAreaProxyImpl.h"
 #include "LayerTreeCoordinatorProxy.h"
+#include "LayerTreeRenderer.h"
 #include "NativeWebKeyboardEvent.h"
 #include "NativeWebMouseEvent.h"
 #if ENABLE(TOUCH_EVENTS)
@@ -31,7 +32,6 @@
 #include "NativeWebWheelEvent.h"
 #include "NotImplemented.h"
 #include "WebContext.h"
-#include "WebLayerTreeRenderer.h"
 #include "WebPageGroup.h"
 #include "WebPreferences.h"
 #include "qrawwebview_p_p.h"
@@ -353,7 +353,7 @@ void QRawWebView::paint(const QMatrix4x4& transform, float opacity, unsigned pai
     if (!coordinatorProxy)
         return;
 
-    WebKit::WebLayerTreeRenderer* renderer = coordinatorProxy->layerTreeRenderer();
+    WebKit::LayerTreeRenderer* renderer = coordinatorProxy->layerTreeRenderer();
     if (!renderer)
         return;
 
@@ -18,9 +18,9 @@
  */
 
 #include "config.h"
-#include "LayerBackingStore.h"
+#include "CoordinatedBackingStore.h"
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 #include "GraphicsLayer.h"
 #include "ShareableSurface.h"
 #include "TextureMapper.h"
@@ -30,7 +30,7 @@ using namespace WebCore;
 
 namespace WebKit {
 
-void LayerBackingStoreTile::swapBuffers(WebCore::TextureMapper* textureMapper)
+void CoordinatedBackingStoreTile::swapBuffers(WebCore::TextureMapper* textureMapper)
 {
     if (!m_surface)
         return;
@@ -56,7 +56,7 @@ void LayerBackingStoreTile::swapBuffers(WebCore::TextureMapper* textureMapper)
     m_surface.clear();
 }
 
-void LayerBackingStoreTile::setBackBuffer(const IntRect& targetRect, const IntRect& sourceRect, PassRefPtr<ShareableSurface> buffer, const IntPoint& offset)
+void CoordinatedBackingStoreTile::setBackBuffer(const IntRect& targetRect, const IntRect& sourceRect, PassRefPtr<ShareableSurface> buffer, const IntPoint& offset)
 {
     m_sourceRect = sourceRect;
     m_targetRect = targetRect;
@@ -64,30 +64,30 @@ void LayerBackingStoreTile::setBackBuffer(const IntRect& targetRect, const IntRe
     m_surface = buffer;
 }
 
-void LayerBackingStore::createTile(int id, float scale)
+void CoordinatedBackingStore::createTile(int id, float scale)
 {
-    m_tiles.add(id, LayerBackingStoreTile(scale));
+    m_tiles.add(id, CoordinatedBackingStoreTile(scale));
     m_scale = scale;
 }
 
-void LayerBackingStore::removeTile(int id)
+void CoordinatedBackingStore::removeTile(int id)
 {
     m_tilesToRemove.append(id);
 }
 
 
-void LayerBackingStore::updateTile(int id, const IntRect& sourceRect, const IntRect& targetRect, PassRefPtr<ShareableSurface> backBuffer, const IntPoint& offset)
+void CoordinatedBackingStore::updateTile(int id, const IntRect& sourceRect, const IntRect& targetRect, PassRefPtr<ShareableSurface> backBuffer, const IntPoint& offset)
 {
-    HashMap<int, LayerBackingStoreTile>::iterator it = m_tiles.find(id);
+    HashMap<int, CoordinatedBackingStoreTile>::iterator it = m_tiles.find(id);
     ASSERT(it != m_tiles.end());
     it->second.incrementRepaintCount();
     it->second.setBackBuffer(targetRect, sourceRect, backBuffer, offset);
 }
 
-PassRefPtr<BitmapTexture> LayerBackingStore::texture() const
+PassRefPtr<BitmapTexture> CoordinatedBackingStore::texture() const
 {
-    HashMap<int, LayerBackingStoreTile>::const_iterator end = m_tiles.end();
-    for (HashMap<int, LayerBackingStoreTile>::const_iterator it = m_tiles.begin(); it != end; ++it) {
+    HashMap<int, CoordinatedBackingStoreTile>::const_iterator end = m_tiles.end();
+    for (HashMap<int, CoordinatedBackingStoreTile>::const_iterator it = m_tiles.begin(); it != end; ++it) {
         RefPtr<BitmapTexture> texture = it->second.texture();
         if (texture)
             return texture;
@@ -104,15 +104,15 @@ static bool shouldShowTileDebugVisuals()
     return false;
 }
 
-void LayerBackingStore::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity, BitmapTexture* mask)
+void CoordinatedBackingStore::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity, BitmapTexture* mask)
 {
     Vector<TextureMapperTile*> tilesToPaint;
 
     // We have to do this every time we paint, in case the opacity has changed.
-    HashMap<int, LayerBackingStoreTile>::iterator end = m_tiles.end();
+    HashMap<int, CoordinatedBackingStoreTile>::iterator end = m_tiles.end();
     FloatRect coveredRect;
-    for (HashMap<int, LayerBackingStoreTile>::iterator it = m_tiles.begin(); it != end; ++it) {
-        LayerBackingStoreTile& tile = it->second;
+    for (HashMap<int, CoordinatedBackingStoreTile>::iterator it = m_tiles.begin(); it != end; ++it) {
+        CoordinatedBackingStoreTile& tile = it->second;
         if (!tile.texture())
             continue;
 
@@ -132,7 +132,7 @@ void LayerBackingStore::paintToTextureMapper(TextureMapper* textureMapper, const
 
     // TODO: When the TextureMapper makes a distinction between some edges exposed and no edges
     // exposed, the value passed should be an accurate reflection of the tile subset that we are
-    // passing. For now we just "estimate" since LayerBackingStore doesn't keep information about
+    // passing. For now we just "estimate" since CoordinatedBackingStore doesn't keep information about
     // the total tiled surface rect at the moment.
     unsigned edgesExposed = m_tiles.size() > 1 ? TextureMapper::NoEdges : TextureMapper::AllEdges;
     for (size_t i = 0; i < tilesToPaint.size(); ++i) {
@@ -143,19 +143,19 @@ void LayerBackingStore::paintToTextureMapper(TextureMapper* textureMapper, const
             continue;
 
         textureMapper->drawBorder(Color(0xFF, 0, 0), 2, tile->rect(), transform);
-        textureMapper->drawRepaintCounter(static_cast<LayerBackingStoreTile*>(tile)->repaintCount(), 8, tilesToPaint[i]->rect().location(), transform);
+        textureMapper->drawRepaintCounter(static_cast<CoordinatedBackingStoreTile*>(tile)->repaintCount(), 8, tilesToPaint[i]->rect().location(), transform);
     }
 }
 
-void LayerBackingStore::commitTileOperations(TextureMapper* textureMapper)
+void CoordinatedBackingStore::commitTileOperations(TextureMapper* textureMapper)
 {
     Vector<int>::iterator tilesToRemoveEnd = m_tilesToRemove.end();
     for (Vector<int>::iterator it = m_tilesToRemove.begin(); it != tilesToRemoveEnd; ++it)
         m_tiles.remove(*it);
     m_tilesToRemove.clear();
 
-    HashMap<int, LayerBackingStoreTile>::iterator tilesEnd = m_tiles.end();
-    for (HashMap<int, LayerBackingStoreTile>::iterator it = m_tiles.begin(); it != tilesEnd; ++it)
+    HashMap<int, CoordinatedBackingStoreTile>::iterator tilesEnd = m_tiles.end();
+    for (HashMap<int, CoordinatedBackingStoreTile>::iterator it = m_tiles.begin(); it != tilesEnd; ++it)
         it->second.swapBuffers(textureMapper);
 }
 
  Boston, MA 02110-1301, USA.
  */
 
-#ifndef LayerBackingStore_h
-#define LayerBackingStore_h
+#ifndef CoordinatedBackingStore_h
+#define CoordinatedBackingStore_h
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 
 #include "TextureMapper.h"
 #include "TextureMapperBackingStore.h"
@@ -30,9 +30,9 @@ namespace WebKit {
 
 class ShareableSurface;
 
-class LayerBackingStoreTile : public WebCore::TextureMapperTile {
+class CoordinatedBackingStoreTile : public WebCore::TextureMapperTile {
 public:
-    LayerBackingStoreTile(float scale = 1)
+    CoordinatedBackingStoreTile(float scale = 1)
         : TextureMapperTile(WebCore::FloatRect())
         , m_scale(scale)
         , m_repaintCount(0)
@@ -54,21 +54,21 @@ private:
     int m_repaintCount;
 };
 
-class LayerBackingStore : public WebCore::TextureMapperBackingStore {
+class CoordinatedBackingStore : public WebCore::TextureMapperBackingStore {
 public:
     void createTile(int, float);
     void removeTile(int);
     void updateTile(int, const WebCore::IntRect&, const WebCore::IntRect&, PassRefPtr<ShareableSurface>, const WebCore::IntPoint&);
-    static PassRefPtr<LayerBackingStore> create() { return adoptRef(new LayerBackingStore); }
+    static PassRefPtr<CoordinatedBackingStore> create() { return adoptRef(new CoordinatedBackingStore); }
     void commitTileOperations(WebCore::TextureMapper*);
     PassRefPtr<WebCore::BitmapTexture> texture() const;
     virtual void paintToTextureMapper(WebCore::TextureMapper*, const WebCore::FloatRect&, const WebCore::TransformationMatrix&, float, WebCore::BitmapTexture*);
 
 private:
-    LayerBackingStore()
+    CoordinatedBackingStore()
         : m_scale(1.)
     { }
-    HashMap<int, LayerBackingStoreTile> m_tiles;
+    HashMap<int, CoordinatedBackingStoreTile> m_tiles;
     Vector<int> m_tilesToRemove;
     float m_scale;
 };
@@ -76,4 +76,4 @@ private:
 } // namespace WebKit
 #endif
 
-#endif // LayerBackingStore_h
+#endif // CoordinatedBackingStore_h
 
 #include "config.h"
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 #include "LayerTreeCoordinatorProxy.h"
 
 #include "LayerTreeCoordinatorMessages.h"
+#include "LayerTreeRenderer.h"
 #include "UpdateInfo.h"
 #include "WebCoreArgumentCoders.h"
 #include "WebLayerTreeInfo.h"
-#include "WebLayerTreeRenderer.h"
 #include "WebPageProxy.h"
 #include "WebProcessProxy.h"
 
@@ -36,7 +36,7 @@ using namespace WebCore;
 
 LayerTreeCoordinatorProxy::LayerTreeCoordinatorProxy(DrawingAreaProxy* drawingAreaProxy)
     : m_drawingAreaProxy(drawingAreaProxy)
-    , m_renderer(adoptRef(new WebLayerTreeRenderer(this)))
+    , m_renderer(adoptRef(new LayerTreeRenderer(this)))
     , m_lastSentScale(0)
 {
 }
@@ -58,7 +58,7 @@ void LayerTreeCoordinatorProxy::dispatchUpdate(const Function<void()>& function)
 
 void LayerTreeCoordinatorProxy::createTileForLayer(int layerID, int tileID, const IntRect& targetRect, const WebKit::SurfaceUpdateInfo& updateInfo)
 {
-    dispatchUpdate(bind(&WebLayerTreeRenderer::createTile, m_renderer.get(), layerID, tileID, updateInfo.scaleFactor));
+    dispatchUpdate(bind(&LayerTreeRenderer::createTile, m_renderer.get(), layerID, tileID, updateInfo.scaleFactor));
     updateTileForLayer(layerID, tileID, targetRect, updateInfo);
 }
 
@@ -79,69 +79,69 @@ void LayerTreeCoordinatorProxy::updateTileForLayer(int layerID, int tileID, cons
 #else
     surface = ShareableSurface::create(updateInfo.surfaceHandle);
 #endif
-    dispatchUpdate(bind(&WebLayerTreeRenderer::updateTile, m_renderer.get(), layerID, tileID, WebLayerTreeRenderer::TileUpdate(updateInfo.updateRect, targetRect, surface, updateInfo.surfaceOffset)));
+    dispatchUpdate(bind(&LayerTreeRenderer::updateTile, m_renderer.get(), layerID, tileID, LayerTreeRenderer::TileUpdate(updateInfo.updateRect, targetRect, surface, updateInfo.surfaceOffset)));
 }
 
 void LayerTreeCoordinatorProxy::removeTileForLayer(int layerID, int tileID)
 {
-    dispatchUpdate(bind(&WebLayerTreeRenderer::removeTile, m_renderer.get(), layerID, tileID));
+    dispatchUpdate(bind(&LayerTreeRenderer::removeTile, m_renderer.get(), layerID, tileID));
 }
 
 void LayerTreeCoordinatorProxy::deleteCompositingLayer(WebLayerID id)
 {
-    dispatchUpdate(bind(&WebLayerTreeRenderer::deleteLayer, m_renderer.get(), id));
+    dispatchUpdate(bind(&LayerTreeRenderer::deleteLayer, m_renderer.get(), id));
     updateViewport();
 }
 
 void LayerTreeCoordinatorProxy::setRootCompositingLayer(WebLayerID id)
 {
-    dispatchUpdate(bind(&WebLayerTreeRenderer::setRootLayerID, m_renderer.get(), id));
+    dispatchUpdate(bind(&LayerTreeRenderer::setRootLayerID, m_renderer.get(), id));
     updateViewport();
 }
 
 void LayerTreeCoordinatorProxy::setCompositingLayerState(WebLayerID id, const WebLayerInfo& info)
 {
-    dispatchUpdate(bind(&WebLayerTreeRenderer::setLayerState, m_renderer.get(), id, info));
+    dispatchUpdate(bind(&LayerTreeRenderer::setLayerState, m_renderer.get(), id, info));
 }
 
 void LayerTreeCoordinatorProxy::setCompositingLayerChildren(WebLayerID id, const Vector<WebLayerID>& children)
 {
-    dispatchUpdate(bind(&WebLayerTreeRenderer::setLayerChildren, m_renderer.get(), id, children));
+    dispatchUpdate(bind(&LayerTreeRenderer::setLayerChildren, m_renderer.get(), id, children));
 }
 
 #if ENABLE(CSS_FILTERS)
 void LayerTreeCoordinatorProxy::setCompositingLayerFilters(WebLayerID id, const FilterOperations& filters)
 {
-    dispatchUpdate(bind(&WebLayerTreeRenderer::setLayerFilters, m_renderer.get(), id, filters));
+    dispatchUpdate(bind(&LayerTreeRenderer::setLayerFilters, m_renderer.get(), id, filters));
 }
 #endif
 
 void LayerTreeCoordinatorProxy::didRenderFrame()
 {
-    dispatchUpdate(bind(&WebLayerTreeRenderer::flushLayerChanges, m_renderer.get()));
+    dispatchUpdate(bind(&LayerTreeRenderer::flushLayerChanges, m_renderer.get()));
     updateViewport();
 }
 
 void LayerTreeCoordinatorProxy::createDirectlyCompositedImage(int64_t key, const WebKit::ShareableBitmap::Handle& handle)
 {
     RefPtr<ShareableBitmap> bitmap = ShareableBitmap::create(handle);
-    dispatchUpdate(bind(&WebLayerTreeRenderer::createImage, m_renderer.get(), key, bitmap));
+    dispatchUpdate(bind(&LayerTreeRenderer::createImage, m_renderer.get(), key, bitmap));
 }
 
 void LayerTreeCoordinatorProxy::destroyDirectlyCompositedImage(int64_t key)
 {
-    dispatchUpdate(bind(&WebLayerTreeRenderer::destroyImage, m_renderer.get(), key));
+    dispatchUpdate(bind(&LayerTreeRenderer::destroyImage, m_renderer.get(), key));
 }
 
 void LayerTreeCoordinatorProxy::setContentsSize(const FloatSize& contentsSize)
 {
-    dispatchUpdate(bind(&WebLayerTreeRenderer::setContentsSize, m_renderer.get(), contentsSize));
+    dispatchUpdate(bind(&LayerTreeRenderer::setContentsSize, m_renderer.get(), contentsSize));
 }
 
 void LayerTreeCoordinatorProxy::setVisibleContentsRect(const FloatRect& rect, float scale, const FloatPoint& trajectoryVector)
 {
     // Inform the renderer to adjust viewport-fixed layers.
-    dispatchUpdate(bind(&WebLayerTreeRenderer::setVisibleContentsRect, m_renderer.get(), rect));
+    dispatchUpdate(bind(&LayerTreeRenderer::setVisibleContentsRect, m_renderer.get(), rect));
 
     // 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.
     IntRect roundedRect = roundedIntRect(rect);
@@ -161,12 +161,12 @@ void LayerTreeCoordinatorProxy::renderNextFrame()
 
 void LayerTreeCoordinatorProxy::didChangeScrollPosition(const IntPoint& position)
 {
-    dispatchUpdate(bind(&WebLayerTreeRenderer::didChangeScrollPosition, m_renderer.get(), position));
+    dispatchUpdate(bind(&LayerTreeRenderer::didChangeScrollPosition, m_renderer.get(), position));
 }
 
 void LayerTreeCoordinatorProxy::syncCanvas(uint32_t id, const IntSize& canvasSize, uint32_t graphicsSurfaceToken)
 {
-    dispatchUpdate(bind(&WebLayerTreeRenderer::syncCanvas, m_renderer.get(), id, canvasSize, graphicsSurfaceToken));
+    dispatchUpdate(bind(&LayerTreeRenderer::syncCanvas, m_renderer.get(), id, canvasSize, graphicsSurfaceToken));
 }
 
 void LayerTreeCoordinatorProxy::purgeBackingStores()
@@ -175,4 +175,4 @@ void LayerTreeCoordinatorProxy::purgeBackingStores()
 }
 
 }
-#endif // USE(UI_SIDE_COMPOSITING)
+#endif // USE(COORDINATED_GRAPHICS)
@@ -20,7 +20,7 @@
 #ifndef LayerTreeCoordinatorProxy_h
 #define LayerTreeCoordinatorProxy_h
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 
 #include "BackingStore.h"
 #include "DrawingAreaProxy.h"
@@ -43,7 +43,7 @@ QT_END_NAMESPACE
 namespace WebKit {
 
 class WebLayerInfo;
-class WebLayerTreeRenderer;
+class LayerTreeRenderer;
 class WebLayerUpdateInfo;
 
 class LayerTreeCoordinatorProxy {
@@ -73,13 +73,13 @@ public:
     void didChangeScrollPosition(const WebCore::IntPoint& position);
     void syncCanvas(uint32_t id, const WebCore::IntSize& canvasSize, uint32_t graphicsSurfaceToken);
     void purgeBackingStores();
-    WebLayerTreeRenderer* layerTreeRenderer() const { return m_renderer.get(); }
+    LayerTreeRenderer* layerTreeRenderer() const { return m_renderer.get(); }
 
 protected:
     void dispatchUpdate(const Function<void()>&);
 
     DrawingAreaProxy* m_drawingAreaProxy;
-    RefPtr<WebLayerTreeRenderer> m_renderer;
+    RefPtr<LayerTreeRenderer> m_renderer;
     WebCore::IntRect m_lastSentVisibleRect;
     float m_lastSentScale;
     WebCore::FloatPoint m_lastSentTrajectoryVector;
@@ -17,7 +17,7 @@
 #   Boston, MA 02110-1301, USA.
 #
 
-#if USE(ACCELERATED_COMPOSITING) && USE(TILED_BACKING_STORE)
+#if USE(COORDINATED_GRAPHICS)
 messages -> LayerTreeCoordinatorProxy {
     SetCompositingLayerState(uint32_t id, WebKit::WebLayerInfo layerInfo)
     SetCompositingLayerChildren(uint32_t id, Vector<uint32_t> children)
 
 #include "config.h"
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 
-#include "WebLayerTreeRenderer.h"
+#include "LayerTreeRenderer.h"
 
+#include "CoordinatedBackingStore.h"
 #include "GraphicsLayerTextureMapper.h"
-#include "LayerBackingStore.h"
 #include "LayerTreeCoordinatorProxy.h"
 #include "MessageID.h"
 #include "ShareableBitmap.h"
@@ -66,12 +66,12 @@ private:
     }
 };
 
-void WebLayerTreeRenderer::callOnMainTread(const Function<void()>& function)
+void LayerTreeRenderer::callOnMainTread(const Function<void()>& function)
 {
     if (isMainThread())
         function();
     else
-        MainThreadGuardedInvoker<WebLayerTreeRenderer>::call(this, function);
+        MainThreadGuardedInvoker<LayerTreeRenderer>::call(this, function);
 }
 
 static FloatPoint boundedScrollPosition(const FloatPoint& scrollPosition, const FloatRect& visibleContentRect, const FloatSize& contentSize)
@@ -84,18 +84,18 @@ static FloatPoint boundedScrollPosition(const FloatPoint& scrollPosition, const
     return FloatPoint(scrollPositionX, scrollPositionY);
 }
 
-WebLayerTreeRenderer::WebLayerTreeRenderer(LayerTreeCoordinatorProxy* layerTreeCoordinatorProxy)
+LayerTreeRenderer::LayerTreeRenderer(LayerTreeCoordinatorProxy* layerTreeCoordinatorProxy)
     : m_layerTreeCoordinatorProxy(layerTreeCoordinatorProxy)
     , m_rootLayerID(InvalidWebLayerID)
     , m_isActive(false)
 {
 }
 
-WebLayerTreeRenderer::~WebLayerTreeRenderer()
+LayerTreeRenderer::~LayerTreeRenderer()
 {
 }
 
-PassOwnPtr<GraphicsLayer> WebLayerTreeRenderer::createLayer(WebLayerID layerID)
+PassOwnPtr<GraphicsLayer> LayerTreeRenderer::createLayer(WebLayerID layerID)
 {
     GraphicsLayer* newLayer = new GraphicsLayerTextureMapper(this);
     TextureMapperLayer* layer = toTextureMapperLayer(newLayer);
@@ -103,7 +103,7 @@ PassOwnPtr<GraphicsLayer> WebLayerTreeRenderer::createLayer(WebLayerID layerID)
     return adoptPtr(newLayer);
 }
 
-void WebLayerTreeRenderer::paintToCurrentGLContext(const TransformationMatrix& matrix, float opacity, const FloatRect& clipRect, TextureMapper::PaintFlags PaintFlags)
+void LayerTreeRenderer::paintToCurrentGLContext(const TransformationMatrix& matrix, float opacity, const FloatRect& clipRect, TextureMapper::PaintFlags PaintFlags)
 {
     if (!m_textureMapper)
         m_textureMapper = TextureMapper::create(TextureMapper::OpenGLMode);
@@ -134,7 +134,7 @@ void WebLayerTreeRenderer::paintToCurrentGLContext(const TransformationMatrix& m
     m_textureMapper->endPainting();
 }
 
-void WebLayerTreeRenderer::paintToGraphicsContext(BackingStore::PlatformGraphicsContext painter)
+void LayerTreeRenderer::paintToGraphicsContext(BackingStore::PlatformGraphicsContext painter)
 {
     if (!m_textureMapper)
         m_textureMapper = TextureMapper::create();
@@ -153,23 +153,23 @@ void WebLayerTreeRenderer::paintToGraphicsContext(BackingStore::PlatformGraphics
     m_textureMapper->setGraphicsContext(0);
 }
 
-void WebLayerTreeRenderer::setContentsSize(const WebCore::FloatSize& contentsSize)
+void LayerTreeRenderer::setContentsSize(const WebCore::FloatSize& contentsSize)
 {
     m_contentsSize = contentsSize;
 }
 
-void WebLayerTreeRenderer::setVisibleContentsRect(const FloatRect& rect)
+void LayerTreeRenderer::setVisibleContentsRect(const FloatRect& rect)
 {
     m_visibleContentsRect = rect;
 }
 
-void WebLayerTreeRenderer::updateViewport()
+void LayerTreeRenderer::updateViewport()
 {
     if (m_layerTreeCoordinatorProxy)
         m_layerTreeCoordinatorProxy->updateViewport();
 }
 
-void WebLayerTreeRenderer::adjustPositionForFixedLayers()
+void LayerTreeRenderer::adjustPositionForFixedLayers()
 {
     if (m_fixedLayers.isEmpty())
         return;
@@ -186,12 +186,12 @@ void WebLayerTreeRenderer::adjustPositionForFixedLayers()
         toTextureMapperLayer(it->second)->setScrollPositionDeltaIfNeeded(delta);
 }
 
-void WebLayerTreeRenderer::didChangeScrollPosition(const IntPoint& position)
+void LayerTreeRenderer::didChangeScrollPosition(const IntPoint& position)
 {
     m_pendingRenderedContentsScrollPosition = position;
 }
 
-void WebLayerTreeRenderer::syncCanvas(WebLayerID id, const WebCore::IntSize& canvasSize, uint32_t graphicsSurfaceToken)
+void LayerTreeRenderer::syncCanvas(WebLayerID id, const WebCore::IntSize& canvasSize, uint32_t graphicsSurfaceToken)
 {
     if (canvasSize.isEmpty() || !m_textureMapper)
         return;
@@ -213,7 +213,7 @@ void WebLayerTreeRenderer::syncCanvas(WebLayerID id, const WebCore::IntSize& can
 #endif
 }
 
-void WebLayerTreeRenderer::setLayerChildren(WebLayerID id, const Vector<WebLayerID>& childIDs)
+void LayerTreeRenderer::setLayerChildren(WebLayerID id, const Vector<WebLayerID>& childIDs)
 {
     ensureLayer(id);
     LayerMap::iterator it = m_layers.find(id);
@@ -233,7 +233,7 @@ void WebLayerTreeRenderer::setLayerChildren(WebLayerID id, const Vector<WebLayer
 }
 
 #if ENABLE(CSS_FILTERS)
-void WebLayerTreeRenderer::setLayerFilters(WebLayerID id, const FilterOperations& filters)
+void LayerTreeRenderer::setLayerFilters(WebLayerID id, const FilterOperations& filters)
 {
     ensureLayer(id);
     LayerMap::iterator it = m_layers.find(id);
@@ -244,7 +244,7 @@ void WebLayerTreeRenderer::setLayerFilters(WebLayerID id, const FilterOperations
 }
 #endif
 
-void WebLayerTreeRenderer::setLayerState(WebLayerID id, const WebLayerInfo& layerInfo)
+void LayerTreeRenderer::setLayerState(WebLayerID id, const WebLayerInfo& layerInfo)
 {
     ensureLayer(id);
     LayerMap::iterator it = m_layers.find(id);
@@ -282,7 +282,7 @@ void WebLayerTreeRenderer::setLayerState(WebLayerID id, const WebLayerInfo& laye
         setRootLayerID(id);
 }
 
-void WebLayerTreeRenderer::deleteLayer(WebLayerID layerID)
+void LayerTreeRenderer::deleteLayer(WebLayerID layerID)
 {
     GraphicsLayer* layer = layerByID(layerID);
     if (!layer)
@@ -298,7 +298,7 @@ void WebLayerTreeRenderer::deleteLayer(WebLayerID layerID)
 }
 
 
-void WebLayerTreeRenderer::ensureLayer(WebLayerID id)
+void LayerTreeRenderer::ensureLayer(WebLayerID id)
 {
     // We have to leak the new layer's pointer and manage it ourselves,
     // because OwnPtr is not copyable.
@@ -306,7 +306,7 @@ void WebLayerTreeRenderer::ensureLayer(WebLayerID id)
         m_layers.add(id, createLayer(id).leakPtr());
 }
 
-void WebLayerTreeRenderer::setRootLayerID(WebLayerID layerID)
+void LayerTreeRenderer::setRootLayerID(WebLayerID layerID)
 {
     if (layerID == m_rootLayerID)
         return;
@@ -325,37 +325,37 @@ void WebLayerTreeRenderer::setRootLayerID(WebLayerID layerID)
     m_rootLayer->addChild(layer);
 }
 
-PassRefPtr<LayerBackingStore> WebLayerTreeRenderer::getBackingStore(WebLayerID id)
+PassRefPtr<CoordinatedBackingStore> LayerTreeRenderer::getBackingStore(WebLayerID id)
 {
     TextureMapperLayer* layer = toTextureMapperLayer(layerByID(id));
     ASSERT(layer);
-    RefPtr<LayerBackingStore> backingStore = static_cast<LayerBackingStore*>(layer->backingStore().get());
+    RefPtr<CoordinatedBackingStore> backingStore = static_cast<CoordinatedBackingStore*>(layer->backingStore().get());
     if (!backingStore) {
-        backingStore = LayerBackingStore::create();
+        backingStore = CoordinatedBackingStore::create();
         layer->setBackingStore(backingStore.get());
     }
     ASSERT(backingStore);
     return backingStore;
 }
 
-void WebLayerTreeRenderer::createTile(WebLayerID layerID, int tileID, float scale)
+void LayerTreeRenderer::createTile(WebLayerID layerID, int tileID, float scale)
 {
     getBackingStore(layerID)->createTile(tileID, scale);
 }
 
-void WebLayerTreeRenderer::removeTile(WebLayerID layerID, int tileID)
+void LayerTreeRenderer::removeTile(WebLayerID layerID, int tileID)
 {
     getBackingStore(layerID)->removeTile(tileID);
 }
 
-void WebLayerTreeRenderer::updateTile(WebLayerID layerID, int tileID, const TileUpdate& update)
+void LayerTreeRenderer::updateTile(WebLayerID layerID, int tileID, const TileUpdate& update)
 {
-    RefPtr<LayerBackingStore> backingStore = getBackingStore(layerID);
+    RefPtr<CoordinatedBackingStore> backingStore = getBackingStore(layerID);
     backingStore->updateTile(tileID, update.sourceRect, update.targetRect, update.surface, update.offset);
     m_backingStoresWithPendingBuffers.add(backingStore);
 }
 
-void WebLayerTreeRenderer::createImage(int64_t imageID, PassRefPtr<ShareableBitmap> weakBitmap)
+void LayerTreeRenderer::createImage(int64_t imageID, PassRefPtr<ShareableBitmap> weakBitmap)
 {
     RefPtr<ShareableBitmap> bitmap = weakBitmap;
     RefPtr<TextureMapperTiledBackingStore> backingStore = TextureMapperTiledBackingStore::create();
@@ -363,12 +363,12 @@ void WebLayerTreeRenderer::createImage(int64_t imageID, PassRefPtr<ShareableBitm
     backingStore->updateContents(m_textureMapper.get(), bitmap->createImage().get());
 }
 
-void WebLayerTreeRenderer::destroyImage(int64_t imageID)
+void LayerTreeRenderer::destroyImage(int64_t imageID)
 {
     m_directlyCompositedImages.remove(imageID);
 }
 
-void WebLayerTreeRenderer::assignImageToLayer(GraphicsLayer* layer, int64_t imageID)
+void LayerTreeRenderer::assignImageToLayer(GraphicsLayer* layer, int64_t imageID)
 {
     if (!imageID) {
         layer->setContentsToMedia(0);
@@ -380,16 +380,16 @@ void WebLayerTreeRenderer::assignImageToLayer(GraphicsLayer* layer, int64_t imag
     layer->setContentsToMedia(it->second.get());
 }
 
-void WebLayerTreeRenderer::commitTileOperations()
+void LayerTreeRenderer::commitTileOperations()
 {
-    HashSet<RefPtr<LayerBackingStore> >::iterator end = m_backingStoresWithPendingBuffers.end();
-    for (HashSet<RefPtr<LayerBackingStore> >::iterator it = m_backingStoresWithPendingBuffers.begin(); it != end; ++it)
+    HashSet<RefPtr<CoordinatedBackingStore> >::iterator end = m_backingStoresWithPendingBuffers.end();
+    for (HashSet<RefPtr<CoordinatedBackingStore> >::iterator it = m_backingStoresWithPendingBuffers.begin(); it != end; ++it)
         (*it)->commitTileOperations(m_textureMapper.get());
 
     m_backingStoresWithPendingBuffers.clear();
 }
 
-void WebLayerTreeRenderer::flushLayerChanges()
+void LayerTreeRenderer::flushLayerChanges()
 {
     m_renderedContentsScrollPosition = m_pendingRenderedContentsScrollPosition;
 
@@ -397,16 +397,16 @@ void WebLayerTreeRenderer::flushLayerChanges()
     commitTileOperations();
 
     // The pending tiles state is on its way for the screen, tell the web process to render the next one.
-    callOnMainThread(bind(&WebLayerTreeRenderer::renderNextFrame, this));
+    callOnMainThread(bind(&LayerTreeRenderer::renderNextFrame, this));
 }
 
-void WebLayerTreeRenderer::renderNextFrame()
+void LayerTreeRenderer::renderNextFrame()
 {
     if (m_layerTreeCoordinatorProxy)
         m_layerTreeCoordinatorProxy->renderNextFrame();
 }
 
-void WebLayerTreeRenderer::ensureRootLayer()
+void LayerTreeRenderer::ensureRootLayer()
 {
     if (m_rootLayer)
         return;
@@ -425,7 +425,7 @@ void WebLayerTreeRenderer::ensureRootLayer()
     toTextureMapperLayer(m_rootLayer.get())->setTextureMapper(m_textureMapper.get());
 }
 
-void WebLayerTreeRenderer::syncRemoteContent()
+void LayerTreeRenderer::syncRemoteContent()
 {
     // We enqueue messages and execute them during paint, as they require an active GL context.
     ensureRootLayer();
@@ -436,7 +436,7 @@ void WebLayerTreeRenderer::syncRemoteContent()
     m_renderQueue.clear();
 }
 
-void WebLayerTreeRenderer::purgeGLResources()
+void LayerTreeRenderer::purgeGLResources()
 {
     TextureMapperLayer* layer = toTextureMapperLayer(rootLayer());
 
@@ -458,21 +458,21 @@ void WebLayerTreeRenderer::purgeGLResources()
 
     setActive(false);
 
-    callOnMainThread(bind(&WebLayerTreeRenderer::purgeBackingStores, this));
+    callOnMainThread(bind(&LayerTreeRenderer::purgeBackingStores, this));
 }
 
-void WebLayerTreeRenderer::purgeBackingStores()
+void LayerTreeRenderer::purgeBackingStores()
 {
     if (m_layerTreeCoordinatorProxy)
         m_layerTreeCoordinatorProxy->purgeBackingStores();
 }
 
-void WebLayerTreeRenderer::detach()
+void LayerTreeRenderer::detach()
 {
     m_layerTreeCoordinatorProxy = 0;
 }
 
-void WebLayerTreeRenderer::appendUpdate(const Function<void()>& function)
+void LayerTreeRenderer::appendUpdate(const Function<void()>& function)
 {
     if (!m_isActive)
         return;
@@ -480,7 +480,7 @@ void WebLayerTreeRenderer::appendUpdate(const Function<void()>& function)
     m_renderQueue.append(function);
 }
 
-void WebLayerTreeRenderer::setActive(bool active)
+void LayerTreeRenderer::setActive(bool active)
 {
     if (m_isActive == active)
         return;
@@ -496,4 +496,4 @@ void WebLayerTreeRenderer::setActive(bool active)
 
 } // namespace WebKit
 
-#endif // USE(UI_SIDE_COMPOSITING)
+#endif // USE(COORDINATED_GRAPHICS)
     Boston, MA 02110-1301, USA.
 */
 
-#ifndef WebLayerTreeRenderer_h
-#define WebLayerTreeRenderer_h
+#ifndef LayerTreeRenderer_h
+#define LayerTreeRenderer_h
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 #include "BackingStore.h"
 #include "GraphicsSurface.h"
 #include "ShareableSurface.h"
 
 namespace WebKit {
 
-class LayerBackingStore;
+class CoordinatedBackingStore;
 class LayerTreeCoordinatorProxy;
 class WebLayerInfo;
 class WebLayerUpdateInfo;
 
-class WebLayerTreeRenderer : public ThreadSafeRefCounted<WebLayerTreeRenderer>, public WebCore::GraphicsLayerClient {
+class LayerTreeRenderer : public ThreadSafeRefCounted<LayerTreeRenderer>, public WebCore::GraphicsLayerClient {
 public:
     struct TileUpdate {
         WebCore::IntRect sourceRect;
@@ -59,8 +59,8 @@ public:
         {
         }
     };
-    WebLayerTreeRenderer(LayerTreeCoordinatorProxy*);
-    virtual ~WebLayerTreeRenderer();
+    LayerTreeRenderer(LayerTreeCoordinatorProxy*);
+    virtual ~LayerTreeRenderer();
     void purgeGLResources();
     void paintToCurrentGLContext(const WebCore::TransformationMatrix&, float, const WebCore::FloatRect&, WebCore::TextureMapper::PaintFlags = 0);
     void paintToGraphicsContext(BackingStore::PlatformGraphicsContext);
@@ -114,9 +114,9 @@ private:
 
 #if USE(TEXTURE_MAPPER)
     OwnPtr<WebCore::TextureMapper> m_textureMapper;
-    PassRefPtr<LayerBackingStore> getBackingStore(WebLayerID);
+    PassRefPtr<CoordinatedBackingStore> getBackingStore(WebLayerID);
     HashMap<int64_t, RefPtr<WebCore::TextureMapperBackingStore> > m_directlyCompositedImages;
-    HashSet<RefPtr<LayerBackingStore> > m_backingStoresWithPendingBuffers;
+    HashSet<RefPtr<CoordinatedBackingStore> > m_backingStoresWithPendingBuffers;
 #endif
 #if USE(GRAPHICS_SURFACE)
     typedef HashMap<WebLayerID, RefPtr<WebCore::TextureMapperSurfaceBackingStore> > SurfaceBackingStoreMap;
@@ -147,8 +147,8 @@ private:
 
 };
 
-#endif // USE(UI_SIDE_COMPOSITING)
+#endif // USE(COORDINATED_GRAPHICS)
 
-#endif // WebLayerTreeRenderer_h
+#endif // LayerTreeRenderer_h
 
 
index 5f7b106..79e610e 100644 (file)
@@ -28,7 +28,7 @@
 
 #include "WebPageProxy.h"
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 #include "LayerTreeCoordinatorProxy.h"
 #include <CoreIPC/MessageID.h>
 #endif
@@ -58,7 +58,7 @@ void DrawingAreaProxy::setSize(const IntSize& size, const IntSize& scrollOffset)
     sizeDidChange();
 }
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 void DrawingAreaProxy::updateViewport()
 {
     m_webPageProxy->setViewNeedsDisplay(viewportVisibleRect());
index 99460e4..5c2d508 100644 (file)
@@ -90,7 +90,7 @@ public:
 
     virtual void colorSpaceDidChange() { }
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
     virtual void updateViewport();
     virtual WebCore::IntRect viewportVisibleRect() const { return contentsRect(); }
     virtual WebCore::IntRect contentsRect() const;
@@ -113,7 +113,7 @@ protected:
     WebCore::IntSize m_size;
     WebCore::IntSize m_scrollOffset;
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
     OwnPtr<LayerTreeCoordinatorProxy> m_layerTreeCoordinatorProxy;
 #endif
 
index cd8c5f6..cd9cafc 100644 (file)
@@ -36,7 +36,7 @@
 #include "WebProcessProxy.h"
 #include <WebCore/Region.h>
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 #include "LayerTreeCoordinatorProxy.h"
 #endif
 
@@ -58,7 +58,7 @@ DrawingAreaProxyImpl::DrawingAreaProxyImpl(WebPageProxy* webPageProxy)
     , m_isBackingStoreDiscardable(true)
     , m_discardBackingStoreTimer(RunLoop::current(), this, &DrawingAreaProxyImpl::discardBackingStore)
 {
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
     // Construct the proxy early to allow messages to be sent to the web process while AC is entered there.
     if (webPageProxy->pageGroup()->preferences()->forceCompositingMode())
         m_layerTreeCoordinatorProxy = adoptPtr(new LayerTreeCoordinatorProxy(this));
@@ -353,13 +353,13 @@ void DrawingAreaProxyImpl::enterAcceleratedCompositingMode(const LayerTreeContex
     m_backingStore = nullptr;
     m_layerTreeContext = layerTreeContext;
     m_webPageProxy->enterAcceleratedCompositingMode(layerTreeContext);
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
     if (!m_layerTreeCoordinatorProxy)
         m_layerTreeCoordinatorProxy = adoptPtr(new LayerTreeCoordinatorProxy(this));
 #endif
 }
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 void DrawingAreaProxyImpl::didReceiveLayerTreeCoordinatorProxyMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
 {
     if (m_layerTreeCoordinatorProxy)
index 19a771f..0c9f04f 100644 (file)
@@ -81,7 +81,7 @@ private:
 
     bool isInAcceleratedCompositingMode() const { return !m_layerTreeContext.isEmpty(); }
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
     virtual void setVisibleContentsRect(const WebCore::FloatRect& visibleContentsRect, float scale, const WebCore::FloatPoint& trajectory);
     void didReceiveLayerTreeCoordinatorProxyMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
 #endif
index fd0c0ea..5c522c0 100644 (file)
@@ -94,7 +94,7 @@
 #include "WebIntentServiceInfo.h"
 #endif
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 #include "LayerTreeCoordinatorProxyMessages.h"
 #endif
 
@@ -1747,7 +1747,7 @@ void WebPageProxy::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::M
         return;
     }
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
     if (messageID.is<CoreIPC::MessageClassLayerTreeCoordinatorProxy>()) {
         m_drawingArea->didReceiveLayerTreeCoordinatorProxyMessage(connection, messageID, arguments);
         return;
index 4de77f7..eb70239 100644 (file)
@@ -21,7 +21,7 @@
 #include "config.h"
 #include "QtWebPageSGNode.h"
 
-#include "WebLayerTreeRenderer.h"
+#include "LayerTreeRenderer.h"
 #include <QtGui/QPolygonF>
 #include <QtQuick/QSGSimpleRectNode>
 #include <private/qsgrendernode_p.h>
@@ -32,7 +32,7 @@ namespace WebKit {
 
 class ContentsSGNode : public QSGRenderNode {
 public:
-    ContentsSGNode(PassRefPtr<WebLayerTreeRenderer> renderer)
+    ContentsSGNode(PassRefPtr<LayerTreeRenderer> renderer)
         : m_renderer(renderer)
     {
         layerTreeRenderer()->setActive(true);
@@ -61,7 +61,7 @@ public:
         layerTreeRenderer()->purgeGLResources();
     }
 
-    WebLayerTreeRenderer* layerTreeRenderer() const { return m_renderer.get(); }
+    LayerTreeRenderer* layerTreeRenderer() const { return m_renderer.get(); }
 
 private:
     QRectF clipRect() const
@@ -105,7 +105,7 @@ private:
         return resultRect;
     }
 
-    RefPtr<WebLayerTreeRenderer> m_renderer;
+    RefPtr<LayerTreeRenderer> m_renderer;
 };
 
 QtWebPageSGNode::QtWebPageSGNode()
@@ -128,7 +128,7 @@ void QtWebPageSGNode::setScale(float scale)
     setMatrix(matrix);
 }
 
-void QtWebPageSGNode::setRenderer(PassRefPtr<WebLayerTreeRenderer> renderer)
+void QtWebPageSGNode::setRenderer(PassRefPtr<LayerTreeRenderer> renderer)
 {
     if (m_contentsNode && m_contentsNode->layerTreeRenderer() == renderer)
         return;
index 22a5bcf..11d1898 100644 (file)
@@ -31,14 +31,14 @@ QT_END_NAMESPACE
 namespace WebKit {
 
 class ContentsSGNode;
-class WebLayerTreeRenderer;
+class LayerTreeRenderer;
 
 class QtWebPageSGNode : public QSGTransformNode {
     public:
         QtWebPageSGNode();
         void setBackground(const QRectF&, const QColor&);
         void setScale(float);
-        void setRenderer(PassRefPtr<WebLayerTreeRenderer>);
+        void setRenderer(PassRefPtr<LayerTreeRenderer>);
 
     private:
         ContentsSGNode* m_contentsNode;
index 17d5493..4f48c7a 100644 (file)
@@ -26,6 +26,7 @@ INCLUDEPATH += \
     $$SOURCE_DIR/UIProcess/API/cpp/qt \
     $$SOURCE_DIR/UIProcess/API/qt \
     $$SOURCE_DIR/UIProcess/Authentication \
+    $$SOURCE_DIR/UIProcess/CoordinatedGraphics \
     $$SOURCE_DIR/UIProcess/Downloads \
     $$SOURCE_DIR/UIProcess/InspectorServer \
     $$SOURCE_DIR/UIProcess/InspectorServer/qt \
@@ -58,7 +59,7 @@ INCLUDEPATH += \
     $$SOURCE_DIR/WebProcess/WebCoreSupport \
     $$SOURCE_DIR/WebProcess/WebCoreSupport/qt \
     $$SOURCE_DIR/WebProcess/WebPage \
-    $$SOURCE_DIR/WebProcess/WebPage/LayerTreeCoordinator \
+    $$SOURCE_DIR/WebProcess/WebPage/CoordinatedGraphics \
     $$SOURCE_DIR/WebProcess/qt \
     $$SOURCE_DIR/PluginProcess
 
index 3af5966..c7fc9a7 100644 (file)
@@ -638,7 +638,7 @@ void WebChromeClient::setCursorHiddenUntilMouseMoves(bool hiddenUntilMouseMoves)
 #if ENABLE(REQUEST_ANIMATION_FRAME) && !USE(REQUEST_ANIMATION_FRAME_TIMER)
 void WebChromeClient::scheduleAnimation()
 {
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
     m_page->drawingArea()->layerTreeHost()->scheduleAnimation();
 #endif
 }
 
 #include "config.h"
 
-#if USE(UI_SIDE_COMPOSITING)
-#include "WebGraphicsLayer.h"
+#if USE(COORDINATED_GRAPHICS)
+#include "CoordinatedGraphicsLayer.h"
 
 #include "BackingStore.h"
+#include "CoordinatedTile.h"
 #include "FloatQuad.h"
 #include "Frame.h"
 #include "FrameView.h"
@@ -31,7 +32,6 @@
 #include "LayerTreeCoordinatorProxyMessages.h"
 #include "Page.h"
 #include "TextureMapperPlatformLayer.h"
-#include "TiledBackingStoreRemoteTile.h"
 #include "WebPage.h"
 #include <wtf/CurrentTime.h>
 #include <wtf/HashMap.h>
@@ -41,16 +41,16 @@ using namespace WebKit;
 
 namespace WebCore {
 
-static HashMap<WebLayerID, WebGraphicsLayer*>& layerByIDMap()
+static HashMap<WebLayerID, CoordinatedGraphicsLayer*>& layerByIDMap()
 {
-    static HashMap<WebLayerID, WebGraphicsLayer*> globalMap;
+    static HashMap<WebLayerID, CoordinatedGraphicsLayer*> globalMap;
     return globalMap;
 }
 
-WebGraphicsLayer* WebGraphicsLayer::layerByID(WebKit::WebLayerID id)
+CoordinatedGraphicsLayer* CoordinatedGraphicsLayer::layerByID(WebKit::WebLayerID id)
 {
-    HashMap<WebLayerID, WebGraphicsLayer*>& table = layerByIDMap();
-    HashMap<WebLayerID, WebGraphicsLayer*>::iterator it = table.find(id);
+    HashMap<WebLayerID, CoordinatedGraphicsLayer*>& table = layerByIDMap();
+    HashMap<WebLayerID, CoordinatedGraphicsLayer*>::iterator it = table.find(id);
     if (it == table.end())
         return 0;
     return it->second;
@@ -58,17 +58,17 @@ WebGraphicsLayer* WebGraphicsLayer::layerByID(WebKit::WebLayerID id)
 
 static WebLayerID toWebLayerID(GraphicsLayer* layer)
 {
-    return layer ? toWebGraphicsLayer(layer)->id() : 0;
+    return layer ? toCoordinatedGraphicsLayer(layer)->id() : 0;
 }
 
-void WebGraphicsLayer::didChangeLayerState()
+void CoordinatedGraphicsLayer::didChangeLayerState()
 {
     m_shouldSyncLayerState = true;
     if (client())
         client()->notifySyncRequired(this);
 }
 
-void WebGraphicsLayer::didChangeChildren()
+void CoordinatedGraphicsLayer::didChangeChildren()
 {
     m_shouldSyncChildren = true;
     if (client())
@@ -76,7 +76,7 @@ void WebGraphicsLayer::didChangeChildren()
 }
 
 #if ENABLE(CSS_FILTERS)
-void WebGraphicsLayer::didChangeFilters()
+void CoordinatedGraphicsLayer::didChangeFilters()
 {
     m_shouldSyncFilters = true;
     if (client())
@@ -84,25 +84,25 @@ void WebGraphicsLayer::didChangeFilters()
 }
 #endif
 
-void WebGraphicsLayer::setShouldUpdateVisibleRect()
+void CoordinatedGraphicsLayer::setShouldUpdateVisibleRect()
 {
     if (!transform().isAffine())
         return;
 
     m_shouldUpdateVisibleRect = true;
     for (size_t i = 0; i < children().size(); ++i)
-        toWebGraphicsLayer(children()[i])->setShouldUpdateVisibleRect();
+        toCoordinatedGraphicsLayer(children()[i])->setShouldUpdateVisibleRect();
     if (replicaLayer())
-        toWebGraphicsLayer(replicaLayer())->setShouldUpdateVisibleRect();
+        toCoordinatedGraphicsLayer(replicaLayer())->setShouldUpdateVisibleRect();
 }
 
-void WebGraphicsLayer::didChangeGeometry()
+void CoordinatedGraphicsLayer::didChangeGeometry()
 {
     didChangeLayerState();
     setShouldUpdateVisibleRect();
 }
 
-WebGraphicsLayer::WebGraphicsLayer(GraphicsLayerClient* client)
+CoordinatedGraphicsLayer::CoordinatedGraphicsLayer(GraphicsLayerClient* client)
     : GraphicsLayer(client)
     , m_maskTarget(0)
     , m_inUpdateMode(false)
@@ -111,7 +111,7 @@ WebGraphicsLayer::WebGraphicsLayer(GraphicsLayerClient* client)
     , m_shouldSyncChildren(true)
     , m_fixedToViewport(false)
     , m_canvasNeedsDisplay(false)
-    , m_webGraphicsLayerClient(0)
+    , m_CoordinatedGraphicsLayerClient(0)
     , m_contentsScale(1)
     , m_canvasPlatformLayer(0)
 {
@@ -120,90 +120,90 @@ WebGraphicsLayer::WebGraphicsLayer(GraphicsLayerClient* client)
     layerByIDMap().add(id(), this);
 }
 
-WebGraphicsLayer::~WebGraphicsLayer()
+CoordinatedGraphicsLayer::~CoordinatedGraphicsLayer()
 {
     layerByIDMap().remove(id());
 
-    if (m_webGraphicsLayerClient) {
+    if (m_CoordinatedGraphicsLayerClient) {
         purgeBackingStores();
-        m_webGraphicsLayerClient->detachLayer(this);
+        m_CoordinatedGraphicsLayerClient->detachLayer(this);
     }
     willBeDestroyed();
 }
 
-void WebGraphicsLayer::willBeDestroyed()
+void CoordinatedGraphicsLayer::willBeDestroyed()
 {
     GraphicsLayer::willBeDestroyed();
 }
 
-bool WebGraphicsLayer::setChildren(const Vector<GraphicsLayer*>& children)
+bool CoordinatedGraphicsLayer::setChildren(const Vector<GraphicsLayer*>& children)
 {
     bool ok = GraphicsLayer::setChildren(children);
     if (!ok)
         return false;
     for (int i = 0; i < children.size(); ++i) {
-        WebGraphicsLayer* child = toWebGraphicsLayer(children[i]);
-        child->setWebGraphicsLayerClient(m_webGraphicsLayerClient);
+        CoordinatedGraphicsLayer* child = toCoordinatedGraphicsLayer(children[i]);
+        child->setCoordinatedGraphicsLayerClient(m_CoordinatedGraphicsLayerClient);
         child->didChangeLayerState();
     }
     didChangeChildren();
     return true;
 }
 
-void WebGraphicsLayer::addChild(GraphicsLayer* layer)
+void CoordinatedGraphicsLayer::addChild(GraphicsLayer* layer)
 {
     GraphicsLayer::addChild(layer);
-    toWebGraphicsLayer(layer)->setWebGraphicsLayerClient(m_webGraphicsLayerClient);
-    toWebGraphicsLayer(layer)->didChangeLayerState();
+    toCoordinatedGraphicsLayer(layer)->setCoordinatedGraphicsLayerClient(m_CoordinatedGraphicsLayerClient);
+    toCoordinatedGraphicsLayer(layer)->didChangeLayerState();
     didChangeChildren();
 }
 
-void WebGraphicsLayer::addChildAtIndex(GraphicsLayer* layer, int index)
+void CoordinatedGraphicsLayer::addChildAtIndex(GraphicsLayer* layer, int index)
 {
     GraphicsLayer::addChildAtIndex(layer, index);
-    toWebGraphicsLayer(layer)->setWebGraphicsLayerClient(m_webGraphicsLayerClient);
-    toWebGraphicsLayer(layer)->didChangeLayerState();
+    toCoordinatedGraphicsLayer(layer)->setCoordinatedGraphicsLayerClient(m_CoordinatedGraphicsLayerClient);
+    toCoordinatedGraphicsLayer(layer)->didChangeLayerState();
     didChangeChildren();
 }
 
-void WebGraphicsLayer::addChildAbove(GraphicsLayer* layer, GraphicsLayer* sibling)
+void CoordinatedGraphicsLayer::addChildAbove(GraphicsLayer* layer, GraphicsLayer* sibling)
 {
     GraphicsLayer::addChildAbove(layer, sibling);
-    toWebGraphicsLayer(layer)->setWebGraphicsLayerClient(m_webGraphicsLayerClient);
-    toWebGraphicsLayer(layer)->didChangeLayerState();
+    toCoordinatedGraphicsLayer(layer)->setCoordinatedGraphicsLayerClient(m_CoordinatedGraphicsLayerClient);
+    toCoordinatedGraphicsLayer(layer)->didChangeLayerState();
     didChangeChildren();
 }
 
-void WebGraphicsLayer::addChildBelow(GraphicsLayer* layer, GraphicsLayer* sibling)
+void CoordinatedGraphicsLayer::addChildBelow(GraphicsLayer* layer, GraphicsLayer* sibling)
 {
     GraphicsLayer::addChildBelow(layer, sibling);
-    toWebGraphicsLayer(layer)->setWebGraphicsLayerClient(m_webGraphicsLayerClient);
-    toWebGraphicsLayer(layer)->didChangeLayerState();
+    toCoordinatedGraphicsLayer(layer)->setCoordinatedGraphicsLayerClient(m_CoordinatedGraphicsLayerClient);
+    toCoordinatedGraphicsLayer(layer)->didChangeLayerState();
     didChangeChildren();
 }
 
-bool WebGraphicsLayer::replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild)
+bool CoordinatedGraphicsLayer::replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild)
 {
     bool ok = GraphicsLayer::replaceChild(oldChild, newChild);
     if (!ok)
         return false;
     didChangeChildren();
-    toWebGraphicsLayer(oldChild)->didChangeLayerState();
-    toWebGraphicsLayer(newChild)->setWebGraphicsLayerClient(m_webGraphicsLayerClient);
-    toWebGraphicsLayer(newChild)->didChangeLayerState();
+    toCoordinatedGraphicsLayer(oldChild)->didChangeLayerState();
+    toCoordinatedGraphicsLayer(newChild)->setCoordinatedGraphicsLayerClient(m_CoordinatedGraphicsLayerClient);
+    toCoordinatedGraphicsLayer(newChild)->didChangeLayerState();
     return true;
 }
 
-void WebGraphicsLayer::removeFromParent()
+void CoordinatedGraphicsLayer::removeFromParent()
 {
-    if (WebGraphicsLayer* parentLayer = toWebGraphicsLayer(parent()))
+    if (CoordinatedGraphicsLayer* parentLayer = toCoordinatedGraphicsLayer(parent()))
         parentLayer->didChangeChildren();
     GraphicsLayer::removeFromParent();
 
     didChangeLayerState();
 }
 
-void WebGraphicsLayer::setPosition(const FloatPoint& p)
+void CoordinatedGraphicsLayer::setPosition(const FloatPoint& p)
 {
     if (position() == p)
         return;
@@ -212,7 +212,7 @@ void WebGraphicsLayer::setPosition(const FloatPoint& p)
     didChangeGeometry();
 }
 
-void WebGraphicsLayer::setAnchorPoint(const FloatPoint3D& p)
+void CoordinatedGraphicsLayer::setAnchorPoint(const FloatPoint3D& p)
 {
     if (anchorPoint() == p)
         return;
@@ -221,7 +221,7 @@ void WebGraphicsLayer::setAnchorPoint(const FloatPoint3D& p)
     didChangeGeometry();
 }
 
-void WebGraphicsLayer::setSize(const FloatSize& size)
+void CoordinatedGraphicsLayer::setSize(const FloatSize& size)
 {
     if (this->size() == size)
         return;
@@ -233,7 +233,7 @@ void WebGraphicsLayer::setSize(const FloatSize& size)
     didChangeGeometry();
 }
 
-void WebGraphicsLayer::setTransform(const TransformationMatrix& t)
+void CoordinatedGraphicsLayer::setTransform(const TransformationMatrix& t)
 {
     if (transform() == t)
         return;
@@ -242,7 +242,7 @@ void WebGraphicsLayer::setTransform(const TransformationMatrix& t)
     didChangeGeometry();
 }
 
-void WebGraphicsLayer::setChildrenTransform(const TransformationMatrix& t)
+void CoordinatedGraphicsLayer::setChildrenTransform(const TransformationMatrix& t)
 {
     if (childrenTransform() == t)
         return;
@@ -251,7 +251,7 @@ void WebGraphicsLayer::setChildrenTransform(const TransformationMatrix& t)
     didChangeGeometry();
 }
 
-void WebGraphicsLayer::setPreserves3D(bool b)
+void CoordinatedGraphicsLayer::setPreserves3D(bool b)
 {
     if (preserves3D() == b)
         return;
@@ -260,7 +260,7 @@ void WebGraphicsLayer::setPreserves3D(bool b)
     didChangeGeometry();
 }
 
-void WebGraphicsLayer::setMasksToBounds(bool b)
+void CoordinatedGraphicsLayer::setMasksToBounds(bool b)
 {
     if (masksToBounds() == b)
         return;
@@ -268,7 +268,7 @@ void WebGraphicsLayer::setMasksToBounds(bool b)
     didChangeGeometry();
 }
 
-void WebGraphicsLayer::setDrawsContent(bool b)
+void CoordinatedGraphicsLayer::setDrawsContent(bool b)
 {
     if (drawsContent() == b)
         return;
@@ -277,7 +277,7 @@ void WebGraphicsLayer::setDrawsContent(bool b)
     didChangeLayerState();
 }
 
-void WebGraphicsLayer::setContentsVisible(bool b)
+void CoordinatedGraphicsLayer::setContentsVisible(bool b)
 {
     if (contentsAreVisible() == b)
         return;
@@ -286,7 +286,7 @@ void WebGraphicsLayer::setContentsVisible(bool b)
     didChangeLayerState();
 }
 
-void WebGraphicsLayer::setContentsOpaque(bool b)
+void CoordinatedGraphicsLayer::setContentsOpaque(bool b)
 {
     if (contentsOpaque() == b)
         return;
@@ -296,7 +296,7 @@ void WebGraphicsLayer::setContentsOpaque(bool b)
     didChangeLayerState();
 }
 
-void WebGraphicsLayer::setBackfaceVisibility(bool b)
+void CoordinatedGraphicsLayer::setBackfaceVisibility(bool b)
 {
     if (backfaceVisibility() == b)
         return;
@@ -305,7 +305,7 @@ void WebGraphicsLayer::setBackfaceVisibility(bool b)
     didChangeLayerState();
 }
 
-void WebGraphicsLayer::setOpacity(float opacity)
+void CoordinatedGraphicsLayer::setOpacity(float opacity)
 {
     if (this->opacity() == opacity)
         return;
@@ -314,7 +314,7 @@ void WebGraphicsLayer::setOpacity(float opacity)
     didChangeLayerState();
 }
 
-void WebGraphicsLayer::setContentsRect(const IntRect& r)
+void CoordinatedGraphicsLayer::setContentsRect(const IntRect& r)
 {
     if (contentsRect() == r)
         return;
@@ -323,7 +323,7 @@ void WebGraphicsLayer::setContentsRect(const IntRect& r)
     didChangeLayerState();
 }
 
-void WebGraphicsLayer::setContentsNeedsDisplay()
+void CoordinatedGraphicsLayer::setContentsNeedsDisplay()
 {
     RefPtr<Image> image = m_image;
     setContentsToImage(0);
@@ -333,7 +333,7 @@ void WebGraphicsLayer::setContentsNeedsDisplay()
         client()->notifySyncRequired(this);
 }
 
-void WebGraphicsLayer::setContentsToCanvas(PlatformLayer* platformLayer)
+void CoordinatedGraphicsLayer::setContentsToCanvas(PlatformLayer* platformLayer)
 {
     m_canvasPlatformLayer = platformLayer;
     m_canvasNeedsDisplay = true;
@@ -342,7 +342,7 @@ void WebGraphicsLayer::setContentsToCanvas(PlatformLayer* platformLayer)
 }
 
 #if ENABLE(CSS_FILTERS)
-bool WebGraphicsLayer::setFilters(const FilterOperations& newFilters)
+bool CoordinatedGraphicsLayer::setFilters(const FilterOperations& newFilters)
 {
     if (filters() == newFilters)
         return true;
@@ -352,20 +352,20 @@ bool WebGraphicsLayer::setFilters(const FilterOperations& newFilters)
 #endif
 
 
-void WebGraphicsLayer::setContentsToImage(Image* image)
+void CoordinatedGraphicsLayer::setContentsToImage(Image* image)
 {
     if (image == m_image)
         return;
     int64_t newID = 0;
-    if (m_webGraphicsLayerClient) {
+    if (m_CoordinatedGraphicsLayerClient) {
         // We adopt first, in case this is the same frame - that way we avoid destroying and recreating the image.
-        newID = m_webGraphicsLayerClient->adoptImageBackingStore(image);
-        m_webGraphicsLayerClient->releaseImageBackingStore(m_layerInfo.imageBackingStoreID);
+        newID = m_CoordinatedGraphicsLayerClient->adoptImageBackingStore(image);
+        m_CoordinatedGraphicsLayerClient->releaseImageBackingStore(m_layerInfo.imageBackingStoreID);
         didChangeLayerState();
         if (m_layerInfo.imageBackingStoreID && newID == m_layerInfo.imageBackingStoreID)
             return;
     } else {
-        // If m_webGraphicsLayerClient is not set yet there should be no backing store ID.
+        // If m_CoordinatedGraphicsLayerClient is not set yet there should be no backing store ID.
         ASSERT(!m_layerInfo.imageBackingStoreID);
         didChangeLayerState();
     }
@@ -375,7 +375,7 @@ void WebGraphicsLayer::setContentsToImage(Image* image)
     GraphicsLayer::setContentsToImage(image);
 }
 
-void WebGraphicsLayer::setMaskLayer(GraphicsLayer* layer)
+void CoordinatedGraphicsLayer::setMaskLayer(GraphicsLayer* layer)
 {
     if (layer == maskLayer())
         return;
@@ -386,52 +386,52 @@ void WebGraphicsLayer::setMaskLayer(GraphicsLayer* layer)
         return;
 
     layer->setSize(size());
-    WebGraphicsLayer* webGraphicsLayer = toWebGraphicsLayer(layer);
-    webGraphicsLayer->setWebGraphicsLayerClient(m_webGraphicsLayerClient);
-    webGraphicsLayer->setMaskTarget(this);
-    webGraphicsLayer->didChangeLayerState();
+    CoordinatedGraphicsLayer* CoordinatedGraphicsLayer = toCoordinatedGraphicsLayer(layer);
+    CoordinatedGraphicsLayer->setCoordinatedGraphicsLayerClient(m_CoordinatedGraphicsLayerClient);
+    CoordinatedGraphicsLayer->setMaskTarget(this);
+    CoordinatedGraphicsLayer->didChangeLayerState();
     didChangeLayerState();
 
 }
 
-void WebGraphicsLayer::setReplicatedByLayer(GraphicsLayer* layer)
+void CoordinatedGraphicsLayer::setReplicatedByLayer(GraphicsLayer* layer)
 {
     if (layer == replicaLayer())
         return;
 
     if (layer)
-        toWebGraphicsLayer(layer)->setWebGraphicsLayerClient(m_webGraphicsLayerClient);
+        toCoordinatedGraphicsLayer(layer)->setCoordinatedGraphicsLayerClient(m_CoordinatedGraphicsLayerClient);
 
     GraphicsLayer::setReplicatedByLayer(layer);
     didChangeLayerState();
 }
 
-void WebGraphicsLayer::setNeedsDisplay()
+void CoordinatedGraphicsLayer::setNeedsDisplay()
 {
     setNeedsDisplayInRect(IntRect(IntPoint::zero(), IntSize(size().width(), size().height())));
 }
 
-void WebGraphicsLayer::setNeedsDisplayInRect(const FloatRect& rect)
+void CoordinatedGraphicsLayer::setNeedsDisplayInRect(const FloatRect& rect)
 {
     if (m_mainBackingStore)
         m_mainBackingStore->invalidate(IntRect(rect));
     didChangeLayerState();
 }
 
-WebLayerID WebGraphicsLayer::id() const
+WebLayerID CoordinatedGraphicsLayer::id() const
 {
     return m_id;
 }
 
-void WebGraphicsLayer::syncCompositingState(const FloatRect& rect)
+void CoordinatedGraphicsLayer::syncCompositingState(const FloatRect& rect)
 {
-    if (WebGraphicsLayer* mask = toWebGraphicsLayer(maskLayer()))
+    if (CoordinatedGraphicsLayer* mask = toCoordinatedGraphicsLayer(maskLayer()))
         mask->syncCompositingStateForThisLayerOnly();
 
-    if (WebGraphicsLayer* replica = toWebGraphicsLayer(replicaLayer()))
+    if (CoordinatedGraphicsLayer* replica = toCoordinatedGraphicsLayer(replicaLayer()))
         replica->syncCompositingStateForThisLayerOnly();
 
-    m_webGraphicsLayerClient->syncFixedLayers();
+    m_CoordinatedGraphicsLayerClient->syncFixedLayers();
 
     syncCompositingStateForThisLayerOnly();
 
@@ -439,12 +439,12 @@ void WebGraphicsLayer::syncCompositingState(const FloatRect& rect)
         children()[i]->syncCompositingState(rect);
 }
 
-WebGraphicsLayer* toWebGraphicsLayer(GraphicsLayer* layer)
+CoordinatedGraphicsLayer* toCoordinatedGraphicsLayer(GraphicsLayer* layer)
 {
-    return static_cast<WebGraphicsLayer*>(layer);
+    return static_cast<CoordinatedGraphicsLayer*>(layer);
 }
 
-void WebGraphicsLayer::syncChildren()
+void CoordinatedGraphicsLayer::syncChildren()
 {
     if (!m_shouldSyncChildren)
         return;
@@ -453,20 +453,20 @@ void WebGraphicsLayer::syncChildren()
     for (size_t i = 0; i < children().size(); ++i)
         childIDs.append(toWebLayerID(children()[i]));
 
-    m_webGraphicsLayerClient->syncLayerChildren(m_id, childIDs);
+    m_CoordinatedGraphicsLayerClient->syncLayerChildren(m_id, childIDs);
 }
 
 #if ENABLE(CSS_FILTERS)
-void WebGraphicsLayer::syncFilters()
+void CoordinatedGraphicsLayer::syncFilters()
 {
     if (!m_shouldSyncFilters)
         return;
     m_shouldSyncFilters = false;
-    m_webGraphicsLayerClient->syncLayerFilters(m_id, filters());
+    m_CoordinatedGraphicsLayerClient->syncLayerFilters(m_id, filters());
 }
 #endif
 
-void WebGraphicsLayer::syncLayerState()
+void CoordinatedGraphicsLayer::syncLayerState()
 {
     if (!m_shouldSyncLayerState)
         return;
@@ -489,10 +489,10 @@ void WebGraphicsLayer::syncLayerState()
     m_layerInfo.replica = toWebLayerID(replicaLayer());
     m_layerInfo.size = size();
     m_layerInfo.transform = transform();
-    m_webGraphicsLayerClient->syncLayerState(m_id, m_layerInfo);
+    m_CoordinatedGraphicsLayerClient->syncLayerState(m_id, m_layerInfo);
 }
 
-void WebGraphicsLayer::syncCanvas()
+void CoordinatedGraphicsLayer::syncCanvas()
 {
     if (!m_canvasNeedsDisplay)
         return;
@@ -502,20 +502,20 @@ void WebGraphicsLayer::syncCanvas()
 
 #if USE(GRAPHICS_SURFACE)
     uint32_t graphicsSurfaceToken = m_canvasPlatformLayer->copyToGraphicsSurface();
-    m_webGraphicsLayerClient->syncCanvas(m_id, IntSize(size().width(), size().height()), graphicsSurfaceToken);
+    m_CoordinatedGraphicsLayerClient->syncCanvas(m_id, IntSize(size().width(), size().height()), graphicsSurfaceToken);
 #endif
     m_canvasNeedsDisplay = false;
 }
 
-void WebGraphicsLayer::ensureImageBackingStore()
+void CoordinatedGraphicsLayer::ensureImageBackingStore()
 {
     if (!m_image)
         return;
     if (!m_layerInfo.imageBackingStoreID)
-        m_layerInfo.imageBackingStoreID = m_webGraphicsLayerClient->adoptImageBackingStore(m_image.get());
+        m_layerInfo.imageBackingStoreID = m_CoordinatedGraphicsLayerClient->adoptImageBackingStore(m_image.get());
 }
 
-void WebGraphicsLayer::syncCompositingStateForThisLayerOnly()
+void CoordinatedGraphicsLayer::syncCompositingStateForThisLayerOnly()
 {
     // The remote image might have been released by purgeBackingStores.
     ensureImageBackingStore();
@@ -529,34 +529,34 @@ void WebGraphicsLayer::syncCompositingStateForThisLayerOnly()
     syncCanvas();
 }
 
-void WebGraphicsLayer::tiledBackingStorePaintBegin()
+void CoordinatedGraphicsLayer::tiledBackingStorePaintBegin()
 {
 }
 
-void WebGraphicsLayer::setRootLayer(bool isRoot)
+void CoordinatedGraphicsLayer::setRootLayer(bool isRoot)
 {
     m_layerInfo.isRootLayer = isRoot;
     didChangeLayerState();
 }
 
-void WebGraphicsLayer::setVisibleContentRectTrajectoryVector(const FloatPoint& trajectoryVector)
+void CoordinatedGraphicsLayer::setVisibleContentRectTrajectoryVector(const FloatPoint& trajectoryVector)
 {
     if (m_mainBackingStore)
         m_mainBackingStore->coverWithTilesIfNeeded(trajectoryVector);
 }
 
-void WebGraphicsLayer::setContentsScale(float scale)
+void CoordinatedGraphicsLayer::setContentsScale(float scale)
 {
     m_contentsScale = scale;
     adjustContentsScale();
 }
 
-float WebGraphicsLayer::effectiveContentsScale()
+float CoordinatedGraphicsLayer::effectiveContentsScale()
 {
     return shouldUseTiledBackingStore() ? m_contentsScale : 1;
 }
 
-void WebGraphicsLayer::adjustContentsScale()
+void CoordinatedGraphicsLayer::adjustContentsScale()
 {
     if (!drawsContent())
         return;
@@ -576,42 +576,42 @@ void WebGraphicsLayer::adjustContentsScale()
     createBackingStore();
 }
 
-void WebGraphicsLayer::createBackingStore()
+void CoordinatedGraphicsLayer::createBackingStore()
 {
-    m_mainBackingStore = adoptPtr(new TiledBackingStore(this, TiledBackingStoreRemoteTileBackend::create(this)));
+    m_mainBackingStore = adoptPtr(new TiledBackingStore(this, CoordinatedTileBackend::create(this)));
     m_mainBackingStore->setSupportsAlpha(!contentsOpaque());
     m_mainBackingStore->setContentsScale(effectiveContentsScale());
 }
 
-void WebGraphicsLayer::tiledBackingStorePaint(GraphicsContext* context, const IntRect& rect)
+void CoordinatedGraphicsLayer::tiledBackingStorePaint(GraphicsContext* context, const IntRect& rect)
 {
     if (rect.isEmpty())
         return;
     paintGraphicsLayerContents(*context, rect);
 }
 
-void WebGraphicsLayer::tiledBackingStorePaintEnd(const Vector<IntRect>& updatedRects)
+void CoordinatedGraphicsLayer::tiledBackingStorePaintEnd(const Vector<IntRect>& updatedRects)
 {
 }
 
-bool WebGraphicsLayer::tiledBackingStoreUpdatesAllowed() const
+bool CoordinatedGraphicsLayer::tiledBackingStoreUpdatesAllowed() const
 {
     if (!m_inUpdateMode)
         return false;
-    return m_webGraphicsLayerClient->layerTreeTileUpdatesAllowed();
+    return m_CoordinatedGraphicsLayerClient->layerTreeTileUpdatesAllowed();
 }
 
-IntRect WebGraphicsLayer::tiledBackingStoreContentsRect()
+IntRect CoordinatedGraphicsLayer::tiledBackingStoreContentsRect()
 {
     return IntRect(0, 0, size().width(), size().height());
 }
 
-bool WebGraphicsLayer::shouldUseTiledBackingStore()
+bool CoordinatedGraphicsLayer::shouldUseTiledBackingStore()
 {
     return !selfOrAncestorHaveNonAffineTransforms();
 }
 
-IntRect WebGraphicsLayer::tiledBackingStoreVisibleRect()
+IntRect CoordinatedGraphicsLayer::tiledBackingStoreVisibleRect()
 {
     if (!shouldUseTiledBackingStore())
         return tiledBackingStoreContentsRect();
@@ -623,35 +623,35 @@ IntRect WebGraphicsLayer::tiledBackingStoreVisibleRect()
     // Return a projection of the visible rect (surface coordinates) onto the layer's plane (layer coordinates).
     // The resulting quad might be squewed and the visible rect is the bounding box of this quad,
     // so it might spread further than the real visible area (and then even more amplified by the cover rect multiplier).
-    return enclosingIntRect(m_layerTransform.combined().inverse().clampedBoundsOfProjectedQuad(FloatQuad(FloatRect(m_webGraphicsLayerClient->visibleContentsRect()))));
+    return enclosingIntRect(m_layerTransform.combined().inverse().clampedBoundsOfProjectedQuad(FloatQuad(FloatRect(m_CoordinatedGraphicsLayerClient->visibleContentsRect()))));
 }
 
-Color WebGraphicsLayer::tiledBackingStoreBackgroundColor() const
+Color CoordinatedGraphicsLayer::tiledBackingStoreBackgroundColor() const
 {
     return contentsOpaque() ? Color::white : Color::transparent;
 }
 
-PassOwnPtr<WebCore::GraphicsContext> WebGraphicsLayer::beginContentUpdate(const WebCore::IntSize& size, ShareableSurface::Handle& handle, WebCore::IntPoint& offset)
+PassOwnPtr<WebCore::GraphicsContext> CoordinatedGraphicsLayer::beginContentUpdate(const WebCore::IntSize& size, ShareableSurface::Handle& handle, WebCore::IntPoint& offset)
 {
-    return m_webGraphicsLayerClient->beginContentUpdate(size, contentsOpaque() ? 0 : ShareableBitmap::SupportsAlpha, handle, offset);
+    return m_CoordinatedGraphicsLayerClient->beginContentUpdate(size, contentsOpaque() ? 0 : ShareableBitmap::SupportsAlpha, handle, offset);
 }
 
-void WebGraphicsLayer::createTile(int tileID, const SurfaceUpdateInfo& updateInfo, const IntRect& targetRect)
+void CoordinatedGraphicsLayer::createTile(int tileID, const SurfaceUpdateInfo& updateInfo, const IntRect& targetRect)
 {
-    m_webGraphicsLayerClient->createTile(id(), tileID, updateInfo, targetRect);
+    m_CoordinatedGraphicsLayerClient->createTile(id(), tileID, updateInfo, targetRect);
 }
 
-void WebGraphicsLayer::updateTile(int tileID, const SurfaceUpdateInfo& updateInfo, const IntRect& targetRect)
+void CoordinatedGraphicsLayer::updateTile(int tileID, const SurfaceUpdateInfo& updateInfo, const IntRect& targetRect)
 {
-    m_webGraphicsLayerClient->updateTile(id(), tileID, updateInfo, targetRect);
+    m_CoordinatedGraphicsLayerClient->updateTile(id(), tileID, updateInfo, targetRect);
 }
 
-void WebGraphicsLayer::removeTile(int tileID)
+void CoordinatedGraphicsLayer::removeTile(int tileID)
 {
-    m_webGraphicsLayerClient->removeTile(id(), tileID);
+    m_CoordinatedGraphicsLayerClient->removeTile(id(), tileID);
 }
 
-void WebGraphicsLayer::updateContentBuffers()
+void CoordinatedGraphicsLayer::updateContentBuffers()
 {
     if (!drawsContent()) {
         m_mainBackingStore.clear();
@@ -674,13 +674,13 @@ void WebGraphicsLayer::updateContentBuffers()
         m_previousBackingStore.clear();
 }
 
-void WebGraphicsLayer::purgeBackingStores()
+void CoordinatedGraphicsLayer::purgeBackingStores()
 {
     m_mainBackingStore.clear();
     m_previousBackingStore.clear();
 
     if (m_layerInfo.imageBackingStoreID) {
-        m_webGraphicsLayerClient->releaseImageBackingStore(m_layerInfo.imageBackingStoreID);
+        m_CoordinatedGraphicsLayerClient->releaseImageBackingStore(m_layerInfo.imageBackingStoreID);
         m_layerInfo.imageBackingStoreID = 0;
     }
 
@@ -688,37 +688,37 @@ void WebGraphicsLayer::purgeBackingStores()
     didChangeChildren();
 }
 
-void WebGraphicsLayer::setWebGraphicsLayerClient(WebKit::WebGraphicsLayerClient* client)
+void CoordinatedGraphicsLayer::setCoordinatedGraphicsLayerClient(WebKit::CoordinatedGraphicsLayerClient* client)
 {
-    if (m_webGraphicsLayerClient == client)
+    if (m_CoordinatedGraphicsLayerClient == client)
         return;
 
-    if (WebGraphicsLayer* replica = toWebGraphicsLayer(replicaLayer()))
-        replica->setWebGraphicsLayerClient(client);
-    if (WebGraphicsLayer* mask = toWebGraphicsLayer(maskLayer()))
-        mask->setWebGraphicsLayerClient(client);
+    if (CoordinatedGraphicsLayer* replica = toCoordinatedGraphicsLayer(replicaLayer()))
+        replica->setCoordinatedGraphicsLayerClient(client);
+    if (CoordinatedGraphicsLayer* mask = toCoordinatedGraphicsLayer(maskLayer()))
+        mask->setCoordinatedGraphicsLayerClient(client);
     for (size_t i = 0; i < children().size(); ++i) {
-        WebGraphicsLayer* layer = toWebGraphicsLayer(this->children()[i]);
-        layer->setWebGraphicsLayerClient(client);
+        CoordinatedGraphicsLayer* layer = toCoordinatedGraphicsLayer(this->children()[i]);
+        layer->setCoordinatedGraphicsLayerClient(client);
     }
 
     // We have to release resources on the UI process here if the remote client has changed or is removed.
-    if (m_webGraphicsLayerClient) {
+    if (m_CoordinatedGraphicsLayerClient) {
         purgeBackingStores();
-        m_webGraphicsLayerClient->detachLayer(this);
+        m_CoordinatedGraphicsLayerClient->detachLayer(this);
     }
-    m_webGraphicsLayerClient = client;
+    m_CoordinatedGraphicsLayerClient = client;
     if (client)
         client->attachLayer(this);
 }
 
-void WebGraphicsLayer::adjustVisibleRect()
+void CoordinatedGraphicsLayer::adjustVisibleRect()
 {
     if (m_mainBackingStore)
         m_mainBackingStore->coverWithTilesIfNeeded();
 }
 
-void WebGraphicsLayer::computeTransformedVisibleRect()
+void CoordinatedGraphicsLayer::computeTransformedVisibleRect()
 {
     if (!m_shouldUpdateVisibleRect)
         return;
@@ -729,24 +729,24 @@ void WebGraphicsLayer::computeTransformedVisibleRect()
     m_layerTransform.setSize(size());
     m_layerTransform.setFlattening(!preserves3D());
     m_layerTransform.setChildrenTransform(childrenTransform());
-    m_layerTransform.combineTransforms(parent() ? toWebGraphicsLayer(parent())->m_layerTransform.combinedForChildren() : TransformationMatrix());
+    m_layerTransform.combineTransforms(parent() ? toCoordinatedGraphicsLayer(parent())->m_layerTransform.combinedForChildren() : TransformationMatrix());
 
     // The combined transform will be used in tiledBackingStoreVisibleRect.
     adjustVisibleRect();
     adjustContentsScale();
 }
 
-static PassOwnPtr<GraphicsLayer> createWebGraphicsLayer(GraphicsLayerClient* client)
+static PassOwnPtr<GraphicsLayer> createCoordinatedGraphicsLayer(GraphicsLayerClient* client)
 {
-    return adoptPtr(new WebGraphicsLayer(client));
+    return adoptPtr(new CoordinatedGraphicsLayer(client));
 }
 
-void WebGraphicsLayer::initFactory()
+void CoordinatedGraphicsLayer::initFactory()
 {
-    GraphicsLayer::setGraphicsLayerFactory(createWebGraphicsLayer);
+    GraphicsLayer::setGraphicsLayerFactory(createCoordinatedGraphicsLayer);
 }
 
-bool WebGraphicsLayer::selfOrAncestorHaveNonAffineTransforms()
+bool CoordinatedGraphicsLayer::selfOrAncestorHaveNonAffineTransforms()
 {
     if (!m_layerTransform.combined().isAffine())
         return true;
  */
 
 
-#ifndef WebGraphicsLayer_h
-#define WebGraphicsLayer_h
+#ifndef CoordinatedGraphicsLayer_h
+#define CoordinatedGraphicsLayer_h
 
+#include "CoordinatedTile.h"
 #include "FloatPoint3D.h"
 #include "GraphicsLayer.h"
 #include "GraphicsLayerTransform.h"
@@ -29,7 +30,6 @@
 #include "ShareableBitmap.h"
 #include "TiledBackingStore.h"
 #include "TiledBackingStoreClient.h"
-#include "TiledBackingStoreRemoteTile.h"
 #include "TransformationMatrix.h"
 #include "UpdateInfo.h"
 #include "WebLayerTreeInfo.h"
 #include <WebCore/RunLoop.h>
 #include <wtf/text/StringHash.h>
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 namespace WebCore {
-class WebGraphicsLayer;
+class CoordinatedGraphicsLayer;
 }
 
 namespace WebKit {
 
-class WebGraphicsLayerClient {
+class CoordinatedGraphicsLayerClient {
 public:
-    // TiledBackingStoreRemoteTileClient
+    // CoordinatedTileClient
     virtual void createTile(WebLayerID, int tileID, const SurfaceUpdateInfo&, const WebCore::IntRect&) = 0;
     virtual void updateTile(WebLayerID, int tileID, const SurfaceUpdateInfo&, const WebCore::IntRect&) = 0;
     virtual void removeTile(WebLayerID, int tileID) = 0;
@@ -63,8 +63,8 @@ public:
 #if PLATFORM(QT)
     virtual void syncCanvas(WebLayerID, const WebCore::IntSize& canvasSize, uint32_t graphicsSurfaceToken) = 0;
 #endif
-    virtual void attachLayer(WebCore::WebGraphicsLayer*) = 0;
-    virtual void detachLayer(WebCore::WebGraphicsLayer*) = 0;
+    virtual void attachLayer(WebCore::CoordinatedGraphicsLayer*) = 0;
+    virtual void detachLayer(WebCore::CoordinatedGraphicsLayer*) = 0;
     virtual void syncFixedLayers() = 0;
     virtual PassOwnPtr<WebCore::GraphicsContext> beginContentUpdate(const WebCore::IntSize&, ShareableBitmap::Flags, ShareableSurface::Handle&, WebCore::IntPoint&) = 0;
 };
@@ -72,12 +72,12 @@ public:
 
 namespace WebCore {
 
-class WebGraphicsLayer : public WebCore::GraphicsLayer
+class CoordinatedGraphicsLayer : public WebCore::GraphicsLayer
                        , public TiledBackingStoreClient
-                       , public WebKit::TiledBackingStoreRemoteTileClient {
+                       , public WebKit::CoordinatedTileClient {
 public:
-    WebGraphicsLayer(GraphicsLayerClient*);
-    virtual ~WebGraphicsLayer();
+    CoordinatedGraphicsLayer(GraphicsLayerClient*);
+    virtual ~CoordinatedGraphicsLayer();
 
     // Reimplementations from GraphicsLayer.h.
     bool setChildren(const Vector<GraphicsLayer*>&);
@@ -118,7 +118,7 @@ public:
     void setRootLayer(bool);
 
     WebKit::WebLayerID id() const;
-    static WebGraphicsLayer* layerByID(WebKit::WebLayerID);
+    static CoordinatedGraphicsLayer* layerByID(WebKit::WebLayerID);
     void didSynchronize();
     Image* image() { return m_image.get(); }
 
@@ -139,13 +139,13 @@ public:
     virtual IntRect tiledBackingStoreVisibleRect();
     virtual Color tiledBackingStoreBackgroundColor() const;
 
-    // TiledBackingStoreRemoteTileClient
+    // CoordinatedTileClient
     virtual void createTile(int tileID, const WebKit::SurfaceUpdateInfo&, const WebCore::IntRect&);
     virtual void updateTile(int tileID, const WebKit::SurfaceUpdateInfo&, const WebCore::IntRect&);
     virtual void removeTile(int tileID);
     virtual PassOwnPtr<WebCore::GraphicsContext> beginContentUpdate(const WebCore::IntSize&, WebKit::ShareableSurface::Handle&, WebCore::IntPoint&);
 
-    void setWebGraphicsLayerClient(WebKit::WebGraphicsLayerClient*);
+    void setCoordinatedGraphicsLayerClient(WebKit::CoordinatedGraphicsLayerClient*);
     void syncChildren();
     void syncLayerState();
 #if ENABLE(CSS_FILTERS)
@@ -193,16 +193,16 @@ private:
     void setShouldUpdateVisibleRect();
     float effectiveContentsScale();
 
-    WebKit::WebGraphicsLayerClient* m_webGraphicsLayerClient;
+    WebKit::CoordinatedGraphicsLayerClient* m_CoordinatedGraphicsLayerClient;
     OwnPtr<WebCore::TiledBackingStore> m_mainBackingStore;
     OwnPtr<WebCore::TiledBackingStore> m_previousBackingStore;
     float m_contentsScale;
     PlatformLayer* m_canvasPlatformLayer;
 };
 
-WebGraphicsLayer* toWebGraphicsLayer(GraphicsLayer*);
+CoordinatedGraphicsLayer* toCoordinatedGraphicsLayer(GraphicsLayer*);
 
 }
 #endif
 
-#endif // WebGraphicsLayer_H
+#endif // CoordinatedGraphicsLayer_H
@@ -24,7 +24,7 @@
  */
 
 #include "config.h"
-#include "TiledBackingStoreRemoteTile.h"
+#include "CoordinatedTile.h"
 
 #if USE(TILED_BACKING_STORE)
 
@@ -37,7 +37,7 @@ using namespace WebCore;
 
 namespace WebKit {
 
-TiledBackingStoreRemoteTile::TiledBackingStoreRemoteTile(TiledBackingStoreRemoteTileClient* client, TiledBackingStore* tiledBackingStore, const Coordinate& tileCoordinate)
+CoordinatedTile::CoordinatedTile(CoordinatedTileClient* client, TiledBackingStore* tiledBackingStore, const Coordinate& tileCoordinate)
     : m_client(client)
     , m_tiledBackingStore(tiledBackingStore)
     , m_coordinate(tileCoordinate)
@@ -47,18 +47,18 @@ TiledBackingStoreRemoteTile::TiledBackingStoreRemoteTile(TiledBackingStoreRemote
 {
 }
 
-TiledBackingStoreRemoteTile::~TiledBackingStoreRemoteTile()
+CoordinatedTile::~CoordinatedTile()
 {
     if (m_ID)
         m_client->removeTile(m_ID);
 }
 
-bool TiledBackingStoreRemoteTile::isDirty() const
+bool CoordinatedTile::isDirty() const
 {
     return !m_dirtyRect.isEmpty();
 }
 
-void TiledBackingStoreRemoteTile::invalidate(const IntRect& dirtyRect)
+void CoordinatedTile::invalidate(const IntRect& dirtyRect)
 {
     IntRect tileDirtyRect = intersection(dirtyRect, m_rect);
     if (tileDirtyRect.isEmpty())
@@ -67,7 +67,7 @@ void TiledBackingStoreRemoteTile::invalidate(const IntRect& dirtyRect)
     m_dirtyRect.unite(tileDirtyRect);
 }
 
-Vector<IntRect> TiledBackingStoreRemoteTile::updateBackBuffer()
+Vector<IntRect> CoordinatedTile::updateBackBuffer()
 {
     if (!isDirty())
         return Vector<IntRect>();
@@ -96,38 +96,38 @@ Vector<IntRect> TiledBackingStoreRemoteTile::updateBackBuffer()
     return Vector<IntRect>();
 }
 
-void TiledBackingStoreRemoteTile::swapBackBufferToFront()
+void CoordinatedTile::swapBackBufferToFront()
 {
     // Handled by tiledBackingStorePaintEnd.
 }
 
-bool TiledBackingStoreRemoteTile::isReadyToPaint() const
+bool CoordinatedTile::isReadyToPaint() const
 {
     return !!m_ID;
 }
 
-void TiledBackingStoreRemoteTile::paint(GraphicsContext* context, const IntRect& rect)
+void CoordinatedTile::paint(GraphicsContext* context, const IntRect& rect)
 {
     ASSERT_NOT_REACHED();
 }
 
-void TiledBackingStoreRemoteTile::resize(const IntSize& newSize)
+void CoordinatedTile::resize(const IntSize& newSize)
 {
     m_rect = IntRect(m_rect.location(), newSize);
     m_dirtyRect = m_rect;
 }
 
-TiledBackingStoreRemoteTileBackend::TiledBackingStoreRemoteTileBackend(TiledBackingStoreRemoteTileClient* client)
+CoordinatedTileBackend::CoordinatedTileBackend(CoordinatedTileClient* client)
     : m_client(client)
 {
 }
 
-PassRefPtr<WebCore::Tile> TiledBackingStoreRemoteTileBackend::createTile(WebCore::TiledBackingStore* tiledBackingStore, const WebCore::Tile::Coordinate& tileCoordinate)
+PassRefPtr<WebCore::Tile> CoordinatedTileBackend::createTile(WebCore::TiledBackingStore* tiledBackingStore, const WebCore::Tile::Coordinate& tileCoordinate)
 {
-    return TiledBackingStoreRemoteTile::create(m_client, tiledBackingStore, tileCoordinate);
+    return CoordinatedTile::create(m_client, tiledBackingStore, tileCoordinate);
 }
 
-void TiledBackingStoreRemoteTileBackend::paintCheckerPattern(WebCore::GraphicsContext*, const WebCore::FloatRect&)
+void CoordinatedTileBackend::paintCheckerPattern(WebCore::GraphicsContext*, const WebCore::FloatRect&)
 {
 }
 
@@ -23,8 +23,8 @@
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef TiledBackingStoreRemoteTile_h
-#define TiledBackingStoreRemoteTile_h
+#ifndef CoordinatedTile_h
+#define CoordinatedTile_h
 
 #if USE(TILED_BACKING_STORE)
 
@@ -40,13 +40,13 @@ class TiledBackingStore;
 
 namespace WebKit {
 
-class TiledBackingStoreRemoteTileClient;
+class CoordinatedTileClient;
 class SurfaceUpdateInfo;
 
-class TiledBackingStoreRemoteTile : public WebCore::Tile {
+class CoordinatedTile : public WebCore::Tile {
 public:
-    static PassRefPtr<Tile> create(TiledBackingStoreRemoteTileClient* client, WebCore::TiledBackingStore* tiledBackingStore, const Coordinate& tileCoordinate) { return adoptRef(new TiledBackingStoreRemoteTile(client, tiledBackingStore, tileCoordinate)); }
-    ~TiledBackingStoreRemoteTile();
+    static PassRefPtr<Tile> create(CoordinatedTileClient* client, WebCore::TiledBackingStore* tiledBackingStore, const Coordinate& tileCoordinate) { return adoptRef(new CoordinatedTile(client, tiledBackingStore, tileCoordinate)); }
+    ~CoordinatedTile();
 
     bool isDirty() const;
     void invalidate(const WebCore::IntRect&);
@@ -60,9 +60,9 @@ public:
     void resize(const WebCore::IntSize&);
 
 private:
-    TiledBackingStoreRemoteTile(TiledBackingStoreRemoteTileClient*, WebCore::TiledBackingStore*, const Coordinate&);
+    CoordinatedTile(CoordinatedTileClient*, WebCore::TiledBackingStore*, const Coordinate&);
 
-    TiledBackingStoreRemoteTileClient* m_client;
+    CoordinatedTileClient* m_client;
     WebCore::TiledBackingStore* m_tiledBackingStore;
     Coordinate m_coordinate;
     WebCore::IntRect m_rect;
@@ -73,24 +73,24 @@ private:
     OwnPtr<WebCore::ImageBuffer> m_localBuffer;
 };
 
-class TiledBackingStoreRemoteTileClient {
+class CoordinatedTileClient {
 public:
-    virtual ~TiledBackingStoreRemoteTileClient() { }
+    virtual ~CoordinatedTileClient() { }
     virtual void createTile(int tileID, const SurfaceUpdateInfo&, const WebCore::IntRect&) = 0;
     virtual void updateTile(int tileID, const SurfaceUpdateInfo&, const WebCore::IntRect&) = 0;
     virtual void removeTile(int tileID) = 0;
     virtual PassOwnPtr<WebCore::GraphicsContext> beginContentUpdate(const WebCore::IntSize&, ShareableSurface::Handle&, WebCore::IntPoint&) = 0;
 };
 
-class TiledBackingStoreRemoteTileBackend : public WebCore::TiledBackingStoreBackend {
+class CoordinatedTileBackend : public WebCore::TiledBackingStoreBackend {
 public:
-    static PassOwnPtr<WebCore::TiledBackingStoreBackend> create(TiledBackingStoreRemoteTileClient* client) { return adoptPtr(new TiledBackingStoreRemoteTileBackend(client)); }
+    static PassOwnPtr<WebCore::TiledBackingStoreBackend> create(CoordinatedTileClient* client) { return adoptPtr(new CoordinatedTileBackend(client)); }
     PassRefPtr<WebCore::Tile> createTile(WebCore::TiledBackingStore*, const WebCore::Tile::Coordinate&);
     void paintCheckerPattern(WebCore::GraphicsContext*, const WebCore::FloatRect&);
 
 private:
-    TiledBackingStoreRemoteTileBackend(TiledBackingStoreRemoteTileClient*);
-    TiledBackingStoreRemoteTileClient* m_client;
+    CoordinatedTileBackend(CoordinatedTileClient*);
+    CoordinatedTileClient* m_client;
 };
 
 
@@ -98,4 +98,4 @@ private:
 
 #endif // USE(TILED_BACKING_STORE)
 
-#endif // TiledBackingStoreRemoteTile
+#endif // CoordinatedTile
@@ -1,4 +1,4 @@
-/*
+    /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
  *
 
 #include "LayerTreeCoordinator.h"
 
+#include "CoordinatedGraphicsLayer.h"
 #include "DrawingAreaImpl.h"
 #include "GraphicsContext.h"
 #include "LayerTreeCoordinatorProxyMessages.h"
 #include "MessageID.h"
 #include "SurfaceUpdateInfo.h"
 #include "WebCoreArgumentCoders.h"
-#include "WebGraphicsLayer.h"
 #include "WebPage.h"
 #include <WebCore/Frame.h>
 #include <WebCore/FrameView.h>
@@ -56,13 +56,13 @@ PassRefPtr<LayerTreeCoordinator> LayerTreeCoordinator::create(WebPage* webPage)
 
 LayerTreeCoordinator::~LayerTreeCoordinator()
 {
-    // Prevent setWebGraphicsLayerClient(0) -> detachLayer() from modifying the set while we iterate it.
-    HashSet<WebCore::WebGraphicsLayer*> registeredLayers;
+    // Prevent setCoordinatedGraphicsLayerClient(0) -> detachLayer() from modifying the set while we iterate it.
+    HashSet<WebCore::CoordinatedGraphicsLayer*> registeredLayers;
     registeredLayers.swap(m_registeredLayers);
 
-    HashSet<WebCore::WebGraphicsLayer*>::iterator end = registeredLayers.end();
-    for (HashSet<WebCore::WebGraphicsLayer*>::iterator it = registeredLayers.begin(); it != end; ++it)
-        (*it)->setWebGraphicsLayerClient(0);
+    HashSet<WebCore::CoordinatedGraphicsLayer*>::iterator end = registeredLayers.end();
+    for (HashSet<WebCore::CoordinatedGraphicsLayer*>::iterator it = registeredLayers.begin(); it != end; ++it)
+        (*it)->setCoordinatedGraphicsLayerClient(0);
 }
 
 LayerTreeCoordinator::LayerTreeCoordinator(WebPage* webPage)
@@ -80,17 +80,17 @@ LayerTreeCoordinator::LayerTreeCoordinator(WebPage* webPage)
 {
     // Create a root layer.
     m_rootLayer = GraphicsLayer::create(this);
-    WebGraphicsLayer* webRootLayer = toWebGraphicsLayer(m_rootLayer.get());
+    CoordinatedGraphicsLayer* webRootLayer = toCoordinatedGraphicsLayer(m_rootLayer.get());
     webRootLayer->setRootLayer(true);
 #ifndef NDEBUG
     m_rootLayer->setName("LayerTreeCoordinator root layer");
 #endif
     m_rootLayer->setDrawsContent(false);
     m_rootLayer->setSize(m_webPage->size());
-    m_layerTreeContext.webLayerID = toWebGraphicsLayer(webRootLayer)->id();
+    m_layerTreeContext.webLayerID = toCoordinatedGraphicsLayer(webRootLayer)->id();
 
     m_nonCompositedContentLayer = GraphicsLayer::create(this);
-    toWebGraphicsLayer(m_rootLayer.get())->setWebGraphicsLayerClient(this);
+    toCoordinatedGraphicsLayer(m_rootLayer.get())->setCoordinatedGraphicsLayerClient(this);
 #ifndef NDEBUG
     m_nonCompositedContentLayer->setName("LayerTreeCoordinator non-composited content");
 #endif
@@ -247,7 +247,7 @@ bool LayerTreeCoordinator::flushPendingLayerChanges()
     m_rootLayer->syncCompositingStateForThisLayerOnly();
 
     if (m_shouldSyncRootLayer) {
-        m_webPage->send(Messages::LayerTreeCoordinatorProxy::SetRootCompositingLayer(toWebGraphicsLayer(m_rootLayer.get())->id()));
+        m_webPage->send(Messages::LayerTreeCoordinatorProxy::SetRootCompositingLayer(toCoordinatedGraphicsLayer(m_rootLayer.get())->id()));
         m_shouldSyncRootLayer = false;
     }
 
@@ -292,7 +292,7 @@ void LayerTreeCoordinator::syncLayerFilters(WebLayerID id, const FilterOperation
 }
 #endif
 
-void LayerTreeCoordinator::attachLayer(WebGraphicsLayer* layer)
+void LayerTreeCoordinator::attachLayer(CoordinatedGraphicsLayer* layer)
 {
     ASSERT(!m_registeredLayers.contains(layer));
     m_registeredLayers.add(layer);
@@ -301,7 +301,7 @@ void LayerTreeCoordinator::attachLayer(WebGraphicsLayer* layer)
     layer->adjustVisibleRect();
 }
 
-void LayerTreeCoordinator::detachLayer(WebGraphicsLayer* layer)
+void LayerTreeCoordinator::detachLayer(CoordinatedGraphicsLayer* layer)
 {
     m_registeredLayers.remove(layer);
     m_shouldSyncFrame = true;
@@ -328,7 +328,7 @@ static void updateOffsetFromViewportForSelf(RenderLayer* renderLayer)
     if (!renderLayer->isStackingContext())
         return;
 
-    WebGraphicsLayer* graphicsLayer = toWebGraphicsLayer(backing->graphicsLayer());
+    CoordinatedGraphicsLayer* graphicsLayer = toCoordinatedGraphicsLayer(backing->graphicsLayer());
     graphicsLayer->setFixedToViewport(true);
 }
 
@@ -536,14 +536,14 @@ void LayerTreeCoordinator::setVisibleContentsRect(const IntRect& rect, float sca
     bool contentsScaleDidChange = scale != m_contentsScale;
 
     // A zero trajectoryVector indicates that tiles all around the viewport are requested.
-    toWebGraphicsLayer(m_nonCompositedContentLayer.get())->setVisibleContentRectTrajectoryVector(trajectoryVector);
+    toCoordinatedGraphicsLayer(m_nonCompositedContentLayer.get())->setVisibleContentRectTrajectoryVector(trajectoryVector);
 
     if (contentsRectDidChange || contentsScaleDidChange) {
         m_visibleContentsRect = rect;
         m_contentsScale = scale;
 
-        HashSet<WebCore::WebGraphicsLayer*>::iterator end = m_registeredLayers.end();
-        for (HashSet<WebCore::WebGraphicsLayer*>::iterator it = m_registeredLayers.begin(); it != end; ++it) {
+        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)
@@ -558,7 +558,7 @@ void LayerTreeCoordinator::setVisibleContentsRect(const IntRect& rect, float sca
         m_shouldSendScrollPositionUpdate = true;
 }
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 void LayerTreeCoordinator::scheduleAnimation()
 {
     scheduleLayerFlush();
@@ -580,8 +580,8 @@ bool LayerTreeCoordinator::layerTreeTileUpdatesAllowed() const
 
 void LayerTreeCoordinator::purgeBackingStores()
 {
-    HashSet<WebCore::WebGraphicsLayer*>::iterator end = m_registeredLayers.end();
-    for (HashSet<WebCore::WebGraphicsLayer*>::iterator it = m_registeredLayers.begin(); it != end; ++it)
+    HashSet<WebCore::CoordinatedGraphicsLayer*>::iterator end = m_registeredLayers.end();
+    for (HashSet<WebCore::CoordinatedGraphicsLayer*>::iterator it = m_registeredLayers.begin(); it != end; ++it)
         (*it)->purgeBackingStores();
 
     ASSERT(!m_directlyCompositedImageRefCounts.size());
 #ifndef LayerTreeCoordinator_h
 #define LayerTreeCoordinator_h
 
+#include "CoordinatedGraphicsLayer.h"
 #include "LayerTreeContext.h"
 #include "LayerTreeHost.h"
 #include "Timer.h"
 #include "UpdateAtlas.h"
-#include "WebGraphicsLayer.h"
 #include <WebCore/GraphicsLayerClient.h>
 #include <wtf/OwnPtr.h>
 
@@ -34,7 +34,7 @@ class UpdateInfo;
 class WebPage;
 
 class LayerTreeCoordinator : public LayerTreeHost, WebCore::GraphicsLayerClient
-                           , public WebGraphicsLayerClient {
+                           , public CoordinatedGraphicsLayerClient {
 public:
     static PassRefPtr<LayerTreeCoordinator> create(WebPage*);
     virtual ~LayerTreeCoordinator();
@@ -81,12 +81,12 @@ public:
     virtual void syncLayerFilters(WebLayerID, const WebCore::FilterOperations&);
 #endif
     virtual void syncCanvas(WebLayerID, const WebCore::IntSize& canvasSize, uint32_t graphicsSurfaceToken) OVERRIDE;
-    virtual void attachLayer(WebCore::WebGraphicsLayer*);
-    virtual void detachLayer(WebCore::WebGraphicsLayer*);
+    virtual void attachLayer(WebCore::CoordinatedGraphicsLayer*);
+    virtual void detachLayer(WebCore::CoordinatedGraphicsLayer*);
     virtual void syncFixedLayers();
 
     virtual PassOwnPtr<WebCore::GraphicsContext> beginContentUpdate(const WebCore::IntSize&, ShareableBitmap::Flags, ShareableSurface::Handle&, WebCore::IntPoint&);
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
     virtual void scheduleAnimation() OVERRIDE;
 #endif
 
@@ -118,7 +118,7 @@ private:
     // The page overlay layer. Will be null if there's no page overlay.
     OwnPtr<WebCore::GraphicsLayer> m_pageOverlayLayer;
 
-    HashSet<WebCore::WebGraphicsLayer*> m_registeredLayers;
+    HashSet<WebCore::CoordinatedGraphicsLayer*> m_registeredLayers;
     HashMap<int64_t, int> m_directlyCompositedImageRefCounts;
     Vector<UpdateAtlas> m_updateAtlases;
 
@@ -18,7 +18,7 @@
 #
 
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 messages -> LayerTreeCoordinator {
     SetVisibleContentsRect(WebCore::IntRect visibleContentsRect, float scale, WebCore::FloatPoint trajectoryVectory)
     RenderNextFrame()
index 71aa607..759e675 100644 (file)
@@ -90,7 +90,7 @@ public:
     virtual void scheduleCompositingLayerSync() = 0;
 #endif
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
     virtual void didReceiveLayerTreeCoordinatorMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*) = 0;
 #endif
 
index 5e6d5ec..8ecd9e2 100644 (file)
@@ -688,7 +688,7 @@ void DrawingAreaImpl::display(UpdateInfo& updateInfo)
     m_displayTimer.stop();
 }
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 void DrawingAreaImpl::didReceiveLayerTreeCoordinatorMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
 {
     if (m_layerTreeHost)
index 2cebbd5..55e3df4 100644 (file)
@@ -77,7 +77,7 @@ private:
     virtual void setLayerHostingMode(uint32_t) OVERRIDE;
 #endif
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
     virtual void didReceiveLayerTreeCoordinatorMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
 #endif
 
index 1372f2a..9c2e744 100644 (file)
@@ -85,7 +85,7 @@ public:
     virtual void pauseRendering() { }
     virtual void resumeRendering() { }
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
     virtual void setVisibleContentsRect(const WebCore::IntRect&, float scale, const WebCore::FloatPoint&) { }
     virtual void setVisibleContentsRectForLayer(int layerID, const WebCore::IntRect&) { }
     virtual void renderNextFrame() { }
@@ -105,7 +105,7 @@ public:
     virtual WebCore::GraphicsDeviceAdapter* graphicsDeviceAdapter() const { return 0; }
 #endif
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
     virtual void scheduleAnimation() = 0;
 #endif
 
@@ -114,7 +114,7 @@ protected:
 
     WebPage* m_webPage;
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
     bool m_waitingForUIProcess;
 #endif
 };
index 0acd348..58869f3 100644 (file)
@@ -20,7 +20,7 @@
 #include "config.h"
 #include "UpdateAtlas.h"
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 
 #include "GraphicsContext.h"
 #include "IntRect.h"
index 74760a5..7d22237 100644 (file)
@@ -22,7 +22,7 @@
 
 #include "ShareableSurface.h"
 
-#if USE(UI_SIDE_COMPOSITING)
+#if USE(COORDINATED_GRAPHICS)
 namespace WebCore {
 class GraphicsContext;
 class IntRect;
index cb72cb9..28b200d 100644 (file)
@@ -38,7 +38,7 @@
 #include <wtf/MainThread.h>
 
 #if USE(ACCELERATED_COMPOSITING)
-#include "WebGraphicsLayer.h"
+#include "CoordinatedGraphicsLayer.h"
 #endif
 #if USE(QTKIT)
 #include "WebSystemInterface.h"
@@ -181,7 +181,7 @@ Q_DECL_EXPORT int WebProcessMainQt(QGuiApplication* app)
     }
 #endif
 #if USE(ACCELERATED_COMPOSITING)
-    WebGraphicsLayer::initFactory();
+    CoordinatedGraphicsLayer::initFactory();
 #endif
 
     WebKit::WebProcess::shared().initialize(identifier, RunLoop::main());