Rename Mac's TileCache to TileController, and WebTileCacheLayer to WebTiledBackingLayer
authorsimon.fraser@apple.com <simon.fraser@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 7 Mar 2013 23:54:13 +0000 (23:54 +0000)
committersimon.fraser@apple.com <simon.fraser@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 7 Mar 2013 23:54:13 +0000 (23:54 +0000)
https://bugs.webkit.org/show_bug.cgi?id=111779

Reviewed by Tim Horton.

"TileCache" was a name conflict in downstream code, so rename it to TileController.
The layer that has a TileController is now a WebTiledBackingLayer (which fits with
the TiledBacking API that TileController exposes).

Also renamed the flags in PlatformCALayer to match.

Rename only, no behavior change.

* WebCore.xcodeproj/project.pbxproj:
* page/scrolling/mac/ScrollingTreeScrollingNodeMac.mm:
(WebCore::ScrollingTreeScrollingNodeMac::logExposedUnfilledArea):
* platform/graphics/GraphicsLayerClient.h:
(WebCore::GraphicsLayerClient::shouldUseTiledBacking):
* platform/graphics/ca/GraphicsLayerCA.cpp:
(WebCore::GraphicsLayerCA::GraphicsLayerCA):
(WebCore::GraphicsLayerCA::recursiveCommitChanges):
(WebCore::GraphicsLayerCA::platformCALayerShowRepaintCounter):
(WebCore::GraphicsLayerCA::platformCALayerDidCreateTiles):
(WebCore::GraphicsLayerCA::updateVisibleRect):
(WebCore::GraphicsLayerCA::getDebugBorderInfo):
(WebCore::GraphicsLayerCA::requiresTiledLayer):
(WebCore::GraphicsLayerCA::swapFromOrToTiledLayer):
* platform/graphics/ca/GraphicsLayerCA.h:
* platform/graphics/ca/PlatformCALayer.h:
(WebCore::PlatformCALayer::usesTiledBackingLayer):
* platform/graphics/ca/mac/PlatformCALayerMac.mm:
(PlatformCALayer::PlatformCALayer):
(PlatformCALayer::~PlatformCALayer):
(PlatformCALayer::tiledBacking):
* platform/graphics/ca/mac/TileController.h: Renamed from Source/WebCore/platform/graphics/ca/mac/TileCache.h.
* platform/graphics/ca/mac/WebTileLayer.h:
(TileController):
* platform/graphics/ca/mac/WebTileLayer.mm:
(-[WebTileLayer drawInContext:]):
(-[WebTileLayer setTileController:WebCore::]):
(-[WebTileLayer logFilledFreshTile]):
* platform/graphics/ca/mac/WebTiledBackingLayer.h: Renamed from Source/WebCore/platform/graphics/ca/mac/WebTileCacheLayer.h.
* platform/graphics/ca/mac/WebTiledBackingLayer.mm: Renamed from Source/WebCore/platform/graphics/ca/mac/WebTileCacheLayer.mm.
* platform/graphics/mac/WebLayer.mm:
(drawLayerContents):
* rendering/RenderLayerBacking.cpp:
(WebCore::RenderLayerBacking::RenderLayerBacking):
(WebCore::RenderLayerBacking::shouldUseTiledBacking):
(WebCore::RenderLayerBacking::adjustTiledBackingCoverage):
(WebCore::RenderLayerBacking::createPrimaryGraphicsLayer):
* rendering/RenderLayerBacking.h:
(WebCore::RenderLayerBacking::usingTiledBacking):
(RenderLayerBacking):
(WebCore::RenderLayerBacking::hasTiledBackingFlatteningLayer):
* rendering/RenderLayerCompositor.cpp:
(WebCore::RenderLayerCompositor::frameViewDidLayout):
(WebCore::RenderLayerCompositor::rootFixedBackgroundsChanged):
(WebCore::RenderLayerCompositor::supportsFixedRootBackgroundCompositing):

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

18 files changed:
Source/WebCore/ChangeLog
Source/WebCore/WebCore.xcodeproj/project.pbxproj
Source/WebCore/page/scrolling/mac/ScrollingTreeScrollingNodeMac.mm
Source/WebCore/platform/graphics/GraphicsLayerClient.h
Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp
Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h
Source/WebCore/platform/graphics/ca/PlatformCALayer.h
Source/WebCore/platform/graphics/ca/mac/PlatformCALayerMac.mm
Source/WebCore/platform/graphics/ca/mac/TileController.h [moved from Source/WebCore/platform/graphics/ca/mac/TileCache.h with 92% similarity]
Source/WebCore/platform/graphics/ca/mac/TileController.mm [moved from Source/WebCore/platform/graphics/ca/mac/TileCache.mm with 87% similarity]
Source/WebCore/platform/graphics/ca/mac/WebTileLayer.h
Source/WebCore/platform/graphics/ca/mac/WebTileLayer.mm
Source/WebCore/platform/graphics/ca/mac/WebTiledBackingLayer.h [moved from Source/WebCore/platform/graphics/ca/mac/WebTileCacheLayer.h with 85% similarity]
Source/WebCore/platform/graphics/ca/mac/WebTiledBackingLayer.mm [moved from Source/WebCore/platform/graphics/ca/mac/WebTileCacheLayer.mm with 73% similarity]
Source/WebCore/platform/graphics/mac/WebLayer.mm
Source/WebCore/rendering/RenderLayerBacking.cpp
Source/WebCore/rendering/RenderLayerBacking.h
Source/WebCore/rendering/RenderLayerCompositor.cpp

index e73ca5b..d15ca14 100644 (file)
@@ -1,3 +1,64 @@
+2013-03-07  Simon Fraser  <simon.fraser@apple.com>
+
+        Rename Mac's TileCache to TileController, and WebTileCacheLayer to WebTiledBackingLayer
+        https://bugs.webkit.org/show_bug.cgi?id=111779
+
+        Reviewed by Tim Horton.
+        
+        "TileCache" was a name conflict in downstream code, so rename it to TileController.
+        The layer that has a TileController is now a WebTiledBackingLayer (which fits with
+        the TiledBacking API that TileController exposes).
+        
+        Also renamed the flags in PlatformCALayer to match.
+
+        Rename only, no behavior change.
+
+        * WebCore.xcodeproj/project.pbxproj:
+        * page/scrolling/mac/ScrollingTreeScrollingNodeMac.mm:
+        (WebCore::ScrollingTreeScrollingNodeMac::logExposedUnfilledArea):
+        * platform/graphics/GraphicsLayerClient.h:
+        (WebCore::GraphicsLayerClient::shouldUseTiledBacking):
+        * platform/graphics/ca/GraphicsLayerCA.cpp:
+        (WebCore::GraphicsLayerCA::GraphicsLayerCA):
+        (WebCore::GraphicsLayerCA::recursiveCommitChanges):
+        (WebCore::GraphicsLayerCA::platformCALayerShowRepaintCounter):
+        (WebCore::GraphicsLayerCA::platformCALayerDidCreateTiles):
+        (WebCore::GraphicsLayerCA::updateVisibleRect):
+        (WebCore::GraphicsLayerCA::getDebugBorderInfo):
+        (WebCore::GraphicsLayerCA::requiresTiledLayer):
+        (WebCore::GraphicsLayerCA::swapFromOrToTiledLayer):
+        * platform/graphics/ca/GraphicsLayerCA.h:
+        * platform/graphics/ca/PlatformCALayer.h:
+        (WebCore::PlatformCALayer::usesTiledBackingLayer):
+        * platform/graphics/ca/mac/PlatformCALayerMac.mm:
+        (PlatformCALayer::PlatformCALayer):
+        (PlatformCALayer::~PlatformCALayer):
+        (PlatformCALayer::tiledBacking):
+        * platform/graphics/ca/mac/TileController.h: Renamed from Source/WebCore/platform/graphics/ca/mac/TileCache.h.
+        * platform/graphics/ca/mac/WebTileLayer.h:
+        (TileController):
+        * platform/graphics/ca/mac/WebTileLayer.mm:
+        (-[WebTileLayer drawInContext:]):
+        (-[WebTileLayer setTileController:WebCore::]):
+        (-[WebTileLayer logFilledFreshTile]):
+        * platform/graphics/ca/mac/WebTiledBackingLayer.h: Renamed from Source/WebCore/platform/graphics/ca/mac/WebTileCacheLayer.h.
+        * platform/graphics/ca/mac/WebTiledBackingLayer.mm: Renamed from Source/WebCore/platform/graphics/ca/mac/WebTileCacheLayer.mm.
+        * platform/graphics/mac/WebLayer.mm:
+        (drawLayerContents):
+        * rendering/RenderLayerBacking.cpp:
+        (WebCore::RenderLayerBacking::RenderLayerBacking):
+        (WebCore::RenderLayerBacking::shouldUseTiledBacking):
+        (WebCore::RenderLayerBacking::adjustTiledBackingCoverage):
+        (WebCore::RenderLayerBacking::createPrimaryGraphicsLayer):
+        * rendering/RenderLayerBacking.h:
+        (WebCore::RenderLayerBacking::usingTiledBacking):
+        (RenderLayerBacking):
+        (WebCore::RenderLayerBacking::hasTiledBackingFlatteningLayer):
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::RenderLayerCompositor::frameViewDidLayout):
+        (WebCore::RenderLayerCompositor::rootFixedBackgroundsChanged):
+        (WebCore::RenderLayerCompositor::supportsFixedRootBackgroundCompositing):
+
 2013-03-07  Alexey Proskuryakov  <ap@apple.com>
 
         FormData should allow setting filename to empty
index 7c993c2..9679f62 100644 (file)
                0F580CFE0F12DE9B0051D689 /* RenderLayerCompositor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F580CFA0F12DE9B0051D689 /* RenderLayerCompositor.cpp */; };
                0F580CFF0F12DE9B0051D689 /* RenderLayerBacking.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F580CFB0F12DE9B0051D689 /* RenderLayerBacking.h */; settings = {ATTRIBUTES = (Private, ); }; };
                0F580D000F12DE9B0051D689 /* RenderLayerBacking.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F580CFC0F12DE9B0051D689 /* RenderLayerBacking.cpp */; };
-               0F580FA31496939100FB5BD8 /* WebTileCacheLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F580FA11496939100FB5BD8 /* WebTileCacheLayer.h */; };
-               0F580FA41496939100FB5BD8 /* WebTileCacheLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 0F580FA21496939100FB5BD8 /* WebTileCacheLayer.mm */; };
+               0F580FA31496939100FB5BD8 /* WebTiledBackingLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F580FA11496939100FB5BD8 /* WebTiledBackingLayer.h */; };
+               0F580FA41496939100FB5BD8 /* WebTiledBackingLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 0F580FA21496939100FB5BD8 /* WebTiledBackingLayer.mm */; };
                0F580FAF149800D400FB5BD8 /* AnimationUtilities.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F580FAE149800D400FB5BD8 /* AnimationUtilities.h */; settings = {ATTRIBUTES = (Private, ); }; };
                0F5B7A5410F65D7A00376302 /* RenderEmbeddedObject.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F5B7A5210F65D7A00376302 /* RenderEmbeddedObject.cpp */; };
                0F5B7A5510F65D7A00376302 /* RenderEmbeddedObject.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F5B7A5310F65D7A00376302 /* RenderEmbeddedObject.h */; settings = {ATTRIBUTES = (Private, ); }; };
                1A927FD41416A15B003A83C8 /* nptypes.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A927FD11416A15B003A83C8 /* nptypes.h */; settings = {ATTRIBUTES = (Private, ); }; };
                1A98956B0AA78F80005EF5EF /* KURLCFNet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1A98956A0AA78F80005EF5EF /* KURLCFNet.cpp */; };
                1AA21250163F0DA80000E63F /* AtomicStringCF.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1AA2124F163F0DA80000E63F /* AtomicStringCF.cpp */; };
-               1AA7160A149BC4DB0016EC19 /* TileCache.mm in Sources */ = {isa = PBXBuildFile; fileRef = 1AA71608149BC4DA0016EC19 /* TileCache.mm */; };
-               1AA7160B149BC4DB0016EC19 /* TileCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 1AA71609149BC4DB0016EC19 /* TileCache.h */; };
+               1AA7160A149BC4DB0016EC19 /* TileController.mm in Sources */ = {isa = PBXBuildFile; fileRef = 1AA71608149BC4DA0016EC19 /* TileController.mm */; };
+               1AA7160B149BC4DB0016EC19 /* TileController.h in Headers */ = {isa = PBXBuildFile; fileRef = 1AA71609149BC4DB0016EC19 /* TileController.h */; };
                1AA7161E149BF2FA0016EC19 /* WebTileLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = 1AA7161C149BF2FA0016EC19 /* WebTileLayer.mm */; };
                1AA84F04143BA7BD0051D153 /* ScrollElasticityController.mm in Sources */ = {isa = PBXBuildFile; fileRef = 1AA84F02143BA7BD0051D153 /* ScrollElasticityController.mm */; };
                1AA84F05143BA7BD0051D153 /* ScrollElasticityController.h in Headers */ = {isa = PBXBuildFile; fileRef = 1AA84F03143BA7BD0051D153 /* ScrollElasticityController.h */; };
                0F580CFA0F12DE9B0051D689 /* RenderLayerCompositor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderLayerCompositor.cpp; sourceTree = "<group>"; };
                0F580CFB0F12DE9B0051D689 /* RenderLayerBacking.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderLayerBacking.h; sourceTree = "<group>"; };
                0F580CFC0F12DE9B0051D689 /* RenderLayerBacking.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderLayerBacking.cpp; sourceTree = "<group>"; };
-               0F580FA11496939100FB5BD8 /* WebTileCacheLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = WebTileCacheLayer.h; path = ca/mac/WebTileCacheLayer.h; sourceTree = "<group>"; };
-               0F580FA21496939100FB5BD8 /* WebTileCacheLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = WebTileCacheLayer.mm; path = ca/mac/WebTileCacheLayer.mm; sourceTree = "<group>"; };
+               0F580FA11496939100FB5BD8 /* WebTiledBackingLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = WebTiledBackingLayer.h; path = ca/mac/WebTiledBackingLayer.h; sourceTree = "<group>"; };
+               0F580FA21496939100FB5BD8 /* WebTiledBackingLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = WebTiledBackingLayer.mm; path = ca/mac/WebTiledBackingLayer.mm; sourceTree = "<group>"; };
                0F580FAE149800D400FB5BD8 /* AnimationUtilities.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = AnimationUtilities.h; path = animation/AnimationUtilities.h; sourceTree = "<group>"; };
                0F5B7A5210F65D7A00376302 /* RenderEmbeddedObject.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderEmbeddedObject.cpp; sourceTree = "<group>"; };
                0F5B7A5310F65D7A00376302 /* RenderEmbeddedObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderEmbeddedObject.h; sourceTree = "<group>"; };
                1A927FD11416A15B003A83C8 /* nptypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = nptypes.h; sourceTree = "<group>"; };
                1A98956A0AA78F80005EF5EF /* KURLCFNet.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = KURLCFNet.cpp; sourceTree = "<group>"; };
                1AA2124F163F0DA80000E63F /* AtomicStringCF.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AtomicStringCF.cpp; sourceTree = "<group>"; };
-               1AA71608149BC4DA0016EC19 /* TileCache.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = TileCache.mm; path = ca/mac/TileCache.mm; sourceTree = "<group>"; };
-               1AA71609149BC4DB0016EC19 /* TileCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = TileCache.h; path = ca/mac/TileCache.h; sourceTree = "<group>"; };
+               1AA71608149BC4DA0016EC19 /* TileController.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = TileController.mm; path = ca/mac/TileController.mm; sourceTree = "<group>"; };
+               1AA71609149BC4DB0016EC19 /* TileController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = TileController.h; path = ca/mac/TileController.h; sourceTree = "<group>"; };
                1AA7161C149BF2FA0016EC19 /* WebTileLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = WebTileLayer.mm; path = ca/mac/WebTileLayer.mm; sourceTree = "<group>"; };
                1AA71625149BFFB20016EC19 /* WebTileLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = WebTileLayer.h; path = ca/mac/WebTileLayer.h; sourceTree = "<group>"; };
                1AA84F02143BA7BD0051D153 /* ScrollElasticityController.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ScrollElasticityController.mm; sourceTree = "<group>"; };
                7E99AF520B13846468FB01A5 /* WindowFocusAllowedIndicator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WindowFocusAllowedIndicator.cpp; sourceTree = "<group>"; };
                7E99AF540B13846468FB01A5 /* WindowFocusAllowedIndicator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WindowFocusAllowedIndicator.h; sourceTree = "<group>"; };
                7EA30F6216DFD62700257D0B /* WebGLCompressedTextureATC.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = WebGLCompressedTextureATC.idl; path = canvas/WebGLCompressedTextureATC.idl; sourceTree = "<group>"; };
-               7EA30F6716DFFE7500257D0B /* JSWebGLCompressedTextureATC.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = JSWebGLCompressedTextureATC.cpp; path = JSWebGLCompressedTextureATC.cpp; sourceTree = "<group>"; };
-               7EA30F6816DFFE7500257D0B /* JSWebGLCompressedTextureATC.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = JSWebGLCompressedTextureATC.h; path = JSWebGLCompressedTextureATC.h; sourceTree = "<group>"; };
+               7EA30F6716DFFE7500257D0B /* JSWebGLCompressedTextureATC.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSWebGLCompressedTextureATC.cpp; sourceTree = "<group>"; };
+               7EA30F6816DFFE7500257D0B /* JSWebGLCompressedTextureATC.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSWebGLCompressedTextureATC.h; sourceTree = "<group>"; };
                7EE6844C12D26E3800E79415 /* AuthenticationCF.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AuthenticationCF.cpp; sourceTree = "<group>"; };
                7EE6844D12D26E3800E79415 /* AuthenticationCF.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AuthenticationCF.h; sourceTree = "<group>"; };
                7EE6844E12D26E3800E79415 /* AuthenticationChallenge.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AuthenticationChallenge.h; sourceTree = "<group>"; };
                                93F72AF21666EDFC002A02BD /* LayerPool.mm */,
                                4958781F12A57DDF007238AC /* PlatformCAAnimationMac.mm */,
                                4958782012A57DDF007238AC /* PlatformCALayerMac.mm */,
-                               1AA71609149BC4DB0016EC19 /* TileCache.h */,
-                               1AA71608149BC4DA0016EC19 /* TileCache.mm */,
-                               0F580FA11496939100FB5BD8 /* WebTileCacheLayer.h */,
-                               0F580FA21496939100FB5BD8 /* WebTileCacheLayer.mm */,
+                               1AA71609149BC4DB0016EC19 /* TileController.h */,
+                               1AA71608149BC4DA0016EC19 /* TileController.mm */,
+                               0F580FA11496939100FB5BD8 /* WebTiledBackingLayer.h */,
+                               0F580FA21496939100FB5BD8 /* WebTiledBackingLayer.mm */,
                                1AA71625149BFFB20016EC19 /* WebTileLayer.h */,
                                1AA7161C149BF2FA0016EC19 /* WebTileLayer.mm */,
                        );
                                51DF6D7E0B92A16D00C2DC85 /* ThreadCheck.h in Headers */,
                                E1FF57A30F01255B00891EBB /* ThreadGlobalData.h in Headers */,
                                185BCF290F3279CE000EA262 /* ThreadTimers.h in Headers */,
-                               1AA7160B149BC4DB0016EC19 /* TileCache.h in Headers */,
+                               1AA7160B149BC4DB0016EC19 /* TileController.h in Headers */,
                                1AF89A421518FDEA00E547B5 /* TiledBacking.h in Headers */,
                                498770F31242C535002226BA /* TilingData.h in Headers */,
                                F55B3DDC1251F12D003EF269 /* TimeInputType.h in Headers */,
                                97AABD2714FA09D5007457AE /* WebSocketHandshake.h in Headers */,
                                97AABD2914FA09D5007457AE /* WebSocketHandshakeRequest.h in Headers */,
                                97AABD2B14FA09D5007457AE /* WebSocketHandshakeResponse.h in Headers */,
-                               0F580FA31496939100FB5BD8 /* WebTileCacheLayer.h in Headers */,
+                               0F580FA31496939100FB5BD8 /* WebTiledBackingLayer.h in Headers */,
                                0FCF332D0F2B9A25004B6795 /* WebTiledLayer.h in Headers */,
                                CD82030A1395AB6A00F956C6 /* WebVideoFullscreenController.h in Headers */,
                                CD82030C1395AB6A00F956C6 /* WebVideoFullscreenHUDWindowController.h in Headers */,
                                E187056316E54A0D00585E97 /* MainThreadTask.h in Headers */,
                                7E66E23416D6EB6C00F7E7FF /* WebGLCompressedTextureATC.h in Headers */,
                                7EA30F6A16DFFE7500257D0B /* JSWebGLCompressedTextureATC.h in Headers */,
-                               2D8287F716E4A0380086BD00 /* HitTestLocation.h in Headers */,
+                               2D8287F716E4A0380086BD00 /* HitTestLocation.h in Headers */,
                        );
                        runOnlyForDeploymentPostprocessing = 0;
                };
                                51DF6D800B92A18E00C2DC85 /* ThreadCheck.mm in Sources */,
                                E1FF57A60F01256B00891EBB /* ThreadGlobalData.cpp in Sources */,
                                185BCF280F3279CE000EA262 /* ThreadTimers.cpp in Sources */,
-                               1AA7160A149BC4DB0016EC19 /* TileCache.mm in Sources */,
+                               1AA7160A149BC4DB0016EC19 /* TileController.mm in Sources */,
                                498770F21242C535002226BA /* TilingData.cpp in Sources */,
                                F55B3DDB1251F12D003EF269 /* TimeInputType.cpp in Sources */,
                                7553CFE9108F473F00EA281E /* TimelineRecordFactory.cpp in Sources */,
                                97AABD2614FA09D5007457AE /* WebSocketHandshake.cpp in Sources */,
                                97AABD2814FA09D5007457AE /* WebSocketHandshakeRequest.cpp in Sources */,
                                97AABD2A14FA09D5007457AE /* WebSocketHandshakeResponse.cpp in Sources */,
-                               0F580FA41496939100FB5BD8 /* WebTileCacheLayer.mm in Sources */,
+                               0F580FA41496939100FB5BD8 /* WebTiledBackingLayer.mm in Sources */,
                                0FCF332C0F2B9A25004B6795 /* WebTiledLayer.mm in Sources */,
                                1AA7161E149BF2FA0016EC19 /* WebTileLayer.mm in Sources */,
                                CD82030B1395AB6A00F956C6 /* WebVideoFullscreenController.mm in Sources */,
                                A31C4E5216E02B08002F7957 /* JSOESTextureHalfFloat.cpp in Sources */,
                                7E66E23316D6EB6C00F7E7FF /* WebGLCompressedTextureATC.cpp in Sources */,
                                7EA30F6916DFFE7500257D0B /* JSWebGLCompressedTextureATC.cpp in Sources */,
-                               2D8287F616E4A0380086BD00 /* HitTestLocation.cpp in Sources */,
+                               2D8287F616E4A0380086BD00 /* HitTestLocation.cpp in Sources */,
                        );
                        runOnlyForDeploymentPostprocessing = 0;
                };
index e17abc6..411a07e 100644 (file)
@@ -34,7 +34,7 @@
 #include "ScrollingTree.h"
 #include "ScrollingStateTree.h"
 #include "Settings.h"
-#include "TileCache.h"
+#include "TileController.h"
 #include "WebTileLayer.h"
 
 #include <wtf/CurrentTime.h>
@@ -382,7 +382,7 @@ void ScrollingTreeScrollingNodeMac::logExposedUnfilledArea()
     }
 
     IntPoint scrollPosition = this->scrollPosition();
-    unsigned unfilledArea = TileCache::blankPixelCountForTiles(tiles, viewportRect(), IntPoint(-scrollPosition.x(), -scrollPosition.y()));
+    unsigned unfilledArea = TileController::blankPixelCountForTiles(tiles, viewportRect(), IntPoint(-scrollPosition.x(), -scrollPosition.y()));
 
     if (unfilledArea || m_lastScrollHadUnfilledPixels)
         WTFLogAlways("SCROLLING: Exposed tileless area. Time: %f Unfilled Pixels: %u\n", WTF::monotonicallyIncreasingTime(), unfilledArea);
index 1e9d296..96f65a4 100644 (file)
@@ -59,7 +59,7 @@ class GraphicsLayerClient {
 public:
     virtual ~GraphicsLayerClient() {}
 
-    virtual bool shouldUseTileCache(const GraphicsLayer*) const { return false; }
+    virtual bool shouldUseTiledBacking(const GraphicsLayer*) const { return false; }
     
     // Callback for when hardware-accelerated animation started.
     virtual void notifyAnimationStarted(const GraphicsLayer*, double time) = 0;
index 8d97498..37451b1 100644 (file)
@@ -275,13 +275,13 @@ GraphicsLayerCA::GraphicsLayerCA(GraphicsLayerClient* client)
     : GraphicsLayer(client)
     , m_contentsLayerPurpose(NoContentsLayer)
     , m_allowTiledLayer(true)
-    , m_isPageTileCacheLayer(false)
+    , m_isPageTiledBackingLayer(false)
     , m_uncommittedChanges(0)
 {
     PlatformCALayer::LayerType layerType = PlatformCALayer::LayerTypeWebLayer;
-    if (client && client->shouldUseTileCache(this)) {
-        layerType = PlatformCALayer::LayerTypePageTileCacheLayer;
-        m_isPageTileCacheLayer = true;
+    if (client && client->shouldUseTiledBacking(this)) {
+        layerType = PlatformCALayer::LayerTypePageTiledBackingLayer;
+        m_isPageTiledBackingLayer = true;
     }
 
     m_layer = PlatformCALayer::create(layerType, this);
@@ -1035,7 +1035,7 @@ void GraphicsLayerCA::recursiveCommitChanges(const CommitState& commitState, con
 
     commitLayerChangesAfterSublayers();
 
-    if (affectedByTransformAnimation && client() && m_layer->layerType() == PlatformCALayer::LayerTypeTileCacheLayer)
+    if (affectedByTransformAnimation && client() && m_layer->layerType() == PlatformCALayer::LayerTypeTiledBackingLayer)
         client()->notifyFlushBeforeDisplayRefresh(this);
 
     if (hadChanges && client())
@@ -1044,9 +1044,9 @@ void GraphicsLayerCA::recursiveCommitChanges(const CommitState& commitState, con
 
 bool GraphicsLayerCA::platformCALayerShowRepaintCounter(PlatformCALayer* platformLayer) const
 {
-    // The repaint counters are painted into the TileCache tiles (which have no corresponding platform layer),
-    // so we don't want to overpaint the repaint counter when called with the TileCache's own layer.
-    if (m_isPageTileCacheLayer && platformLayer)
+    // The repaint counters are painted into the TileController tiles (which have no corresponding platform layer),
+    // so we don't want to overpaint the repaint counter when called with the TileController's own layer.
+    if (m_isPageTiledBackingLayer && platformLayer)
         return false;
     
     return isShowingRepaintCounter();
@@ -1059,7 +1059,7 @@ void GraphicsLayerCA::platformCALayerPaintContents(GraphicsContext& context, con
 
 void GraphicsLayerCA::platformCALayerDidCreateTiles(const Vector<FloatRect>& dirtyRects)
 {
-    ASSERT(m_layer->usesTileCacheLayer());
+    ASSERT(m_layer->usesTiledBackingLayer());
 
     for (size_t i = 0; i < dirtyRects.size(); ++i)
         setNeedsDisplayInRect(dirtyRects[i]);
@@ -1614,11 +1614,11 @@ FloatRect GraphicsLayerCA::adjustTiledLayerVisibleRect(TiledBacking* tiledBackin
 
 void GraphicsLayerCA::updateVisibleRect(const FloatRect& oldVisibleRect)
 {
-    if (!m_layer->usesTileCacheLayer())
+    if (!m_layer->usesTiledBackingLayer())
         return;
 
     FloatRect tileArea = m_visibleRect;
-    if (m_layer->layerType() == PlatformCALayer::LayerTypeTileCacheLayer)
+    if (m_layer->layerType() == PlatformCALayer::LayerTypeTiledBackingLayer)
         tileArea = adjustTiledLayerVisibleRect(tiledBacking(), oldVisibleRect, m_sizeAtLastVisibleRectUpdate);
 
     tiledBacking()->setVisibleRect(tileArea);
@@ -2560,7 +2560,7 @@ void GraphicsLayerCA::setDebugBackgroundColor(const Color& color)
 
 void GraphicsLayerCA::getDebugBorderInfo(Color& color, float& width) const
 {
-    if (m_isPageTileCacheLayer) {
+    if (m_isPageTiledBackingLayer) {
         color = Color(0, 0, 128, 128); // tile cache layer: dark blue
         width = 0.5;
         return;
@@ -2633,7 +2633,7 @@ FloatSize GraphicsLayerCA::constrainedSize() const
 
 bool GraphicsLayerCA::requiresTiledLayer(float pageScaleFactor) const
 {
-    if (!m_drawsContent || !m_allowTiledLayer || m_isPageTileCacheLayer)
+    if (!m_drawsContent || !m_allowTiledLayer || m_isPageTiledBackingLayer)
         return false;
 
     // FIXME: catch zero-size height or width here (or earlier)?
@@ -2642,11 +2642,11 @@ bool GraphicsLayerCA::requiresTiledLayer(float pageScaleFactor) const
 
 void GraphicsLayerCA::swapFromOrToTiledLayer(bool useTiledLayer)
 {
-    ASSERT(m_layer->layerType() != PlatformCALayer::LayerTypePageTileCacheLayer);
+    ASSERT(m_layer->layerType() != PlatformCALayer::LayerTypePageTiledBackingLayer);
     ASSERT(useTiledLayer != m_usingTiledLayer);
     RefPtr<PlatformCALayer> oldLayer = m_layer;
     
-    m_layer = PlatformCALayer::create(useTiledLayer ? PlatformCALayer::LayerTypeTileCacheLayer : PlatformCALayer::LayerTypeWebLayer, this);
+    m_layer = PlatformCALayer::create(useTiledLayer ? PlatformCALayer::LayerTypeTiledBackingLayer : PlatformCALayer::LayerTypeWebLayer, this);
     m_usingTiledLayer = useTiledLayer;
     
     m_layer->adoptSublayers(oldLayer.get());
index 16986d1..be26ba7 100644 (file)
@@ -425,7 +425,7 @@ private:
     
     ContentsLayerPurpose m_contentsLayerPurpose;
     bool m_allowTiledLayer : 1;
-    bool m_isPageTileCacheLayer : 1;
+    bool m_isPageTiledBackingLayer : 1;
     
     Color m_contentsSolidColor;
 
index f637051..adaff5b 100644 (file)
@@ -59,8 +59,8 @@ public:
         LayerTypeWebLayer,
         LayerTypeTransformLayer,
         LayerTypeWebTiledLayer,
-        LayerTypeTileCacheLayer,
-        LayerTypePageTileCacheLayer,
+        LayerTypeTiledBackingLayer,
+        LayerTypePageTiledBackingLayer,
         LayerTypeRootLayer,
         LayerTypeCustom
     };
@@ -81,9 +81,9 @@ public:
     PlatformLayer* platformLayer() const;
 
 #if PLATFORM(WIN)
-    bool usesTileCacheLayer() const { return false; }
+    bool usesTiledBackingLayer() const { return false; }
 #else
-    bool usesTileCacheLayer() const { return m_layerType == LayerTypePageTileCacheLayer || m_layerType == LayerTypeTileCacheLayer; }
+    bool usesTiledBackingLayer() const { return m_layerType == LayerTypePageTiledBackingLayer || m_layerType == LayerTypeTiledBackingLayer; }
 #endif
 
     PlatformCALayer* rootLayer() const;
index 2d2ad18..a1af3a0 100644 (file)
@@ -38,7 +38,7 @@
 #import "TiledBacking.h"
 #import "WebLayer.h"
 #import "WebTiledLayer.h"
-#import "WebTileCacheLayer.h"
+#import "WebTiledBackingLayer.h"
 #import <objc/objc-auto.h>
 #import <objc/runtime.h>
 #import <QuartzCore/QuartzCore.h>
@@ -224,9 +224,9 @@ PlatformCALayer::PlatformCALayer(LayerType layerType, PlatformLayer* layer, Plat
             case LayerTypeWebTiledLayer:
                 layerClass = [WebTiledLayer class];
                 break;
-            case LayerTypeTileCacheLayer:
-            case LayerTypePageTileCacheLayer:
-                layerClass = [WebTileCacheLayer class];
+            case LayerTypeTiledBackingLayer:
+            case LayerTypePageTiledBackingLayer:
+                layerClass = [WebTiledBackingLayer class];
                 break;
             case LayerTypeCustom:
                 break;
@@ -251,9 +251,9 @@ PlatformCALayer::PlatformCALayer(LayerType layerType, PlatformLayer* layer, Plat
         [tiledLayer setContentsGravity:@"bottomLeft"];
     }
     
-    if (usesTileCacheLayer()) {
+    if (usesTiledBackingLayer()) {
         m_customSublayers = adoptPtr(new PlatformCALayerList(1));
-        CALayer* tileCacheTileContainerLayer = [static_cast<WebTileCacheLayer *>(m_layer.get()) tileContainerLayer];
+        CALayer* tileCacheTileContainerLayer = [static_cast<WebTiledBackingLayer *>(m_layer.get()) tileContainerLayer];
         (*m_customSublayers)[0] = PlatformCALayer::create(tileCacheTileContainerLayer, 0);
     }
     
@@ -271,8 +271,8 @@ PlatformCALayer::~PlatformCALayer()
     // Remove the owner pointer from the delegate in case there is a pending animationStarted event.
     [static_cast<WebAnimationDelegate*>(m_delegate.get()) setOwner:nil];
 
-    if (usesTileCacheLayer())
-        [static_cast<WebTileCacheLayer *>(m_layer.get()) invalidate];
+    if (usesTiledBackingLayer())
+        [static_cast<WebTiledBackingLayer *>(m_layer.get()) invalidate];
 }
 
 PlatformCALayer* PlatformCALayer::platformCALayer(void* platformLayer)
@@ -1096,11 +1096,11 @@ void PlatformCALayer::setContentsScale(float value)
 
 TiledBacking* PlatformCALayer::tiledBacking()
 {
-    if (!usesTileCacheLayer())
+    if (!usesTiledBackingLayer())
         return 0;
 
-    WebTileCacheLayer *tileCacheLayer = static_cast<WebTileCacheLayer *>(m_layer.get());
-    return [tileCacheLayer tiledBacking];
+    WebTiledBackingLayer *tiledBackingLayer = static_cast<WebTiledBackingLayer *>(m_layer.get());
+    return [tiledBackingLayer tiledBacking];
 }
 
 #if PLATFORM(IOS) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070
@@ -23,8 +23,8 @@
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef TileCache_h
-#define TileCache_h
+#ifndef TileController_h
+#define TileController_h
 
 #include "FloatRect.h"
 #include "IntPointHash.h"
@@ -38,7 +38,7 @@
 #include <wtf/RetainPtr.h>
 
 OBJC_CLASS CALayer;
-OBJC_CLASS WebTileCacheLayer;
+OBJC_CLASS WebTiledBackingLayer;
 OBJC_CLASS WebTileLayer;
 OBJC_CLASS WebTiledScrollingIndicatorLayer;
 
@@ -50,12 +50,12 @@ class IntRect;
 
 typedef Vector<RetainPtr<WebTileLayer> > WebTileLayerList;
 
-class TileCache : public TiledBacking {
-    WTF_MAKE_NONCOPYABLE(TileCache);
+class TileController : public TiledBacking {
+    WTF_MAKE_NONCOPYABLE(TileController);
 
 public:
-    static PassOwnPtr<TileCache> create(WebTileCacheLayer*);
-    ~TileCache();
+    static PassOwnPtr<TileController> create(WebTiledBackingLayer*);
+    ~TileController();
 
     void tileCacheLayerBoundsChanged();
 
@@ -103,7 +103,7 @@ public:
     };
 
 private:
-    TileCache(WebTileCacheLayer*);
+    TileController(WebTiledBackingLayer*);
 
     // TiledBacking member functions.
     virtual void setVisibleRect(const FloatRect&) OVERRIDE;
@@ -135,10 +135,10 @@ private:
     IntSize tileSizeForCoverageRect(const FloatRect&) const;
 
     void scheduleTileRevalidation(double interval);
-    void tileRevalidationTimerFired(Timer<TileCache>*);
+    void tileRevalidationTimerFired(Timer<TileController>*);
 
     void scheduleCohortRemoval();
-    void cohortRemovalTimerFired(Timer<TileCache>*);
+    void cohortRemovalTimerFired(Timer<TileController>*);
     
     typedef unsigned TileValidationPolicyFlags;
 
@@ -164,7 +164,7 @@ private:
     bool shouldShowRepaintCounters() const;
     void drawRepaintCounter(WebTileLayer *, CGContextRef);
 
-    WebTileCacheLayer* m_tileCacheLayer;
+    WebTiledBackingLayer* m_tileCacheLayer;
     RetainPtr<CALayer> m_tileContainerLayer;
     RetainPtr<WebTiledScrollingIndicatorLayer> m_tiledScrollingIndicatorLayer; // Used for coverage visualization.
 
@@ -175,8 +175,8 @@ private:
 
     typedef HashMap<TileIndex, TileInfo> TileMap;
     TileMap m_tiles;
-    Timer<TileCache> m_tileRevalidationTimer;
-    Timer<TileCache> m_cohortRemovalTimer;
+    Timer<TileController> m_tileRevalidationTimer;
+    Timer<TileController> m_cohortRemovalTimer;
 
     struct TileCohortInfo {
         TileCohort cohort;
@@ -210,4 +210,4 @@ private:
 
 } // namespace WebCore
 
-#endif // TileCache_h
+#endif // TileController_h
  */
 
 #import "config.h"
-#import "TileCache.h"
+#import "TileController.h"
 
 #import "IntRect.h"
 #import "PlatformCALayer.h"
 #import "Region.h"
 #import "LayerPool.h"
 #import "WebLayer.h"
-#import "WebTileCacheLayer.h"
+#import "WebTiledBackingLayer.h"
 #import "WebTileLayer.h"
 #import <QuartzCore/QuartzCore.h>
 #import <wtf/MainThread.h>
@@ -47,15 +47,15 @@ using namespace std;
 #endif
 
 @interface WebTiledScrollingIndicatorLayer : CALayer {
-    WebCore::TileCache* _tileCache;
+    WebCore::TileController* _tileController;
     CALayer *_visibleRectFrameLayer; // Owned by being a sublayer.
 }
-@property (assign) WebCore::TileCache* tileCache;
+@property (assign) WebCore::TileController* tileController;
 @property (assign) CALayer* visibleRectFrameLayer;
 @end
 
 @implementation WebTiledScrollingIndicatorLayer
-@synthesize tileCache = _tileCache;
+@synthesize tileController = _tileController;
 @synthesize visibleRectFrameLayer = _visibleRectFrameLayer;
 - (id)init
 {
@@ -74,8 +74,8 @@ using namespace std;
 
 - (void)drawInContext:(CGContextRef)context
 {
-    if (_tileCache)
-        _tileCache->drawTileMapContents(context, [self bounds]);
+    if (_tileController)
+        _tileController->drawTileMapContents(context, [self bounds]);
 }
 @end
 
@@ -86,20 +86,20 @@ enum TileValidationPolicyFlag {
     UnparentAllTiles = 1 << 1
 };
 
-static const int defaultTileCacheWidth = 512;
-static const int defaultTileCacheHeight = 512;
+static const int defaultTileWidth = 512;
+static const int defaultTileHeight = 512;
 
-PassOwnPtr<TileCache> TileCache::create(WebTileCacheLayer* tileCacheLayer)
+PassOwnPtr<TileController> TileController::create(WebTiledBackingLayer* tileCacheLayer)
 {
-    return adoptPtr(new TileCache(tileCacheLayer));
+    return adoptPtr(new TileController(tileCacheLayer));
 }
 
-TileCache::TileCache(WebTileCacheLayer* tileCacheLayer)
+TileController::TileController(WebTiledBackingLayer* tileCacheLayer)
     : m_tileCacheLayer(tileCacheLayer)
     , m_tileContainerLayer(adoptCF([[CALayer alloc] init]))
-    , m_tileSize(defaultTileCacheWidth, defaultTileCacheHeight)
-    , m_tileRevalidationTimer(this, &TileCache::tileRevalidationTimerFired)
-    , m_cohortRemovalTimer(this, &TileCache::cohortRemovalTimerFired)
+    , m_tileSize(defaultTileWidth, defaultTileHeight)
+    , m_tileRevalidationTimer(this, &TileController::tileRevalidationTimerFired)
+    , m_cohortRemovalTimer(this, &TileController::cohortRemovalTimerFired)
     , m_scale(1)
     , m_deviceScaleFactor(1)
     , m_tileCoverage(CoverageForVisibleArea)
@@ -117,25 +117,25 @@ TileCache::TileCache(WebTileCacheLayer* tileCacheLayer)
     [CATransaction setDisableActions:YES];
     [m_tileCacheLayer addSublayer:m_tileContainerLayer.get()];
 #ifndef NDEBUG
-    [m_tileContainerLayer.get() setName:@"TileCache Container Layer"];
+    [m_tileContainerLayer.get() setName:@"TileController Container Layer"];
 #endif
     [CATransaction commit];
 }
 
-TileCache::~TileCache()
+TileController::~TileController()
 {
     ASSERT(isMainThread());
 
     for (TileMap::iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it) {
         const TileInfo& tileInfo = it->value;
-        [tileInfo.layer.get() setTileCache:0];
+        [tileInfo.layer.get() setTileController:0];
     }
     
     if (m_tiledScrollingIndicatorLayer)
-        [m_tiledScrollingIndicatorLayer.get() setTileCache:nil];
+        [m_tiledScrollingIndicatorLayer.get() setTileController:nil];
 }
 
-void TileCache::tileCacheLayerBoundsChanged()
+void TileController::tileCacheLayerBoundsChanged()
 {
     if (m_tiles.isEmpty()) {
         // We must revalidate immediately instead of using a timer when there are
@@ -147,7 +147,7 @@ void TileCache::tileCacheLayerBoundsChanged()
     scheduleTileRevalidation(0);
 }
 
-void TileCache::setNeedsDisplay()
+void TileController::setNeedsDisplay()
 {
     for (TileMap::const_iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it) {
         const TileInfo& tileInfo = it->value;
@@ -155,7 +155,7 @@ void TileCache::setNeedsDisplay()
     }
 }
 
-void TileCache::setNeedsDisplayInRect(const IntRect& rect)
+void TileController::setNeedsDisplayInRect(const IntRect& rect)
 {
     if (m_tiles.isEmpty())
         return;
@@ -186,7 +186,7 @@ void TileCache::setNeedsDisplayInRect(const IntRect& rect)
         setTileNeedsDisplayInRect(it->key, it->value, repaintRectInTileCoords, m_primaryTileCoverageRect);
 }
 
-void TileCache::setTileNeedsDisplayInRect(const TileIndex& tileIndex, TileInfo& tileInfo, const IntRect& repaintRectInTileCoords, const IntRect& coverageRectInTileCoords)
+void TileController::setTileNeedsDisplayInRect(const TileIndex& tileIndex, TileInfo& tileInfo, const IntRect& repaintRectInTileCoords, const IntRect& coverageRectInTileCoords)
 {
     WebTileLayer* tileLayer = tileInfo.layer.get();
 
@@ -213,7 +213,7 @@ void TileCache::setTileNeedsDisplayInRect(const TileIndex& tileIndex, TileInfo&
 }
 
 
-void TileCache::drawLayer(WebTileLayer *layer, CGContextRef context)
+void TileController::drawLayer(WebTileLayer *layer, CGContextRef context)
 {
     PlatformCALayer* platformLayer = PlatformCALayer::platformCALayer(m_tileCacheLayer);
     if (!platformLayer)
@@ -231,7 +231,7 @@ void TileCache::drawLayer(WebTileLayer *layer, CGContextRef context)
     drawRepaintCounter(layer, context);
 }
 
-void TileCache::setScale(CGFloat scale)
+void TileController::setScale(CGFloat scale)
 {
     PlatformCALayer* platformLayer = PlatformCALayer::platformCALayer(m_tileCacheLayer);
     float deviceScaleFactor = platformLayer->owner()->platformCALayerDeviceScaleFactor();
@@ -267,7 +267,7 @@ void TileCache::setScale(CGFloat scale)
 #endif
 }
 
-void TileCache::setAcceleratesDrawing(bool acceleratesDrawing)
+void TileController::setAcceleratesDrawing(bool acceleratesDrawing)
 {
 #if PLATFORM(IOS) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070
     if (m_acceleratesDrawing == acceleratesDrawing)
@@ -284,7 +284,7 @@ void TileCache::setAcceleratesDrawing(bool acceleratesDrawing)
 #endif
 }
 
-void TileCache::setTilesOpaque(bool opaque)
+void TileController::setTilesOpaque(bool opaque)
 {
     if (opaque == m_tilesAreOpaque)
         return;
@@ -297,7 +297,7 @@ void TileCache::setTilesOpaque(bool opaque)
     }
 }
 
-void TileCache::setVisibleRect(const FloatRect& visibleRect)
+void TileController::setVisibleRect(const FloatRect& visibleRect)
 {
     if (m_visibleRect == visibleRect)
         return;
@@ -306,7 +306,7 @@ void TileCache::setVisibleRect(const FloatRect& visibleRect)
     revalidateTiles();
 }
 
-void TileCache::setExposedRect(const FloatRect& exposedRect)
+void TileController::setExposedRect(const FloatRect& exposedRect)
 {
     if (m_exposedRect == exposedRect)
         return;
@@ -315,7 +315,7 @@ void TileCache::setExposedRect(const FloatRect& exposedRect)
     revalidateTiles();
 }
 
-void TileCache::setClipsToExposedRect(bool clipsToExposedRect)
+void TileController::setClipsToExposedRect(bool clipsToExposedRect)
 {
     if (m_clipsToExposedRect == clipsToExposedRect)
         return;
@@ -327,12 +327,12 @@ void TileCache::setClipsToExposedRect(bool clipsToExposedRect)
         revalidateTiles();
 }
 
-void TileCache::prepopulateRect(const FloatRect& rect)
+void TileController::prepopulateRect(const FloatRect& rect)
 {
     ensureTilesForRect(rect);
 }
 
-void TileCache::setIsInWindow(bool isInWindow)
+void TileController::setIsInWindow(bool isInWindow)
 {
     if (m_isInWindow == isInWindow)
         return;
@@ -347,7 +347,7 @@ void TileCache::setIsInWindow(bool isInWindow)
     }
 }
 
-void TileCache::setTileCoverage(TileCoverage coverage)
+void TileController::setTileCoverage(TileCoverage coverage)
 {
     if (coverage == m_tileCoverage)
         return;
@@ -356,12 +356,12 @@ void TileCache::setTileCoverage(TileCoverage coverage)
     scheduleTileRevalidation(0);
 }
 
-void TileCache::forceRepaint()
+void TileController::forceRepaint()
 {
     setNeedsDisplay();
 }
 
-void TileCache::setTileDebugBorderWidth(float borderWidth)
+void TileController::setTileDebugBorderWidth(float borderWidth)
 {
     if (m_tileDebugBorderWidth == borderWidth)
         return;
@@ -373,7 +373,7 @@ void TileCache::setTileDebugBorderWidth(float borderWidth)
     }
 }
 
-void TileCache::setTileDebugBorderColor(CGColorRef borderColor)
+void TileController::setTileDebugBorderColor(CGColorRef borderColor)
 {
     if (m_tileDebugBorderColor == borderColor)
         return;
@@ -385,12 +385,12 @@ void TileCache::setTileDebugBorderColor(CGColorRef borderColor)
     }
 }
 
-IntRect TileCache::bounds() const
+IntRect TileController::bounds() const
 {
     return IntRect(IntPoint(), IntSize([m_tileCacheLayer bounds].size));
 }
 
-IntRect TileCache::rectForTileIndex(const TileIndex& tileIndex) const
+IntRect TileController::rectForTileIndex(const TileIndex& tileIndex) const
 {
     IntRect rect(tileIndex.x() * m_tileSize.width(), tileIndex.y() * m_tileSize.height(), m_tileSize.width(), m_tileSize.height());
     IntRect scaledBounds(bounds());
@@ -401,7 +401,7 @@ IntRect TileCache::rectForTileIndex(const TileIndex& tileIndex) const
     return rect;
 }
 
-void TileCache::getTileIndexRangeForRect(const IntRect& rect, TileIndex& topLeft, TileIndex& bottomRight) const
+void TileController::getTileIndexRangeForRect(const IntRect& rect, TileIndex& topLeft, TileIndex& bottomRight) const
 {
     IntRect clampedRect = bounds();
     clampedRect.scale(m_scale);
@@ -417,7 +417,7 @@ void TileCache::getTileIndexRangeForRect(const IntRect& rect, TileIndex& topLeft
     bottomRight.setY(max(bottomYRatio - 1, 0));
 }
 
-FloatRect TileCache::computeTileCoverageRect(const FloatRect& previousVisibleRect) const
+FloatRect TileController::computeTileCoverageRect(const FloatRect& previousVisibleRect) const
 {
     FloatRect visibleRect = m_visibleRect;
 
@@ -458,7 +458,7 @@ FloatRect TileCache::computeTileCoverageRect(const FloatRect& previousVisibleRec
     return FloatRect(coverageLeft, coverageTop, coverageHorizontalSize, coverageVerticalSize);
 }
 
-IntSize TileCache::tileSizeForCoverageRect(const FloatRect& coverageRect) const
+IntSize TileController::tileSizeForCoverageRect(const FloatRect& coverageRect) const
 {
     if (m_tileCoverage & CoverageForSlowScrolling) {
         FloatSize tileSize = coverageRect.size();
@@ -466,10 +466,10 @@ IntSize TileCache::tileSizeForCoverageRect(const FloatRect& coverageRect) const
         return expandedIntSize(tileSize);
     }
 
-    return IntSize(defaultTileCacheWidth, defaultTileCacheHeight);
+    return IntSize(defaultTileWidth, defaultTileHeight);
 }
 
-void TileCache::scheduleTileRevalidation(double interval)
+void TileController::scheduleTileRevalidation(double interval)
 {
     if (m_tileRevalidationTimer.isActive() && m_tileRevalidationTimer.nextFireInterval() < interval)
         return;
@@ -477,7 +477,7 @@ void TileCache::scheduleTileRevalidation(double interval)
     m_tileRevalidationTimer.startOneShot(interval);
 }
 
-void TileCache::tileRevalidationTimerFired(Timer<TileCache>*)
+void TileController::tileRevalidationTimerFired(Timer<TileController>*)
 {
     TileValidationPolicyFlags foregroundValidationPolicy = m_aggressivelyRetainsTiles ? 0 : PruneSecondaryTiles;
     TileValidationPolicyFlags backgroundValidationPolicy = foregroundValidationPolicy | UnparentAllTiles;
@@ -485,7 +485,7 @@ void TileCache::tileRevalidationTimerFired(Timer<TileCache>*)
     revalidateTiles(foregroundValidationPolicy, backgroundValidationPolicy);
 }
 
-unsigned TileCache::blankPixelCount() const
+unsigned TileController::blankPixelCount() const
 {
     WebTileLayerList tiles(m_tiles.size());
 
@@ -495,7 +495,7 @@ unsigned TileCache::blankPixelCount() const
     return blankPixelCountForTiles(tiles, m_visibleRect, IntPoint(0,0));
 }
 
-unsigned TileCache::blankPixelCountForTiles(const WebTileLayerList& tiles, const FloatRect& visibleRect, const IntPoint& tileTranslation)
+unsigned TileController::blankPixelCountForTiles(const WebTileLayerList& tiles, const FloatRect& visibleRect, const IntPoint& tileTranslation)
 {
     Region paintedVisibleTiles;
 
@@ -515,15 +515,15 @@ unsigned TileCache::blankPixelCountForTiles(const WebTileLayerList& tiles, const
     return uncoveredRegion.totalArea();
 }
 
-static inline void queueTileForRemoval(const TileCache::TileIndex& tileIndex, const TileCache::TileInfo& tileInfo, Vector<TileCache::TileIndex>& tilesToRemove)
+static inline void queueTileForRemoval(const TileController::TileIndex& tileIndex, const TileController::TileInfo& tileInfo, Vector<TileController::TileIndex>& tilesToRemove)
 {
     WebTileLayer* tileLayer = tileInfo.layer.get();
     [tileLayer removeFromSuperlayer];
-    [tileLayer setTileCache:0];
+    [tileLayer setTileController:0];
     tilesToRemove.append(tileIndex);
 }
 
-void TileCache::removeAllTiles()
+void TileController::removeAllTiles()
 {
     Vector<TileIndex> tilesToRemove;
 
@@ -536,7 +536,7 @@ void TileCache::removeAllTiles()
     }
 }
 
-void TileCache::removeAllSecondaryTiles()
+void TileController::removeAllSecondaryTiles()
 {
     Vector<TileIndex> tilesToRemove;
 
@@ -554,7 +554,7 @@ void TileCache::removeAllSecondaryTiles()
     }
 }
 
-void TileCache::removeTilesInCohort(TileCohort cohort)
+void TileController::removeTilesInCohort(TileCohort cohort)
 {
     ASSERT(cohort != VisibleTileCohort);
     Vector<TileIndex> tilesToRemove;
@@ -573,9 +573,9 @@ void TileCache::removeTilesInCohort(TileCohort cohort)
     }
 }
 
-void TileCache::revalidateTiles(TileValidationPolicyFlags foregroundValidationPolicy, TileValidationPolicyFlags backgroundValidationPolicy)
+void TileController::revalidateTiles(TileValidationPolicyFlags foregroundValidationPolicy, TileValidationPolicyFlags backgroundValidationPolicy)
 {
-    // If the underlying PlatformLayer has been destroyed, but the WebTileCacheLayer hasn't
+    // If the underlying PlatformLayer has been destroyed, but the WebTiledBackingLayer hasn't
     // platformLayer will be null here.
     PlatformCALayer* platformLayer = PlatformCALayer::platformCALayer(m_tileCacheLayer);
     if (!platformLayer)
@@ -699,7 +699,7 @@ void TileCache::revalidateTiles(TileValidationPolicyFlags foregroundValidationPo
     platformLayer->owner()->platformCALayerDidCreateTiles(dirtyRects);
 }
 
-TileCache::TileCohort TileCache::nextTileCohort() const
+TileController::TileCohort TileController::nextTileCohort() const
 {
     if (!m_cohortList.isEmpty())
         return m_cohortList.last().cohort + 1;
@@ -707,22 +707,22 @@ TileCache::TileCohort TileCache::nextTileCohort() const
     return 1;
 }
 
-void TileCache::startedNewCohort(TileCohort cohort)
+void TileController::startedNewCohort(TileCohort cohort)
 {
     m_cohortList.append(TileCohortInfo(cohort, monotonicallyIncreasingTime()));
 }
 
-TileCache::TileCohort TileCache::newestTileCohort() const
+TileController::TileCohort TileController::newestTileCohort() const
 {
     return m_cohortList.isEmpty() ? 0 : m_cohortList.last().cohort;
 }
 
-TileCache::TileCohort TileCache::oldestTileCohort() const
+TileController::TileCohort TileController::oldestTileCohort() const
 {
     return m_cohortList.isEmpty() ? 0 : m_cohortList.first().cohort;
 }
 
-void TileCache::scheduleCohortRemoval()
+void TileController::scheduleCohortRemoval()
 {
     const double cohortRemovalTimerSeconds = 1;
 
@@ -731,7 +731,7 @@ void TileCache::scheduleCohortRemoval()
         m_cohortRemovalTimer.startRepeating(cohortRemovalTimerSeconds);
 }
 
-void TileCache::cohortRemovalTimerFired(Timer<TileCache>*)
+void TileController::cohortRemovalTimerFired(Timer<TileController>*)
 {
     if (m_cohortList.isEmpty()) {
         m_cohortRemovalTimer.stop();
@@ -750,7 +750,7 @@ void TileCache::cohortRemovalTimerFired(Timer<TileCache>*)
         updateTileCoverageMap();
 }
 
-void TileCache::ensureTilesForRect(const FloatRect& rect)
+void TileController::ensureTilesForRect(const FloatRect& rect)
 {
     if (m_unparentsOffscreenTiles && !m_isInWindow)
         return;
@@ -815,7 +815,7 @@ void TileCache::ensureTilesForRect(const FloatRect& rect)
         platformLayer->owner()->platformCALayerDidCreateTiles(dirtyRects);
 }
 
-void TileCache::updateTileCoverageMap()
+void TileController::updateTileCoverageMap()
 {
     FloatRect containerBounds = bounds();
     FloatRect visibleRect = this->visibleRect();
@@ -868,7 +868,7 @@ void TileCache::updateTileCoverageMap()
     END_BLOCK_OBJC_EXCEPTIONS
 }
 
-IntRect TileCache::tileGridExtent() const
+IntRect TileController::tileGridExtent() const
 {
     TileIndex topLeft;
     TileIndex bottomRight;
@@ -879,18 +879,18 @@ IntRect TileCache::tileGridExtent() const
 }
 
 // Return the rect in layer coords, not tile coords.
-IntRect TileCache::tileCoverageRect() const
+IntRect TileController::tileCoverageRect() const
 {
     IntRect coverageRectInLayerCoords(m_primaryTileCoverageRect);
     coverageRectInLayerCoords.scale(1 / m_scale);
     return coverageRectInLayerCoords;
 }
 
-CALayer *TileCache::tiledScrollingIndicatorLayer()
+CALayer *TileController::tiledScrollingIndicatorLayer()
 {
     if (!m_tiledScrollingIndicatorLayer) {
         m_tiledScrollingIndicatorLayer = [WebTiledScrollingIndicatorLayer layer];
-        [m_tiledScrollingIndicatorLayer.get() setTileCache:this];
+        [m_tiledScrollingIndicatorLayer.get() setTileController:this];
         [m_tiledScrollingIndicatorLayer.get() setOpacity:0.75];
         [m_tiledScrollingIndicatorLayer.get() setAnchorPoint:CGPointZero];
         [m_tiledScrollingIndicatorLayer.get() setBorderColor:cachedCGColor(Color::black, ColorSpaceDeviceRGB)];
@@ -902,7 +902,7 @@ CALayer *TileCache::tiledScrollingIndicatorLayer()
     return m_tiledScrollingIndicatorLayer.get();
 }
 
-void TileCache::setScrollingModeIndication(ScrollingModeIndication scrollingMode)
+void TileController::setScrollingModeIndication(ScrollingModeIndication scrollingMode)
 {
     if (scrollingMode == m_indicatorMode)
         return;
@@ -913,12 +913,12 @@ void TileCache::setScrollingModeIndication(ScrollingModeIndication scrollingMode
         updateTileCoverageMap();
 }
 
-WebTileLayer* TileCache::tileLayerAtIndex(const TileIndex& index) const
+WebTileLayer* TileController::tileLayerAtIndex(const TileIndex& index) const
 {
     return m_tiles.get(index).layer.get();
 }
 
-RetainPtr<WebTileLayer> TileCache::createTileLayer(const IntRect& tileRect)
+RetainPtr<WebTileLayer> TileController::createTileLayer(const IntRect& tileRect)
 {
     RetainPtr<WebTileLayer> layer = LayerPool::sharedPool()->takeLayerWithSize(tileRect.size());
     if (layer) {
@@ -930,7 +930,7 @@ RetainPtr<WebTileLayer> TileCache::createTileLayer(const IntRect& tileRect)
         layer = adoptNS([[WebTileLayer alloc] init]);
     [layer.get() setAnchorPoint:CGPointZero];
     [layer.get() setFrame:tileRect];
-    [layer.get() setTileCache:this];
+    [layer.get() setTileController:this];
     [layer.get() setBorderColor:m_tileDebugBorderColor.get()];
     [layer.get() setBorderWidth:m_tileDebugBorderWidth];
     [layer.get() setEdgeAntialiasingMask:0];
@@ -947,7 +947,7 @@ RetainPtr<WebTileLayer> TileCache::createTileLayer(const IntRect& tileRect)
     return layer;
 }
 
-bool TileCache::shouldShowRepaintCounters() const
+bool TileController::shouldShowRepaintCounters() const
 {
     PlatformCALayer* platformLayer = PlatformCALayer::platformCALayer(m_tileCacheLayer);
     if (!platformLayer)
@@ -961,7 +961,7 @@ bool TileCache::shouldShowRepaintCounters() const
     return layerContents->platformCALayerShowRepaintCounter(0);
 }
 
-void TileCache::drawRepaintCounter(WebTileLayer *layer, CGContextRef context)
+void TileController::drawRepaintCounter(WebTileLayer *layer, CGContextRef context)
 {
     unsigned paintCount = [layer incrementPaintCount];
     if (!shouldShowRepaintCounters())
@@ -1000,7 +1000,7 @@ void TileCache::drawRepaintCounter(WebTileLayer *layer, CGContextRef context)
     CGContextRestoreGState(context);
 }
 
-void TileCache::drawTileMapContents(CGContextRef context, CGRect layerBounds)
+void TileController::drawTileMapContents(CGContextRef context, CGRect layerBounds)
 {
     CGContextSetRGBFillColor(context, 0.3, 0.3, 0.3, 1);
     CGContextFillRect(context, layerBounds);
index 02f6cc8..e3a28bb 100644 (file)
 #define WebTileLayer_h
 
 namespace WebCore {
-    class TileCache;
+class TileController;
 }
 
 @interface WebTileLayer : CALayer {
-    WebCore::TileCache* _tileCache;
+    WebCore::TileController* _tileController;
     unsigned _paintCount;
 }
 
-- (void)setTileCache:(WebCore::TileCache*)tileCache;
+- (void)setTileController:(WebCore::TileController*)tileController;
 - (void)resetPaintCount;
 - (unsigned)incrementPaintCount;
 - (unsigned)paintCount;
index 9593cb6..f63134b 100644 (file)
@@ -26,7 +26,7 @@
 #import "config.h"
 #import "WebTileLayer.h"
 
-#import "TileCache.h"
+#import "TileController.h"
 #import <wtf/CurrentTime.h>
 #import <wtf/UnusedParam.h>
 
@@ -48,17 +48,17 @@ using namespace WebCore;
 
 - (void)drawInContext:(CGContextRef)context
 {
-    if (_tileCache) {
-        _tileCache->drawLayer(self, context);
+    if (_tileController) {
+        _tileController->drawLayer(self, context);
 
-        if (static_cast<TiledBacking*>(_tileCache)->scrollingPerformanceLoggingEnabled())
+        if (static_cast<TiledBacking*>(_tileController)->scrollingPerformanceLoggingEnabled())
             [self logFilledFreshTile];
     }
 }
 
-- (void)setTileCache:(WebCore::TileCache*)tileCache
+- (void)setTileController:(WebCore::TileController*)tileController
 {
-    _tileCache = tileCache;
+    _tileController = tileController;
 }
 
 - (void)resetPaintCount
@@ -79,10 +79,10 @@ using namespace WebCore;
 - (void)logFilledFreshTile
 {
     FloatRect visiblePart([self frame]);
-    visiblePart.intersect(_tileCache->visibleRect());
+    visiblePart.intersect(_tileController->visibleRect());
 
     if ([self paintCount] == 1 && !visiblePart.isEmpty())
-        WTFLogAlways("SCROLLING: Filled visible fresh tile. Time: %f Unfilled Pixels: %u\n", WTF::monotonicallyIncreasingTime(), _tileCache->blankPixelCount());
+        WTFLogAlways("SCROLLING: Filled visible fresh tile. Time: %f Unfilled Pixels: %u\n", WTF::monotonicallyIncreasingTime(), _tileController->blankPixelCount());
 }
 
 @end
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
-#ifndef WebTileCacheLayer_h
-#define WebTileCacheLayer_h
+
+#ifndef WebTiledBackingLayer_h
+#define WebTiledBackingLayer_h
 
 #import <QuartzCore/QuartzCore.h>
 #import <wtf/OwnPtr.h>
 
 namespace WebCore {
-    class IntRect;
-    class TileCache;
-    class TiledBacking;
+class IntRect;
+class TileController;
+class TiledBacking;
 }
 
-@interface WebTileCacheLayer : CALayer {
-    OwnPtr<WebCore::TileCache> _tileCache;
+@interface WebTiledBackingLayer : CALayer {
+    OwnPtr<WebCore::TileController> _tileController;
 }
 
 - (CALayer *)tileContainerLayer;
@@ -45,4 +45,4 @@ namespace WebCore {
 
 @end
 
-#endif // WebTileCacheLayer_h
+#endif // WebTiledBackingLayer_h
  */
 
 #import "config.h"
-#import "WebTileCacheLayer.h"
+#import "WebTiledBackingLayer.h"
 
 #import "IntRect.h"
-#import "TileCache.h"
+#import "TileController.h"
 #import <wtf/MainThread.h>
 
 using namespace WebCore;
 
-@implementation WebTileCacheLayer
+@implementation WebTiledBackingLayer
 
 - (id)init
 {
@@ -40,16 +40,16 @@ using namespace WebCore;
     if (!self)
         return nil;
 
-    _tileCache = TileCache::create(self);
+    _tileController = TileController::create(self);
 #ifndef NDEBUG
-    [self setName:@"WebTileCacheLayer"];
+    [self setName:@"WebTiledBackingLayer"];
 #endif
     return self;
 }
 
 - (void)dealloc
 {
-    ASSERT(!_tileCache);
+    ASSERT(!_tileController);
 
     [super dealloc];
 }
@@ -74,70 +74,70 @@ using namespace WebCore;
 {
     [super setBounds:bounds];
 
-    _tileCache->tileCacheLayerBoundsChanged();
+    _tileController->tileCacheLayerBoundsChanged();
 }
 
 - (void)setOpaque:(BOOL)opaque
 {
-    _tileCache->setTilesOpaque(opaque);
+    _tileController->setTilesOpaque(opaque);
 }
 
 - (BOOL)isOpaque
 {
-    return _tileCache->tilesAreOpaque();
+    return _tileController->tilesAreOpaque();
 }
 
 - (void)setNeedsDisplay
 {
-    _tileCache->setNeedsDisplay();
+    _tileController->setNeedsDisplay();
 }
 
 - (void)setNeedsDisplayInRect:(CGRect)rect
 {
-    _tileCache->setNeedsDisplayInRect(enclosingIntRect(rect));
+    _tileController->setNeedsDisplayInRect(enclosingIntRect(rect));
 }
 
 - (void)setAcceleratesDrawing:(BOOL)acceleratesDrawing
 {
-    _tileCache->setAcceleratesDrawing(acceleratesDrawing);
+    _tileController->setAcceleratesDrawing(acceleratesDrawing);
 }
 
 - (BOOL)acceleratesDrawing
 {
-    return _tileCache->acceleratesDrawing();
+    return _tileController->acceleratesDrawing();
 }
 
 - (void)setContentsScale:(CGFloat)contentsScale
 {
-    _tileCache->setScale(contentsScale);
+    _tileController->setScale(contentsScale);
 }
 
 - (CALayer *)tileContainerLayer
 {
-    return _tileCache->tileContainerLayer();
+    return _tileController->tileContainerLayer();
 }
 
 - (WebCore::TiledBacking*)tiledBacking
 {
-    return _tileCache.get();
+    return _tileController.get();
 }
 
 - (void)invalidate
 {
     ASSERT(isMainThread());
-    ASSERT(_tileCache);
-    _tileCache = nullptr;
+    ASSERT(_tileController);
+    _tileController = nullptr;
 }
 
 - (void)setBorderColor:(CGColorRef)borderColor
 {
-    _tileCache->setTileDebugBorderColor(borderColor);
+    _tileController->setTileDebugBorderColor(borderColor);
 }
 
 - (void)setBorderWidth:(CGFloat)borderWidth
 {
     // Tiles adjoin, so halve the border width.
-    _tileCache->setTileDebugBorderWidth(borderWidth / 2);
+    _tileController->setTileDebugBorderWidth(borderWidth / 2);
 }
 
 @end
index 565a118..9f74372 100644 (file)
@@ -133,7 +133,7 @@ void drawLayerContents(CGContextRef context, CALayer *layer, WebCore::PlatformCA
     // for the Web Inspector feeding this information through the LayerTreeAgent. 
     int repaintCount = layerContents->platformCALayerIncrementRepaintCount();
 
-    if (!platformLayer->usesTileCacheLayer() && layerContents && layerContents->platformCALayerShowRepaintCounter(platformLayer)) {
+    if (!platformLayer->usesTiledBackingLayer() && layerContents && layerContents->platformCALayerShowRepaintCounter(platformLayer)) {
         bool isTiledLayer = [layer isKindOfClass:[CATiledLayer class]];
 
         char text[16]; // that's a lot of repaints
index c253a59..0c1259d 100644 (file)
@@ -145,7 +145,7 @@ RenderLayerBacking::RenderLayerBacking(RenderLayer* layer)
                 tiledBacking->setUnparentsOffscreenTiles(true);
 
             tiledBacking->setScrollingPerformanceLoggingEnabled(frame->settings() && frame->settings()->scrollingPerformanceLoggingEnabled());
-            adjustTileCacheCoverage();
+            adjustTiledBackingCoverage();
         }
     }
 }
@@ -184,7 +184,7 @@ PassOwnPtr<GraphicsLayer> RenderLayerBacking::createGraphicsLayer(const String&
     return graphicsLayer.release();
 }
 
-bool RenderLayerBacking::shouldUseTileCache(const GraphicsLayer*) const
+bool RenderLayerBacking::shouldUseTiledBacking(const GraphicsLayer*) const
 {
     return m_usingTiledCacheLayer && m_creatingPrimaryGraphicsLayer;
 }
@@ -194,7 +194,7 @@ TiledBacking* RenderLayerBacking::tiledBacking() const
     return m_graphicsLayer->tiledBacking();
 }
 
-void RenderLayerBacking::adjustTileCacheCoverage()
+void RenderLayerBacking::adjustTiledBackingCoverage()
 {
     if (!m_usingTiledCacheLayer)
         return;
@@ -274,7 +274,7 @@ void RenderLayerBacking::createPrimaryGraphicsLayer()
 #endif
     
     // The call to createGraphicsLayer ends calling back into here as
-    // a GraphicsLayerClient to ask if it shouldUseTileCache(). We only want
+    // a GraphicsLayerClient to ask if it shouldUseTiledBacking(). We only want
     // the tile cache on our main layer. This is pretty ugly, but saves us from
     // exposing the API to all clients.
 
@@ -283,7 +283,7 @@ void RenderLayerBacking::createPrimaryGraphicsLayer()
     m_creatingPrimaryGraphicsLayer = false;
 
     if (m_usingTiledCacheLayer)
-        m_childContainmentLayer = createGraphicsLayer("TileCache Flattening Layer");
+        m_childContainmentLayer = createGraphicsLayer("TiledBacking Flattening Layer");
 
     if (m_isMainFrameRenderViewLayer) {
         m_graphicsLayer->setContentsOpaque(true);
index c9abce3..94f1078 100644 (file)
@@ -147,14 +147,14 @@ public:
     void positionOverflowControlsLayers(const IntSize& offsetFromRoot);
     bool hasUnpositionedOverflowControlsLayers() const;
 
-    bool usingTileCache() const { return m_usingTiledCacheLayer; }
+    bool usingTiledBacking() const { return m_usingTiledCacheLayer; }
     TiledBacking* tiledBacking() const;
-    void adjustTileCacheCoverage();
+    void adjustTiledBackingCoverage();
     
     void updateDebugIndicators(bool showBorder, bool showRepaintCounter);
 
     // GraphicsLayerClient interface
-    virtual bool shouldUseTileCache(const GraphicsLayer*) const OVERRIDE;
+    virtual bool shouldUseTiledBacking(const GraphicsLayer*) const OVERRIDE;
     virtual void notifyAnimationStarted(const GraphicsLayer*, double startTime) OVERRIDE;
     virtual void notifyFlushRequired(const GraphicsLayer*) OVERRIDE;
     virtual void notifyFlushBeforeDisplayRefresh(const GraphicsLayer*) OVERRIDE;
@@ -260,7 +260,7 @@ private:
 
     bool shouldClipCompositedBounds() const;
 
-    bool hasTileCacheFlatteningLayer() const { return (m_childContainmentLayer && m_usingTiledCacheLayer); }
+    bool hasTiledBackingFlatteningLayer() const { return (m_childContainmentLayer && m_usingTiledCacheLayer); }
     GraphicsLayer* tileCacheFlatteningLayer() const { return m_usingTiledCacheLayer ? m_childContainmentLayer.get() : 0; }
 
     void paintIntoLayer(const GraphicsLayer*, GraphicsContext*, const IntRect& paintDirtyRect, PaintBehavior, GraphicsLayerPaintingPhase);
index ca5ae11..bb67eb8 100644 (file)
@@ -1236,13 +1236,13 @@ void RenderLayerCompositor::frameViewDidLayout()
 {
     RenderLayerBacking* renderViewBacking = m_renderView->layer()->backing();
     if (renderViewBacking)
-        renderViewBacking->adjustTileCacheCoverage();
+        renderViewBacking->adjustTiledBackingCoverage();
 }
 
 void RenderLayerCompositor::rootFixedBackgroundsChanged()
 {
     RenderLayerBacking* renderViewBacking = m_renderView->layer()->backing();
-    if (renderViewBacking && renderViewBacking->usingTileCache())
+    if (renderViewBacking && renderViewBacking->usingTiledBacking())
         setCompositingLayersNeedRebuild();
 }
 
@@ -2273,7 +2273,7 @@ void RenderLayerCompositor::paintContents(const GraphicsLayer* graphicsLayer, Gr
 bool RenderLayerCompositor::supportsFixedRootBackgroundCompositing() const
 {
     RenderLayerBacking* renderViewBacking = m_renderView->layer()->backing();
-    return renderViewBacking && renderViewBacking->usingTileCache();
+    return renderViewBacking && renderViewBacking->usingTiledBacking();
 }
 
 bool RenderLayerCompositor::needsFixedRootBackgroundLayer(const RenderLayer* layer) const