Changeset 166529 in webkit


Ignore:
Timestamp:
Mar 31, 2014 2:18:23 PM (10 years ago)
Author:
Antti Koivisto
Message:

Rename TileCache to LegacyTileCache
https://bugs.webkit.org/show_bug.cgi?id=130986

Reviewed by Simon Fraser.

../WebCore:

Rename iOS WebKit1 tile cache classes to reflect its status.
This also frees some good type names.

TileCache -> LegacyTileCache
TileGrid -> LegacyTileGrid
TileGridTile -> LegacyTileGridTile
etc.

../WebKit/mac:

  • WebView/WebView.mm:

(+[WebView drainLayerPool]):
(+[WebView _setTileCacheLayerPoolCapacity:]):

Location:
trunk/Source
Files:
11 edited
10 moved

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r166528 r166529  
     12014-03-31  Antti Koivisto  <antti@apple.com>
     2
     3        Rename TileCache to LegacyTileCache
     4        https://bugs.webkit.org/show_bug.cgi?id=130986
     5
     6        Reviewed by Simon Fraser.
     7
     8        Rename iOS WebKit1 tile cache classes to reflect its status.
     9        This also frees some good type names.
     10
     11        TileCache -> LegacyTileCache
     12        TileGrid -> LegacyTileGrid
     13        TileGridTile -> LegacyTileGridTile
     14        etc.
     15
    1162014-03-31  Tim Horton  <timothy_horton@apple.com>
    217
  • trunk/Source/WebCore/WebCore.exp.in

    r166528 r166529  
    24832483__ZN7WebCore15GraphicsContext23setIsAcceleratedContextEb
    24842484__ZN7WebCore15GraphicsContextC1EP9CGContextb
     2485__ZN7WebCore15LegacyTileCache14drainLayerPoolEv
     2486__ZN7WebCore15LegacyTileCache20setLayerPoolCapacityEj
    24852487__ZN7WebCore15QuickLookHandle10nsResponseEv
    24862488__ZN7WebCore15QuickLookHandle14didReceiveDataEPK8__CFData
     
    26372639__ZN7WebCore9FrameView36scheduleLayerFlushAllowingThrottlingEv
    26382640__ZN7WebCore9PageGroup17removeVisitedLinkERKNS_3URLE
    2639 __ZN7WebCore9TileCache14drainLayerPoolEv
    2640 __ZN7WebCore9TileCache20setLayerPoolCapacityEj
    26412641__ZNK7WebCore10FloatPointcv7CGPointEv
    26422642__ZNK7WebCore10ScrollView21unobscuredContentRectENS_14ScrollableArea36VisibleContentRectIncludesScrollbarsE
  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r166520 r166529  
    59765976                E1FF8F6D180DB5BE00132674 /* CryptoAlgorithmRegistry.h in Headers */ = {isa = PBXBuildFile; fileRef = E1FF8F6B180DB5BE00132674 /* CryptoAlgorithmRegistry.h */; };
    59775977                E401C27517CE53EC00C41A35 /* ElementIteratorAssertions.h in Headers */ = {isa = PBXBuildFile; fileRef = E401C27417CE53EC00C41A35 /* ElementIteratorAssertions.h */; settings = {ATTRIBUTES = (Private, ); }; };
    5978                 E424A39E1330DF0100CF6DC9 /* TileGridTile.h in Headers */ = {isa = PBXBuildFile; fileRef = E424A39D1330DF0100CF6DC9 /* TileGridTile.h */; };
    5979                 E424A3A01330DF1E00CF6DC9 /* TileGridTile.mm in Sources */ = {isa = PBXBuildFile; fileRef = E424A39F1330DF1E00CF6DC9 /* TileGridTile.mm */; };
     5978                E424A39E1330DF0100CF6DC9 /* LegacyTileGridTile.h in Headers */ = {isa = PBXBuildFile; fileRef = E424A39D1330DF0100CF6DC9 /* LegacyTileGridTile.h */; };
     5979                E424A3A01330DF1E00CF6DC9 /* LegacyTileGridTile.mm in Sources */ = {isa = PBXBuildFile; fileRef = E424A39F1330DF1E00CF6DC9 /* LegacyTileGridTile.mm */; };
    59805980                E425A49A18292B840020CFCF /* CollectionIndexCache.h in Headers */ = {isa = PBXBuildFile; fileRef = E425A49918292B840020CFCF /* CollectionIndexCache.h */; };
    59815981                E4295FA412B0614E00D1ACE0 /* ResourceLoadPriority.h in Headers */ = {isa = PBXBuildFile; fileRef = E4295FA312B0614E00D1ACE0 /* ResourceLoadPriority.h */; settings = {ATTRIBUTES = (Private, ); }; };
     
    60586058                E4AFD00F0DAF335500F5F55C /* SVGSMILElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E4AFD0090DAF335400F5F55C /* SVGSMILElement.cpp */; };
    60596059                E4AFD0100DAF335500F5F55C /* SVGSMILElement.h in Headers */ = {isa = PBXBuildFile; fileRef = E4AFD00A0DAF335400F5F55C /* SVGSMILElement.h */; settings = {ATTRIBUTES = (Private, ); }; };
    6060                 E4B65A58132FA8E70070E7BE /* TileGrid.h in Headers */ = {isa = PBXBuildFile; fileRef = E4B65A57132FA8E70070E7BE /* TileGrid.h */; };
    6061                 E4B65A5A132FAAF90070E7BE /* TileGrid.mm in Sources */ = {isa = PBXBuildFile; fileRef = E4B65A59132FAAF90070E7BE /* TileGrid.mm */; };
    6062                 E4B65A5C132FACB00070E7BE /* TileLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = E4B65A5B132FACB00070E7BE /* TileLayer.h */; };
    6063                 E4B65A5E132FADB60070E7BE /* TileLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = E4B65A5D132FADB60070E7BE /* TileLayer.mm */; };
     6060                E4B65A58132FA8E70070E7BE /* LegacyTileGrid.h in Headers */ = {isa = PBXBuildFile; fileRef = E4B65A57132FA8E70070E7BE /* LegacyTileGrid.h */; };
     6061                E4B65A5A132FAAF90070E7BE /* LegacyTileGrid.mm in Sources */ = {isa = PBXBuildFile; fileRef = E4B65A59132FAAF90070E7BE /* LegacyTileGrid.mm */; };
     6062                E4B65A5C132FACB00070E7BE /* LegacyTileLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = E4B65A5B132FACB00070E7BE /* LegacyTileLayer.h */; };
     6063                E4B65A5E132FADB60070E7BE /* LegacyTileLayer.mm in Sources */ = {isa = PBXBuildFile; fileRef = E4B65A5D132FADB60070E7BE /* LegacyTileLayer.mm */; };
    60646064                E4BBED0E14F4025D003F0B98 /* PropertySetCSSStyleDeclaration.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E4BBED0C14F4025D003F0B98 /* PropertySetCSSStyleDeclaration.cpp */; };
    60656065                E4BBED0F14F4025D003F0B98 /* PropertySetCSSStyleDeclaration.h in Headers */ = {isa = PBXBuildFile; fileRef = E4BBED0D14F4025D003F0B98 /* PropertySetCSSStyleDeclaration.h */; };
     
    60706070                E4C279580CF9741900E97B98 /* RenderMedia.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E4C279560CF9741900E97B98 /* RenderMedia.cpp */; };
    60716071                E4C279590CF9741900E97B98 /* RenderMedia.h in Headers */ = {isa = PBXBuildFile; fileRef = E4C279570CF9741900E97B98 /* RenderMedia.h */; };
    6072                 E4C3B1FA0F0E4161009693F6 /* TileCache.h in Headers */ = {isa = PBXBuildFile; fileRef = E4C3B1F90F0E4161009693F6 /* TileCache.h */; settings = {ATTRIBUTES = (Private, ); }; };
    6073                 E4C3B1FC0F0E4170009693F6 /* TileCache.mm in Sources */ = {isa = PBXBuildFile; fileRef = E4C3B1FB0F0E4170009693F6 /* TileCache.mm */; };
     6072                E4C3B1FA0F0E4161009693F6 /* LegacyTileCache.h in Headers */ = {isa = PBXBuildFile; fileRef = E4C3B1F90F0E4161009693F6 /* LegacyTileCache.h */; settings = {ATTRIBUTES = (Private, ); }; };
     6073                E4C3B1FC0F0E4170009693F6 /* LegacyTileCache.mm in Sources */ = {isa = PBXBuildFile; fileRef = E4C3B1FB0F0E4170009693F6 /* LegacyTileCache.mm */; };
    60746074                E4C91A0E1802343100A17F6D /* TextPaintStyle.h in Headers */ = {isa = PBXBuildFile; fileRef = E4C91A0D1802343100A17F6D /* TextPaintStyle.h */; };
    60756075                E4C91A101802343900A17F6D /* TextPaintStyle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E4C91A0F1802343900A17F6D /* TextPaintStyle.cpp */; };
     
    60876087                E4DEAA1717A93DC3000E0430 /* StyleResolveTree.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E4DEAA1517A93DC3000E0430 /* StyleResolveTree.cpp */; };
    60886088                E4DEAA1817A93DC3000E0430 /* StyleResolveTree.h in Headers */ = {isa = PBXBuildFile; fileRef = E4DEAA1617A93DC3000E0430 /* StyleResolveTree.h */; settings = {ATTRIBUTES = (Private, ); }; };
    6089                 E4E39AFB1330EFA8003AB274 /* TileLayerPool.h in Headers */ = {isa = PBXBuildFile; fileRef = E4E39AFA1330EFA8003AB274 /* TileLayerPool.h */; };
    6090                 E4E39AFD1330EFC6003AB274 /* TileLayerPool.mm in Sources */ = {isa = PBXBuildFile; fileRef = E4E39AFC1330EFC5003AB274 /* TileLayerPool.mm */; };
     6089                E4E39AFB1330EFA8003AB274 /* LegacyTileLayerPool.h in Headers */ = {isa = PBXBuildFile; fileRef = E4E39AFA1330EFA8003AB274 /* LegacyTileLayerPool.h */; };
     6090                E4E39AFD1330EFC6003AB274 /* LegacyTileLayerPool.mm in Sources */ = {isa = PBXBuildFile; fileRef = E4E39AFC1330EFC5003AB274 /* LegacyTileLayerPool.mm */; };
    60916091                E4E9B1191810916F003ACCDF /* SimpleLineLayoutResolver.h in Headers */ = {isa = PBXBuildFile; fileRef = E4E9B1181810916F003ACCDF /* SimpleLineLayoutResolver.h */; };
    60926092                E4E9B11B18145692003ACCDF /* SimpleLineLayoutFunctions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E4E9B11A18145692003ACCDF /* SimpleLineLayoutFunctions.cpp */; };
     
    1336613366                E41EA038119836DB00710BC5 /* CSSPropertyNames.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CSSPropertyNames.cpp; sourceTree = "<group>"; };
    1336713367                E41EA0391198374900710BC5 /* CSSValueKeywords.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CSSValueKeywords.cpp; sourceTree = "<group>"; };
    13368                 E424A39D1330DF0100CF6DC9 /* TileGridTile.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = TileGridTile.h; path = ios/TileGridTile.h; sourceTree = "<group>"; };
    13369                 E424A39F1330DF1E00CF6DC9 /* TileGridTile.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = TileGridTile.mm; path = ios/TileGridTile.mm; sourceTree = "<group>"; };
     13368                E424A39D1330DF0100CF6DC9 /* LegacyTileGridTile.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = LegacyTileGridTile.h; path = ios/LegacyTileGridTile.h; sourceTree = "<group>"; };
     13369                E424A39F1330DF1E00CF6DC9 /* LegacyTileGridTile.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = LegacyTileGridTile.mm; path = ios/LegacyTileGridTile.mm; sourceTree = "<group>"; };
    1337013370                E425A49918292B840020CFCF /* CollectionIndexCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CollectionIndexCache.h; sourceTree = "<group>"; };
    1337113371                E4295FA312B0614E00D1ACE0 /* ResourceLoadPriority.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ResourceLoadPriority.h; sourceTree = "<group>"; };
     
    1345713457                E4B423850CBFB73C00AF2ECE /* JSProgressEvent.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSProgressEvent.cpp; sourceTree = "<group>"; };
    1345813458                E4B423860CBFB73C00AF2ECE /* JSProgressEvent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSProgressEvent.h; sourceTree = "<group>"; };
    13459                 E4B65A57132FA8E70070E7BE /* TileGrid.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = TileGrid.h; path = ios/TileGrid.h; sourceTree = "<group>"; };
    13460                 E4B65A59132FAAF90070E7BE /* TileGrid.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = TileGrid.mm; path = ios/TileGrid.mm; sourceTree = "<group>"; };
    13461                 E4B65A5B132FACB00070E7BE /* TileLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = TileLayer.h; path = ios/TileLayer.h; sourceTree = "<group>"; };
    13462                 E4B65A5D132FADB60070E7BE /* TileLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = TileLayer.mm; path = ios/TileLayer.mm; sourceTree = "<group>"; };
     13459                E4B65A57132FA8E70070E7BE /* LegacyTileGrid.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = LegacyTileGrid.h; path = ios/LegacyTileGrid.h; sourceTree = "<group>"; };
     13460                E4B65A59132FAAF90070E7BE /* LegacyTileGrid.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = LegacyTileGrid.mm; path = ios/LegacyTileGrid.mm; sourceTree = "<group>"; };
     13461                E4B65A5B132FACB00070E7BE /* LegacyTileLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = LegacyTileLayer.h; path = ios/LegacyTileLayer.h; sourceTree = "<group>"; };
     13462                E4B65A5D132FADB60070E7BE /* LegacyTileLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = LegacyTileLayer.mm; path = ios/LegacyTileLayer.mm; sourceTree = "<group>"; };
    1346313463                E4BBED0C14F4025D003F0B98 /* PropertySetCSSStyleDeclaration.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PropertySetCSSStyleDeclaration.cpp; sourceTree = "<group>"; };
    1346413464                E4BBED0D14F4025D003F0B98 /* PropertySetCSSStyleDeclaration.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PropertySetCSSStyleDeclaration.h; sourceTree = "<group>"; };
     
    1346913469                E4C279560CF9741900E97B98 /* RenderMedia.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderMedia.cpp; sourceTree = "<group>"; };
    1347013470                E4C279570CF9741900E97B98 /* RenderMedia.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderMedia.h; sourceTree = "<group>"; };
    13471                 E4C3B1F90F0E4161009693F6 /* TileCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = TileCache.h; path = ios/TileCache.h; sourceTree = "<group>"; };
    13472                 E4C3B1FB0F0E4170009693F6 /* TileCache.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = TileCache.mm; path = ios/TileCache.mm; sourceTree = "<group>"; };
     13471                E4C3B1F90F0E4161009693F6 /* LegacyTileCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = LegacyTileCache.h; path = ios/LegacyTileCache.h; sourceTree = "<group>"; };
     13472                E4C3B1FB0F0E4170009693F6 /* LegacyTileCache.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = LegacyTileCache.mm; path = ios/LegacyTileCache.mm; sourceTree = "<group>"; };
    1347313473                E4C91A0D1802343100A17F6D /* TextPaintStyle.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TextPaintStyle.h; sourceTree = "<group>"; };
    1347413474                E4C91A0F1802343900A17F6D /* TextPaintStyle.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TextPaintStyle.cpp; sourceTree = "<group>"; };
     
    1348613486                E4DEAA1517A93DC3000E0430 /* StyleResolveTree.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StyleResolveTree.cpp; sourceTree = "<group>"; };
    1348713487                E4DEAA1617A93DC3000E0430 /* StyleResolveTree.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StyleResolveTree.h; sourceTree = "<group>"; };
    13488                 E4E39AFA1330EFA8003AB274 /* TileLayerPool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = TileLayerPool.h; path = ios/TileLayerPool.h; sourceTree = "<group>"; };
    13489                 E4E39AFC1330EFC5003AB274 /* TileLayerPool.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = TileLayerPool.mm; path = ios/TileLayerPool.mm; sourceTree = "<group>"; };
     13488                E4E39AFA1330EFA8003AB274 /* LegacyTileLayerPool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = LegacyTileLayerPool.h; path = ios/LegacyTileLayerPool.h; sourceTree = "<group>"; };
     13489                E4E39AFC1330EFC5003AB274 /* LegacyTileLayerPool.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = LegacyTileLayerPool.mm; path = ios/LegacyTileLayerPool.mm; sourceTree = "<group>"; };
    1349013490                E4E9B1181810916F003ACCDF /* SimpleLineLayoutResolver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SimpleLineLayoutResolver.h; sourceTree = "<group>"; };
    1349113491                E4E9B11A18145692003ACCDF /* SimpleLineLayoutFunctions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SimpleLineLayoutFunctions.cpp; sourceTree = "<group>"; };
     
    1814118141                                44C9919D0F3D210E00586670 /* ThemeIOS.h */,
    1814218142                                44C9919E0F3D210E00586670 /* ThemeIOS.mm */,
    18143                                 E4C3B1F90F0E4161009693F6 /* TileCache.h */,
    18144                                 E4C3B1FB0F0E4170009693F6 /* TileCache.mm */,
     18143                                E4C3B1F90F0E4161009693F6 /* LegacyTileCache.h */,
     18144                                E4C3B1FB0F0E4170009693F6 /* LegacyTileCache.mm */,
    1814518145                                1F72BF08187FD4270009BCB3 /* TileControllerMemoryHandlerIOS.cpp */,
    1814618146                                1F72BF09187FD4270009BCB3 /* TileControllerMemoryHandlerIOS.h */,
    18147                                 E4B65A57132FA8E70070E7BE /* TileGrid.h */,
    18148                                 E4B65A59132FAAF90070E7BE /* TileGrid.mm */,
    18149                                 E424A39D1330DF0100CF6DC9 /* TileGridTile.h */,
    18150                                 E424A39F1330DF1E00CF6DC9 /* TileGridTile.mm */,
    18151                                 E4B65A5B132FACB00070E7BE /* TileLayer.h */,
    18152                                 E4B65A5D132FADB60070E7BE /* TileLayer.mm */,
    18153                                 E4E39AFA1330EFA8003AB274 /* TileLayerPool.h */,
    18154                                 E4E39AFC1330EFC5003AB274 /* TileLayerPool.mm */,
     18147                                E4B65A57132FA8E70070E7BE /* LegacyTileGrid.h */,
     18148                                E4B65A59132FAAF90070E7BE /* LegacyTileGrid.mm */,
     18149                                E424A39D1330DF0100CF6DC9 /* LegacyTileGridTile.h */,
     18150                                E424A39F1330DF1E00CF6DC9 /* LegacyTileGridTile.mm */,
     18151                                E4B65A5B132FACB00070E7BE /* LegacyTileLayer.h */,
     18152                                E4B65A5D132FADB60070E7BE /* LegacyTileLayer.mm */,
     18153                                E4E39AFA1330EFA8003AB274 /* LegacyTileLayerPool.h */,
     18154                                E4E39AFC1330EFC5003AB274 /* LegacyTileLayerPool.mm */,
    1815518155                                31403797124BEA7F00AF40E4 /* WebCoreMotionManager.h */,
    1815618156                                31403798124BEA7F00AF40E4 /* WebCoreMotionManager.mm */,
     
    2595625956                                E1FF57A30F01255B00891EBB /* ThreadGlobalData.h in Headers */,
    2595725957                                185BCF290F3279CE000EA262 /* ThreadTimers.h in Headers */,
    25958                                 E4C3B1FA0F0E4161009693F6 /* TileCache.h in Headers */,
     25958                                E4C3B1FA0F0E4161009693F6 /* LegacyTileCache.h in Headers */,
    2595925959                                1AA7160B149BC4DB0016EC19 /* TileController.h in Headers */,
    2596025960                                1F72BF0B187FD45C0009BCB3 /* TileControllerMemoryHandlerIOS.h in Headers */,
    2596125961                                1AF89A421518FDEA00E547B5 /* TiledBacking.h in Headers */,
    25962                                 E4B65A58132FA8E70070E7BE /* TileGrid.h in Headers */,
    25963                                 E424A39E1330DF0100CF6DC9 /* TileGridTile.h in Headers */,
    25964                                 E4B65A5C132FACB00070E7BE /* TileLayer.h in Headers */,
    25965                                 E4E39AFB1330EFA8003AB274 /* TileLayerPool.h in Headers */,
     25962                                E4B65A58132FA8E70070E7BE /* LegacyTileGrid.h in Headers */,
     25963                                E424A39E1330DF0100CF6DC9 /* LegacyTileGridTile.h in Headers */,
     25964                                E4B65A5C132FACB00070E7BE /* LegacyTileLayer.h in Headers */,
     25965                                E4E39AFB1330EFA8003AB274 /* LegacyTileLayerPool.h in Headers */,
    2596625966                                498770F31242C535002226BA /* TilingData.h in Headers */,
    2596725967                                F55B3DDC1251F12D003EF269 /* TimeInputType.h in Headers */,
     
    2920829208                                E1FF57A60F01256B00891EBB /* ThreadGlobalData.cpp in Sources */,
    2920929209                                185BCF280F3279CE000EA262 /* ThreadTimers.cpp in Sources */,
    29210                                 E4C3B1FC0F0E4170009693F6 /* TileCache.mm in Sources */,
     29210                                E4C3B1FC0F0E4170009693F6 /* LegacyTileCache.mm in Sources */,
    2921129211                                1AA7160A149BC4DB0016EC19 /* TileController.mm in Sources */,
    2921229212                                1F72BF0A187FD4490009BCB3 /* TileControllerMemoryHandlerIOS.cpp in Sources */,
    29213                                 E4B65A5A132FAAF90070E7BE /* TileGrid.mm in Sources */,
    29214                                 E424A3A01330DF1E00CF6DC9 /* TileGridTile.mm in Sources */,
    29215                                 E4B65A5E132FADB60070E7BE /* TileLayer.mm in Sources */,
    29216                                 E4E39AFD1330EFC6003AB274 /* TileLayerPool.mm in Sources */,
     29213                                E4B65A5A132FAAF90070E7BE /* LegacyTileGrid.mm in Sources */,
     29214                                E424A3A01330DF1E00CF6DC9 /* LegacyTileGridTile.mm in Sources */,
     29215                                E4B65A5E132FADB60070E7BE /* LegacyTileLayer.mm in Sources */,
     29216                                E4E39AFD1330EFC6003AB274 /* LegacyTileLayerPool.mm in Sources */,
    2921729217                                498770F21242C535002226BA /* TilingData.cpp in Sources */,
    2921829218                                F55B3DDB1251F12D003EF269 /* TimeInputType.cpp in Sources */,
  • trunk/Source/WebCore/page/FrameView.cpp

    r166372 r166529  
    9696#if PLATFORM(IOS)
    9797#include "DocumentLoader.h"
     98#include "LegacyTileCache.h"
    9899#include "Logging.h"
    99100#include "MemoryCache.h"
    100101#include "MemoryPressureHandler.h"
    101102#include "SystemMemory.h"
    102 #include "TileCache.h"
    103103#endif
    104104
     
    379379    // To avoid flashes of white, disable tile updates immediately when view is cleared at the beginning of a page load.
    380380    // Tiling will be re-enabled from UIKit via [WAKWindow setTilingMode:] when we have content to draw.
    381     if (TileCache* tileCache = this->tileCache())
    382         tileCache->setTilingMode(TileCache::Disabled);
     381    if (LegacyTileCache* tileCache = legacyTileCache())
     382        tileCache->setTilingMode(LegacyTileCache::Disabled);
    383383#endif
    384384}
     
    861861
    862862#if PLATFORM(IOS)
    863     if (TileCache* tileCache = this->tileCache())
     863    if (LegacyTileCache* tileCache = legacyTileCache())
    864864        tileCache->doPendingRepaints();
    865865#endif
     
    22442244        renderView->layer()->backing()->adjustTiledBackingCoverage();
    22452245#if PLATFORM(IOS)
    2246     if (TileCache* tileCache = this->tileCache())
     2246    if (LegacyTileCache* tileCache = legacyTileCache())
    22472247        tileCache->setSpeculativeTileCreationEnabled(m_speculativeTilingEnabled);
    22482248#endif
  • trunk/Source/WebCore/platform/ScrollView.h

    r166380 r166529  
    6161
    6262class HostWindow;
     63class LegacyTileCache;
    6364class Scrollbar;
    64 class TileCache;
    6565
    6666class ScrollView : public Widget, public ScrollableArea {
     
    191191
    192192    void setActualScrollPosition(const IntPoint&);
    193     TileCache* tileCache();
     193    LegacyTileCache* legacyTileCache();
    194194#endif
    195195
  • trunk/Source/WebCore/platform/ios/LegacyTileCache.h

    r166453 r166529  
    2424 */
    2525
    26 #ifndef TileCache_h
    27 #define TileCache_h
     26#ifndef LegacyTileCache_h
     27#define LegacyTileCache_h
    2828
    2929#if PLATFORM(IOS)
     
    4444#ifdef __OBJC__
    4545@class CALayer;
    46 @class TileCacheTombstone;
    47 @class TileLayer;
     46@class LegacyTileCacheTombstone;
     47@class LegacyTileLayer;
    4848@class WAKWindow;
    4949#else
    5050class CALayer;
    51 class TileCacheTombstone;
    52 class TileLayer;
     51class LegacyTileCacheTombstone;
     52class LegacyTileLayer;
    5353class WAKWindow;
    5454#endif
     
    5656namespace WebCore {
    5757
    58 class TileGrid;
    59 
    60 class TileCache {
    61     WTF_MAKE_NONCOPYABLE(TileCache);
     58class LegacyTileGrid;
     59
     60class LegacyTileCache {
     61    WTF_MAKE_NONCOPYABLE(LegacyTileCache);
    6262public:
    63     TileCache(WAKWindow*);
    64     ~TileCache();
     63    LegacyTileCache(WAKWindow*);
     64    ~LegacyTileCache();
    6565
    6666    CGFloat screenScale() const;
     
    135135    // Internal
    136136    void doLayoutTiles();
    137     void drawLayer(TileLayer*, CGContextRef);
     137    void drawLayer(LegacyTileLayer*, CGContextRef);
    138138    void prepareToDraw();
    139139    void finishedCreatingTiles(bool didCreateTiles, bool createMore);
    140140    FloatRect visibleRectInLayer(CALayer *) const;
    141141    CALayer* hostLayer() const;
    142     unsigned tileCapacityForGrid(TileGrid*);
    143     Color colorForGridTileBorder(TileGrid*) const;
     142    unsigned tileCapacityForGrid(LegacyTileGrid*);
     143    Color colorForGridTileBorder(LegacyTileGrid*) const;
    144144
    145145    void doPendingRepaints();
     
    151151
    152152private:
    153     TileGrid* activeTileGrid() const;
    154     TileGrid* inactiveTileGrid() const;
     153    LegacyTileGrid* activeTileGrid() const;
     154    LegacyTileGrid* inactiveTileGrid() const;
    155155
    156156    void updateTilingMode();
     
    167167    void scheduleLayerFlushForPendingRepaint();
    168168
    169     void tileCreationTimerFired(Timer<TileCache>*);
    170 
    171     void drawReplacementImage(TileLayer*, CGContextRef, CGImageRef);
    172     void drawWindowContent(TileLayer*, CGContextRef, CGRect dirtyRect);
     169    void tileCreationTimerFired(Timer<LegacyTileCache>*);
     170
     171    void drawReplacementImage(LegacyTileLayer*, CGContextRef, CGImageRef);
     172    void drawWindowContent(LegacyTileLayer*, CGContextRef, CGRect dirtyRect);
    173173
    174174    WAKWindow* m_window;
     
    181181    bool m_hasPendingUpdateTilingMode;
    182182    // Ensure there are no async calls on a dead tile cache.
    183     RetainPtr<TileCacheTombstone> m_tombstone;
     183    RetainPtr<LegacyTileCacheTombstone> m_tombstone;
    184184
    185185    TilingMode m_tilingMode;
     
    195195
    196196    bool m_didCallWillStartScrollingOrZooming;
    197     OwnPtr<TileGrid> m_zoomedOutTileGrid;
    198     OwnPtr<TileGrid> m_zoomedInTileGrid;
    199 
    200     Timer<TileCache> m_tileCreationTimer;
     197    OwnPtr<LegacyTileGrid> m_zoomedOutTileGrid;
     198    OwnPtr<LegacyTileGrid> m_zoomedInTileGrid;
     199
     200    Timer<LegacyTileCache> m_tileCreationTimer;
    201201
    202202    Vector<IntRect> m_savedDisplayRects;
  • trunk/Source/WebCore/platform/ios/LegacyTileCache.mm

    r166453 r166529  
    2525
    2626#include "config.h"
    27 #include "TileCache.h"
     27#include "LegacyTileCache.h"
    2828
    2929#if PLATFORM(IOS)
    3030
     31#include "LegacyTileGrid.h"
     32#include "LegacyTileGridTile.h"
     33#include "LegacyTileLayer.h"
     34#include "LegacyTileLayerPool.h"
    3135#include "Logging.h"
    3236#include "MemoryPressureHandler.h"
    3337#include "SystemMemory.h"
    34 #include "TileGrid.h"
    35 #include "TileGridTile.h"
    36 #include "TileLayer.h"
    37 #include "TileLayerPool.h"
    3838#include "WAKWindow.h"
    3939#include "WKGraphics.h"
     
    5252@end
    5353
    54 @interface TileCacheTombstone : NSObject {
     54@interface LegacyTileCacheTombstone : NSObject {
    5555    BOOL dead;
    5656}
     
    5959@end
    6060
    61 @implementation TileCacheTombstone
     61@implementation LegacyTileCacheTombstone
    6262
    6363@synthesize dead;
     
    6767namespace WebCore {
    6868
    69 TileCache::TileCache(WAKWindow* window)
     69LegacyTileCache::LegacyTileCache(WAKWindow* window)
    7070    : m_window(window)
    7171    , m_keepsZoomedOutTiles(false)
    7272    , m_hasPendingLayoutTiles(false)
    7373    , m_hasPendingUpdateTilingMode(false)
    74     , m_tombstone(adoptNS([[TileCacheTombstone alloc] init]))
     74    , m_tombstone(adoptNS([[LegacyTileCacheTombstone alloc] init]))
    7575    , m_tilingMode(Normal)
    7676    , m_tilingDirection(TilingDirectionDown)
     
    8282    , m_isSpeculativeTileCreationEnabled(true)
    8383    , m_didCallWillStartScrollingOrZooming(false)
    84     , m_zoomedOutTileGrid(PassOwnPtr<TileGrid>())
    85     , m_zoomedInTileGrid(PassOwnPtr<TileGrid>())
    86     , m_tileCreationTimer(this, &TileCache::tileCreationTimerFired)
     84    , m_zoomedOutTileGrid(PassOwnPtr<LegacyTileGrid>())
     85    , m_zoomedInTileGrid(PassOwnPtr<LegacyTileGrid>())
     86    , m_tileCreationTimer(this, &LegacyTileCache::tileCreationTimerFired)
    8787    , m_currentScale(1.f)
    8888    , m_pendingScale(0)
    8989    , m_pendingZoomedOutScale(0)
    9090{
    91     m_zoomedOutTileGrid = TileGrid::create(this, m_tileSize);
     91    m_zoomedOutTileGrid = LegacyTileGrid::create(this, m_tileSize);
    9292    [hostLayer() insertSublayer:m_zoomedOutTileGrid->tileHostLayer() atIndex:0];
    9393    hostLayerSizeChanged();
    9494}
    9595
    96 TileCache::~TileCache()
     96LegacyTileCache::~LegacyTileCache()
    9797{
    9898    [m_tombstone.get() setDead:true];
    9999}
    100100
    101 CGFloat TileCache::screenScale() const
     101CGFloat LegacyTileCache::screenScale() const
    102102{
    103103    return [m_window screenScale];
    104104}
    105105
    106 CALayer* TileCache::hostLayer() const
     106CALayer* LegacyTileCache::hostLayer() const
    107107{
    108108    return [m_window hostLayer];
    109109}
    110110
    111 FloatRect TileCache::visibleRectInLayer(CALayer *layer) const
     111FloatRect LegacyTileCache::visibleRectInLayer(CALayer *layer) const
    112112{
    113113    return [layer convertRect:[m_window extendedVisibleRect] fromLayer:hostLayer()];
    114114}
    115115
    116 bool TileCache::tilesOpaque() const
     116bool LegacyTileCache::tilesOpaque() const
    117117{
    118118    return m_tilesOpaque;
    119119}
    120120   
    121 TileGrid* TileCache::activeTileGrid() const
     121LegacyTileGrid* LegacyTileCache::activeTileGrid() const
    122122{
    123123    if (!m_keepsZoomedOutTiles)
     
    130130}
    131131
    132 TileGrid* TileCache::inactiveTileGrid() const
     132LegacyTileGrid* LegacyTileCache::inactiveTileGrid() const
    133133{
    134134    return activeTileGrid() == m_zoomedOutTileGrid ? m_zoomedInTileGrid.get() : m_zoomedOutTileGrid.get();
    135135}
    136136
    137 void TileCache::setTilesOpaque(bool opaque)
     137void LegacyTileCache::setTilesOpaque(bool opaque)
    138138{
    139139    if (m_tilesOpaque == opaque)
     
    148148}
    149149
    150 void TileCache::doLayoutTiles()
     150void LegacyTileCache::doLayoutTiles()
    151151{
    152152    if (isTileCreationSuspended())
     
    154154
    155155    MutexLocker locker(m_tileMutex);
    156     TileGrid* activeGrid = activeTileGrid();
     156    LegacyTileGrid* activeGrid = activeTileGrid();
    157157    // Even though we aren't actually creating tiles in the inactive grid, we
    158158    // still need to drop invalid tiles in response to a layout.
    159159    // See <rdar://problem/9839867>.
    160     if (TileGrid* inactiveGrid = inactiveTileGrid())
     160    if (LegacyTileGrid* inactiveGrid = inactiveTileGrid())
    161161        inactiveGrid->dropInvalidTiles();
    162162    if (activeGrid->checkDoSingleTileLayout())
     
    165165}
    166166
    167 void TileCache::hostLayerSizeChanged()
     167void LegacyTileCache::hostLayerSizeChanged()
    168168{
    169169    m_zoomedOutTileGrid->updateHostLayerSize();
     
    172172}
    173173
    174 void TileCache::setKeepsZoomedOutTiles(bool keep)
     174void LegacyTileCache::setKeepsZoomedOutTiles(bool keep)
    175175{
    176176    m_keepsZoomedOutTiles = keep;
    177177}
    178178
    179 void TileCache::setCurrentScale(float scale)
     179void LegacyTileCache::setCurrentScale(float scale)
    180180{
    181181    ASSERT(scale > 0);
     
    199199}
    200200
    201 void TileCache::setZoomedOutScale(float scale)
     201void LegacyTileCache::setZoomedOutScale(float scale)
    202202{
    203203    ASSERT(scale > 0);
     
    213213}
    214214   
    215 void TileCache::commitScaleChange()
     215void LegacyTileCache::commitScaleChange()
    216216{
    217217    ASSERT(m_pendingZoomedOutScale || m_pendingScale);
     
    242242    if (m_currentScale != m_zoomedOutTileGrid->scale()) {
    243243        if (!m_zoomedInTileGrid) {
    244             m_zoomedInTileGrid = TileGrid::create(this, m_tileSize);
     244            m_zoomedInTileGrid = LegacyTileGrid::create(this, m_tileSize);
    245245            [hostLayer() addSublayer:m_zoomedInTileGrid->tileHostLayer()];
    246246            hostLayerSizeChanged();
     
    257257}
    258258
    259 void TileCache::bringActiveTileGridToFront()
    260 {
    261     TileGrid* activeGrid = activeTileGrid();
    262     TileGrid* otherGrid = inactiveTileGrid();
     259void LegacyTileCache::bringActiveTileGridToFront()
     260{
     261    LegacyTileGrid* activeGrid = activeTileGrid();
     262    LegacyTileGrid* otherGrid = inactiveTileGrid();
    263263    if (!otherGrid)
    264264        return;
     
    268268}
    269269   
    270 void TileCache::adjustTileGridTransforms()
     270void LegacyTileCache::adjustTileGridTransforms()
    271271{
    272272    CALayer* zoomedOutHostLayer = m_zoomedOutTileGrid->tileHostLayer();
     
    276276}
    277277
    278 void TileCache::layoutTiles()
     278void LegacyTileCache::layoutTiles()
    279279{
    280280    if (m_hasPendingLayoutTiles)
     
    282282    m_hasPendingLayoutTiles = true;
    283283
    284     TileCacheTombstone *tombstone = m_tombstone.get();
     284    LegacyTileCacheTombstone *tombstone = m_tombstone.get();
    285285    WebThreadRun(^{
    286286        if ([tombstone isDead])
     
    291291}
    292292
    293 void TileCache::layoutTilesNow()
     293void LegacyTileCache::layoutTilesNow()
    294294{
    295295    ASSERT(WebThreadIsLockedOrDisabled());
     
    308308
    309309    MutexLocker locker(m_tileMutex);
    310     TileGrid* activeGrid = activeTileGrid();
     310    LegacyTileGrid* activeGrid = activeTileGrid();
    311311    if (activeGrid->checkDoSingleTileLayout()) {
    312312        m_tilingMode = savedTilingMode;
     
    317317}
    318318
    319 void TileCache::layoutTilesNowForRect(const IntRect& rect)
     319void LegacyTileCache::layoutTilesNowForRect(const IntRect& rect)
    320320{
    321321    ASSERT(WebThreadIsLockedOrDisabled());
     
    325325}
    326326
    327 void TileCache::removeAllNonVisibleTiles()
     327void LegacyTileCache::removeAllNonVisibleTiles()
    328328{
    329329    MutexLocker locker(m_tileMutex);
     
    331331}
    332332
    333 void TileCache::removeAllNonVisibleTilesInternal()
    334 {
    335     TileGrid* activeGrid = activeTileGrid();
     333void LegacyTileCache::removeAllNonVisibleTilesInternal()
     334{
     335    LegacyTileGrid* activeGrid = activeTileGrid();
    336336    if (keepsZoomedOutTiles() && activeGrid == m_zoomedInTileGrid && activeGrid->hasTiles())
    337337        m_zoomedOutTileGrid->dropAllTiles();
     
    347347}
    348348
    349 void TileCache::removeAllTiles()
     349void LegacyTileCache::removeAllTiles()
    350350{
    351351    MutexLocker locker(m_tileMutex);
     
    355355}
    356356
    357 void TileCache::removeForegroundTiles()
     357void LegacyTileCache::removeForegroundTiles()
    358358{
    359359    MutexLocker locker(m_tileMutex);
     
    364364}
    365365
    366 void TileCache::setContentReplacementImage(RetainPtr<CGImageRef> contentReplacementImage)
     366void LegacyTileCache::setContentReplacementImage(RetainPtr<CGImageRef> contentReplacementImage)
    367367{
    368368    MutexLocker locker(m_contentReplacementImageMutex);
     
    370370}
    371371
    372 RetainPtr<CGImageRef> TileCache::contentReplacementImage() const
     372RetainPtr<CGImageRef> LegacyTileCache::contentReplacementImage() const
    373373{
    374374    MutexLocker locker(m_contentReplacementImageMutex);
     
    376376}
    377377
    378 void TileCache::setTileBordersVisible(bool flag)
     378void LegacyTileCache::setTileBordersVisible(bool flag)
    379379{
    380380    if (flag == m_tileBordersVisible)
     
    387387}
    388388
    389 void TileCache::setTilePaintCountersVisible(bool flag)
     389void LegacyTileCache::setTilePaintCountersVisible(bool flag)
    390390{
    391391    m_tilePaintCountersVisible = flag;
     
    393393}
    394394
    395 void TileCache::finishedCreatingTiles(bool didCreateTiles, bool createMore)
     395void LegacyTileCache::finishedCreatingTiles(bool didCreateTiles, bool createMore)
    396396{
    397397    // We need to ensure that all tiles are showing the same version of the content.
     
    415415}
    416416
    417 void TileCache::tileCreationTimerFired(Timer<TileCache>*)
     417void LegacyTileCache::tileCreationTimerFired(Timer<LegacyTileCache>*)
    418418{
    419419    if (isTileCreationSuspended())
     
    423423}
    424424
    425 void TileCache::createTilesInActiveGrid(SynchronousTileCreationMode mode)
     425void LegacyTileCache::createTilesInActiveGrid(SynchronousTileCreationMode mode)
    426426{
    427427    if (memoryPressureHandler().hasReceivedMemoryPressure()) {
     
    432432}
    433433
    434 unsigned TileCache::tileCapacityForGrid(TileGrid* grid)
     434unsigned LegacyTileCache::tileCapacityForGrid(LegacyTileGrid* grid)
    435435{
    436436    static unsigned capacity;
     
    466466}
    467467
    468 Color TileCache::colorForGridTileBorder(TileGrid* grid) const
     468Color LegacyTileCache::colorForGridTileBorder(LegacyTileGrid* grid) const
    469469{
    470470    if (grid == m_zoomedOutTileGrid)
     
    501501}
    502502
    503 void TileCache::drawReplacementImage(TileLayer* layer, CGContextRef context, CGImageRef image)
     503void LegacyTileCache::drawReplacementImage(LegacyTileLayer* layer, CGContextRef context, CGImageRef image)
    504504{
    505505    CGContextSetRGBFillColor(context, 1, 1, 1, 1);
     
    513513}
    514514
    515 void TileCache::drawWindowContent(TileLayer* layer, CGContextRef context, CGRect dirtyRect)
     515void LegacyTileCache::drawWindowContent(LegacyTileLayer* layer, CGContextRef context, CGRect dirtyRect)
    516516{
    517517    CGRect frame = [layer frame];
     
    545545}
    546546
    547 void TileCache::drawLayer(TileLayer* layer, CGContextRef context)
     547void LegacyTileCache::drawLayer(LegacyTileLayer* layer, CGContextRef context)
    548548{
    549549    // The web lock unlock observer runs after CA commit observer.
     
    601601}
    602602
    603 void TileCache::setNeedsDisplay()
     603void LegacyTileCache::setNeedsDisplay()
    604604{
    605605    setNeedsDisplayInRect(IntRect(0, 0, std::numeric_limits<int>::max(), std::numeric_limits<int>::max()));
    606606}
    607607
    608 void TileCache::scheduleLayerFlushForPendingRepaint()
     608void LegacyTileCache::scheduleLayerFlushForPendingRepaint()
    609609{
    610610    WAKView* view = [m_window contentView];
     
    612612}
    613613
    614 void TileCache::setNeedsDisplayInRect(const IntRect& dirtyRect)
     614void LegacyTileCache::setNeedsDisplayInRect(const IntRect& dirtyRect)
    615615{
    616616    MutexLocker locker(m_savedDisplayRectMutex);
     
    623623}
    624624
    625 void TileCache::invalidateTiles(const IntRect& dirtyRect)
     625void LegacyTileCache::invalidateTiles(const IntRect& dirtyRect)
    626626{
    627627    ASSERT(!m_tileMutex.tryLock());
    628628
    629     TileGrid* activeGrid = activeTileGrid();
     629    LegacyTileGrid* activeGrid = activeTileGrid();
    630630    if (!keepsZoomedOutTiles()) {
    631631        activeGrid->invalidateTiles(dirtyRect);
     
    657657}
    658658   
    659 bool TileCache::isTileCreationSuspended() const
     659bool LegacyTileCache::isTileCreationSuspended() const
    660660{
    661661    return (!keepsZoomedOutTiles() && m_tilingMode == Zooming) || m_tilingMode == Disabled;
    662662}
    663663
    664 bool TileCache::isTileInvalidationSuspended() const
     664bool LegacyTileCache::isTileInvalidationSuspended() const
    665665{
    666666    return m_tilingMode == Zooming || m_tilingMode == Panning || m_tilingMode == ScrollToTop || m_tilingMode == Disabled;
    667667}
    668668
    669 void TileCache::updateTilingMode()
     669void LegacyTileCache::updateTilingMode()
    670670{
    671671    ASSERT(WebThreadIsCurrent() || !WebThreadIsEnabled());
     
    694694}
    695695
    696 void TileCache::setTilingMode(TilingMode tilingMode)
     696void LegacyTileCache::setTilingMode(TilingMode tilingMode)
    697697{
    698698    if (tilingMode == m_tilingMode)
     
    712712    m_hasPendingUpdateTilingMode = true;
    713713
    714     TileCacheTombstone *tombstone = m_tombstone.get();
     714    LegacyTileCacheTombstone *tombstone = m_tombstone.get();
    715715    WebThreadRun(^{
    716716        if ([tombstone isDead])
     
    721721}
    722722
    723 void TileCache::setTilingDirection(TilingDirection tilingDirection)
     723void LegacyTileCache::setTilingDirection(TilingDirection tilingDirection)
    724724{
    725725    m_tilingDirection = tilingDirection;
    726726}
    727727
    728 TileCache::TilingDirection TileCache::tilingDirection() const
     728LegacyTileCache::TilingDirection LegacyTileCache::tilingDirection() const
    729729{
    730730    return m_tilingDirection;
    731731}
    732732   
    733 float TileCache::zoomedOutScale() const
     733float LegacyTileCache::zoomedOutScale() const
    734734{
    735735    return m_zoomedOutTileGrid->scale();
    736736}
    737737
    738 float TileCache::currentScale() const
     738float LegacyTileCache::currentScale() const
    739739{
    740740    return m_currentScale;
    741741}
    742742
    743 void TileCache::doPendingRepaints()
     743void LegacyTileCache::doPendingRepaints()
    744744{
    745745    if (m_savedDisplayRects.isEmpty())
     
    751751}
    752752
    753 void TileCache::flushSavedDisplayRects()
     753void LegacyTileCache::flushSavedDisplayRects()
    754754{
    755755    ASSERT(!m_tileMutex.tryLock());
     
    766766}
    767767
    768 void TileCache::setSpeculativeTileCreationEnabled(bool enabled)
     768void LegacyTileCache::setSpeculativeTileCreationEnabled(bool enabled)
    769769{
    770770    if (m_isSpeculativeTileCreationEnabled == enabled)
     
    775775}
    776776
    777 bool TileCache::hasPendingDraw() const
     777bool LegacyTileCache::hasPendingDraw() const
    778778{
    779779    return !m_savedDisplayRects.isEmpty();
    780780}
    781781
    782 void TileCache::prepareToDraw()
     782void LegacyTileCache::prepareToDraw()
    783783{
    784784    // This will trigger document relayout if needed.
     
    791791}
    792792
    793 void TileCache::setLayerPoolCapacity(unsigned capacity)
    794 {
    795     TileLayerPool::sharedPool()->setCapacity(capacity);
    796 }
    797 
    798 void TileCache::drainLayerPool()
    799 {
    800     TileLayerPool::sharedPool()->drain();
    801 }
    802 
    803 void TileCache::dumpTiles()
     793void LegacyTileCache::setLayerPoolCapacity(unsigned capacity)
     794{
     795    LegacyTileLayerPool::sharedPool()->setCapacity(capacity);
     796}
     797
     798void LegacyTileCache::drainLayerPool()
     799{
     800    LegacyTileLayerPool::sharedPool()->drain();
     801}
     802
     803void LegacyTileCache::dumpTiles()
    804804{
    805805    NSLog(@"=================");
  • trunk/Source/WebCore/platform/ios/LegacyTileGrid.h

    r166453 r166529  
    2424 */
    2525
    26 #ifndef TileGrid_h
    27 #define TileGrid_h
     26#ifndef LegacyTileGrid_h
     27#define LegacyTileGrid_h
    2828
    2929#if PLATFORM(IOS)
     
    3333#include "IntRect.h"
    3434#include "IntSize.h"
    35 #include "TileCache.h"
     35#include "LegacyTileCache.h"
    3636#include <wtf/HashMap.h>
    3737#include <wtf/Noncopyable.h>
     
    4747namespace WebCore {
    4848
    49 class TileGridTile;
     49class LegacyTileGridTile;
    5050
    51 class TileGrid {
    52     WTF_MAKE_NONCOPYABLE(TileGrid);
     51class LegacyTileGrid {
     52    WTF_MAKE_NONCOPYABLE(LegacyTileGrid);
    5353public:
    5454    typedef IntPoint TileIndex;
    5555
    56     static PassOwnPtr<TileGrid> create(TileCache* cache, const IntSize& tileSize) { return adoptPtr(new TileGrid(cache, tileSize)); }
     56    static PassOwnPtr<LegacyTileGrid> create(LegacyTileCache* cache, const IntSize& tileSize) { return adoptPtr(new LegacyTileGrid(cache, tileSize)); }
    5757
    58     ~TileGrid();
     58    ~LegacyTileGrid();
    5959
    60     TileCache* tileCache() const { return m_tileCache; }
     60    LegacyTileCache* tileCache() const { return m_tileCache; }
    6161
    6262    CALayer *tileHostLayer() const;
     
    6969    IntRect visibleRect() const;
    7070
    71     void createTiles(TileCache::SynchronousTileCreationMode);
     71    void createTiles(LegacyTileCache::SynchronousTileCreationMode);
    7272
    7373    void dropAllTiles();
     
    103103    void addTileForIndex(const TileIndex&);
    104104
    105     PassRefPtr<TileGridTile> tileForIndex(const TileIndex&) const;
     105    PassRefPtr<LegacyTileGridTile> tileForIndex(const TileIndex&) const;
    106106    IntRect tileRectForIndex(const TileIndex&) const;
    107     PassRefPtr<TileGridTile> tileForPoint(const IntPoint&) const;
     107    PassRefPtr<LegacyTileGridTile> tileForPoint(const IntPoint&) const;
    108108    TileIndex tileIndexForPoint(const IntPoint&) const;
    109109
     
    112112
    113113private:       
    114     TileGrid(TileCache*, const IntSize&);
     114    LegacyTileGrid(LegacyTileCache*, const IntSize&);
    115115
    116     TileCache* m_tileCache;
     116    LegacyTileCache* m_tileCache;
    117117    RetainPtr<CALayer> m_tileHostLayer;
    118118
     
    122122    float m_scale;
    123123
    124     typedef HashMap<TileIndex, RefPtr<TileGridTile>> TileMap;
     124    typedef HashMap<TileIndex, RefPtr<LegacyTileGridTile>> TileMap;
    125125    TileMap m_tiles;
    126126
  • trunk/Source/WebCore/platform/ios/LegacyTileGrid.mm

    r166453 r166529  
    2525
    2626#include "config.h"
    27 #include "TileGrid.h"
     27#include "LegacyTileGrid.h"
    2828
    2929#if PLATFORM(IOS)
     
    3131#include "MemoryPressureHandler.h"
    3232#include "SystemMemory.h"
    33 #include "TileGridTile.h"
    34 #include "TileLayer.h"
    35 #include "TileLayerPool.h"
     33#include "LegacyTileGridTile.h"
     34#include "LegacyTileLayer.h"
     35#include "LegacyTileLayerPool.h"
    3636#include "WAKWindow.h"
    3737#include <CoreGraphics/CoreGraphicsPrivate.h>
     
    4343namespace WebCore {
    4444
    45 TileGrid::TileGrid(TileCache* tileCache, const IntSize& tileSize)
     45LegacyTileGrid::LegacyTileGrid(LegacyTileCache* tileCache, const IntSize& tileSize)
    4646    : m_tileCache(tileCache)
    47     , m_tileHostLayer(adoptNS([[TileHostLayer alloc] initWithTileGrid:this]))
     47    , m_tileHostLayer(adoptNS([[LegacyTileHostLayer alloc] initWithTileGrid:this]))
    4848    , m_tileSize(tileSize)
    4949    , m_scale(1)
     
    5252}
    5353   
    54 TileGrid::~TileGrid()
     54LegacyTileGrid::~LegacyTileGrid()
    5555{
    5656    [m_tileHostLayer removeFromSuperlayer];
    5757}
    5858
    59 IntRect TileGrid::visibleRect() const
     59IntRect LegacyTileGrid::visibleRect() const
    6060{
    6161    IntRect visibleRect = enclosingIntRect(m_tileCache->visibleRectInLayer(m_tileHostLayer.get()));
    6262
    6363    // When fast scrolling to the top, move the visible rect there immediately so we have tiles when the scrolling completes.
    64     if (m_tileCache->tilingMode() == TileCache::ScrollToTop)
     64    if (m_tileCache->tilingMode() == LegacyTileCache::ScrollToTop)
    6565        visibleRect.setY(0);
    6666
     
    6868}
    6969
    70 void TileGrid::dropAllTiles()
     70void LegacyTileGrid::dropAllTiles()
    7171{
    7272    m_tiles.clear();
    7373}
    7474
    75 void TileGrid::dropTilesIntersectingRect(const IntRect& dropRect)
     75void LegacyTileGrid::dropTilesIntersectingRect(const IntRect& dropRect)
    7676{
    7777    dropTilesBetweenRects(dropRect, IntRect());
    7878}
    7979
    80 void TileGrid::dropTilesOutsideRect(const IntRect& keepRect)
     80void LegacyTileGrid::dropTilesOutsideRect(const IntRect& keepRect)
    8181{
    8282    dropTilesBetweenRects(IntRect(0, 0, std::numeric_limits<int>::max(), std::numeric_limits<int>::max()), keepRect);
    8383}
    8484
    85 void TileGrid::dropTilesBetweenRects(const IntRect& dropRect, const IntRect& keepRect)
     85void LegacyTileGrid::dropTilesBetweenRects(const IntRect& dropRect, const IntRect& keepRect)
    8686{
    8787    Vector<TileIndex> toRemove;
     
    9797}
    9898
    99 unsigned TileGrid::tileByteSize() const
     99unsigned LegacyTileGrid::tileByteSize() const
    100100{
    101101    IntSize tilePixelSize = m_tileSize;
    102102    tilePixelSize.scale(m_tileCache->screenScale());
    103     return TileLayerPool::bytesBackingLayerWithPixelSize(tilePixelSize);
     103    return LegacyTileLayerPool::bytesBackingLayerWithPixelSize(tilePixelSize);
    104104}
    105105
     
    110110}
    111111
    112 bool TileGrid::dropDistantTiles(unsigned tilesNeeded, double shortestDistance)
     112bool LegacyTileGrid::dropDistantTiles(unsigned tilesNeeded, double shortestDistance)
    113113{
    114114    unsigned bytesPerTile = tileByteSize();
     
    148148}
    149149
    150 void TileGrid::addTilesCoveringRect(const IntRect& rectToCover)
     150void LegacyTileGrid::addTilesCoveringRect(const IntRect& rectToCover)
    151151{
    152152    // We never draw anything outside of our bounds.
     
    167167}
    168168
    169 void TileGrid::addTileForIndex(const TileIndex& index)
    170 {
    171     m_tiles.set(index, TileGridTile::create(this, tileRectForIndex(index)));
    172 }
    173 
    174 CALayer* TileGrid::tileHostLayer() const
     169void LegacyTileGrid::addTileForIndex(const TileIndex& index)
     170{
     171    m_tiles.set(index, LegacyTileGridTile::create(this, tileRectForIndex(index)));
     172}
     173
     174CALayer* LegacyTileGrid::tileHostLayer() const
    175175{
    176176    return m_tileHostLayer.get();
    177177}
    178178
    179 IntRect TileGrid::bounds() const
     179IntRect LegacyTileGrid::bounds() const
    180180{
    181181    return IntRect(IntPoint(), IntSize([tileHostLayer() size]));
    182182}
    183183
    184 PassRefPtr<TileGridTile> TileGrid::tileForIndex(const TileIndex& index) const
     184PassRefPtr<LegacyTileGridTile> LegacyTileGrid::tileForIndex(const TileIndex& index) const
    185185{
    186186    return m_tiles.get(index);
    187187}
    188188
    189 IntRect TileGrid::tileRectForIndex(const TileIndex& index) const
     189IntRect LegacyTileGrid::tileRectForIndex(const TileIndex& index) const
    190190{
    191191    IntRect rect(index.x() * m_tileSize.width() - (m_origin.x() ? m_tileSize.width() - m_origin.x() : 0),
     
    197197}
    198198
    199 TileGrid::TileIndex TileGrid::tileIndexForPoint(const IntPoint& point) const
     199LegacyTileGrid::TileIndex LegacyTileGrid::tileIndexForPoint(const IntPoint& point) const
    200200{
    201201    ASSERT(m_origin.x() < m_tileSize.width());
     
    206206}
    207207
    208 void TileGrid::centerTileGridOrigin(const IntRect& visibleRect)
     208void LegacyTileGrid::centerTileGridOrigin(const IntRect& visibleRect)
    209209{
    210210    if (visibleRect.isEmpty())
     
    242242}
    243243
    244 PassRefPtr<TileGridTile> TileGrid::tileForPoint(const IntPoint& point) const
     244PassRefPtr<LegacyTileGridTile> LegacyTileGrid::tileForPoint(const IntPoint& point) const
    245245{
    246246    return tileForIndex(tileIndexForPoint(point));
    247247}
    248248
    249 bool TileGrid::tilesCover(const IntRect& rect) const
     249bool LegacyTileGrid::tilesCover(const IntRect& rect) const
    250250{
    251251    return tileForPoint(rect.location()) && tileForPoint(IntPoint(rect.maxX() - 1, rect.y())) &&
     
    253253}
    254254
    255 void TileGrid::updateTileOpacity()
     255void LegacyTileGrid::updateTileOpacity()
    256256{
    257257    TileMap::iterator end = m_tiles.end();
     
    260260}
    261261
    262 void TileGrid::updateTileBorderVisibility()
     262void LegacyTileGrid::updateTileBorderVisibility()
    263263{
    264264    TileMap::iterator end = m_tiles.end();
     
    267267}
    268268
    269 unsigned TileGrid::tileCount() const
     269unsigned LegacyTileGrid::tileCount() const
    270270{
    271271    return m_tiles.size();
    272272}
    273273
    274 bool TileGrid::checkDoSingleTileLayout()
     274bool LegacyTileGrid::checkDoSingleTileLayout()
    275275{
    276276    IntSize size = bounds().size();
     
    292292    TileIndex originIndex(0, 0);
    293293    if (!m_tiles.get(originIndex))
    294         m_tiles.set(originIndex, TileGridTile::create(this, tileRectForIndex(originIndex)));
     294        m_tiles.set(originIndex, LegacyTileGridTile::create(this, tileRectForIndex(originIndex)));
    295295
    296296    return true;
    297297}
    298298
    299 void TileGrid::updateHostLayerSize()
     299void LegacyTileGrid::updateHostLayerSize()
    300300{
    301301    CALayer* hostLayer = m_tileCache->hostLayer();
     
    312312}
    313313
    314 void TileGrid::dropInvalidTiles()
     314void LegacyTileGrid::dropInvalidTiles()
    315315{
    316316    IntRect bounds = this->bounds();
     
    331331}
    332332
    333 void TileGrid::invalidateTiles(const IntRect& dirtyRect)
     333void LegacyTileGrid::invalidateTiles(const IntRect& dirtyRect)
    334334{
    335335    if (!hasTiles())
     
    350350        TileMap::iterator end = m_tiles.end();
    351351        for (TileMap::iterator it = m_tiles.begin(); it != end; ++it) {
    352             TileGridTile* tile = it->value.get();
     352            LegacyTileGridTile* tile = it->value.get();
    353353            if (!tile->rect().intersects(dirtyRect))
    354354               continue;
     
    362362            for (int xIndex = topLeftIndex.x(); xIndex <= bottomRightIndex.x(); ++xIndex) {
    363363                TileIndex index(xIndex, yIndex);
    364                 RefPtr<TileGridTile> tile = tileForIndex(index);
     364                RefPtr<LegacyTileGridTile> tile = tileForIndex(index);
    365365                if (!tile)
    366366                    continue;
     
    377377    if (!shouldUseMinimalTileCoverage())
    378378        return;
    379     if (m_tileCache->tilingMode() != TileCache::Minimal && m_tileCache->tilingMode() != TileCache::Normal)
     379    if (m_tileCache->tilingMode() != LegacyTileCache::Minimal && m_tileCache->tilingMode() != LegacyTileCache::Normal)
    380380        return;
    381381    IntRect visibleRect = this->visibleRect();
    382382    unsigned count = invalidatedTiles.size();
    383383    for (unsigned i = 0; i < count; ++i) {
    384         RefPtr<TileGridTile> tile = tileForIndex(invalidatedTiles[i]);
     384        RefPtr<LegacyTileGridTile> tile = tileForIndex(invalidatedTiles[i]);
    385385        if (!tile->rect().intersects(visibleRect))
    386386            m_tiles.remove(invalidatedTiles[i]);
     
    388388}
    389389
    390 bool TileGrid::shouldUseMinimalTileCoverage() const
    391 {
    392     return m_tileCache->tilingMode() == TileCache::Minimal
     390bool LegacyTileGrid::shouldUseMinimalTileCoverage() const
     391{
     392    return m_tileCache->tilingMode() == LegacyTileCache::Minimal
    393393        || !m_tileCache->isSpeculativeTileCreationEnabled()
    394394        || memoryPressureHandler().hasReceivedMemoryPressure();
    395395}
    396396
    397 IntRect TileGrid::adjustCoverRectForPageBounds(const IntRect& rect) const
     397IntRect LegacyTileGrid::adjustCoverRectForPageBounds(const IntRect& rect) const
    398398{
    399399    // Adjust the rect so that it stays within the bounds and keeps the pixel size.
     
    415415}
    416416
    417 IntRect TileGrid::calculateCoverRect(const IntRect& visibleRect, bool& centerGrid)
     417IntRect LegacyTileGrid::calculateCoverRect(const IntRect& visibleRect, bool& centerGrid)
    418418{
    419419    // Use minimum coverRect if we are under memory pressure.
     
    429429}
    430430
    431 double TileGrid::tileDistance2(const IntRect& visibleRect, const IntRect& tileRect) const
     431double LegacyTileGrid::tileDistance2(const IntRect& visibleRect, const IntRect& tileRect) const
    432432{
    433433    // The "distance" calculated here is used to pick which tile to cache next. The idea is to create those
     
    451451
    452452    switch (m_tileCache->tilingDirection()) {
    453     case TileCache::TilingDirectionUp:
     453    case LegacyTileCache::TilingDirectionUp:
    454454        verticalBias = tilingBiasVeryLikely;
    455455        upwardBias = tilingBiasLikely;
    456456        break;
    457     case TileCache::TilingDirectionDown:
     457    case LegacyTileCache::TilingDirectionDown:
    458458        verticalBias = tilingBiasVeryLikely;
    459459        downwardBias = tilingBiasLikely;
    460460        break;
    461     case TileCache::TilingDirectionLeft:
     461    case LegacyTileCache::TilingDirectionLeft:
    462462        horizontalBias = tilingBiasVeryLikely;
    463463        leftwardBias = tilingBiasLikely;
    464464        break;
    465     case TileCache::TilingDirectionRight:
     465    case LegacyTileCache::TilingDirectionRight:
    466466        horizontalBias = tilingBiasVeryLikely;
    467467        rightwardBias = tilingBiasLikely;
     
    479479}
    480480
    481 void TileGrid::createTiles(TileCache::SynchronousTileCreationMode creationMode)
     481void LegacyTileGrid::createTiles(LegacyTileCache::SynchronousTileCreationMode creationMode)
    482482{
    483483    IntRect visibleRect = this->visibleRect();
     
    499499    double shortestDistance = std::numeric_limits<double>::infinity();
    500500    double coveredDistance = 0;
    501     Vector<TileGrid::TileIndex> tilesToCreate;
     501    Vector<LegacyTileGrid::TileIndex> tilesToCreate;
    502502    unsigned pendingTileCount = 0;
    503503
    504     TileGrid::TileIndex topLeftIndex = tileIndexForPoint(topLeft(coverRect));
    505     TileGrid::TileIndex bottomRightIndex = tileIndexForPoint(bottomRight(coverRect));
     504    LegacyTileGrid::TileIndex topLeftIndex = tileIndexForPoint(topLeft(coverRect));
     505    LegacyTileGrid::TileIndex bottomRightIndex = tileIndexForPoint(bottomRight(coverRect));
    506506    for (int yIndex = topLeftIndex.y(); yIndex <= bottomRightIndex.y(); ++yIndex) {
    507507        for (int xIndex = topLeftIndex.x(); xIndex <= bottomRightIndex.x(); ++xIndex) {
    508             TileGrid::TileIndex index(xIndex, yIndex);
     508            LegacyTileGrid::TileIndex index(xIndex, yIndex);
    509509            // Currently visible tiles have distance of 0 and get all created in the same transaction.
    510510            double distance = tileDistance2(visibleRect, tileRectForIndex(index));
     
    528528    // Tile creation timer will invoke this function again in CoverSpeculative mode.
    529529    bool candidateTilesAreSpeculative = shortestDistance > 0;
    530     if (creationMode == TileCache::CoverVisibleOnly && candidateTilesAreSpeculative)
     530    if (creationMode == LegacyTileCache::CoverVisibleOnly && candidateTilesAreSpeculative)
    531531        tilesToCreateCount = 0;
    532532
     
    549549}
    550550
    551 void TileGrid::dumpTiles()
     551void LegacyTileGrid::dumpTiles()
    552552{
    553553    IntRect visibleRect = this->visibleRect();
  • trunk/Source/WebCore/platform/ios/LegacyTileGridTile.h

    r166453 r166529  
    2424 */
    2525
    26 #ifndef TileGridTile_h
    27 #define TileGridTile_h
     26#ifndef LegacyTileGridTile_h
     27#define LegacyTileGridTile_h
    2828
    2929#if PLATFORM(IOS)
     
    3434#include <wtf/RetainPtr.h>
    3535
    36 @class TileLayer;
     36@class LegacyTileLayer;
    3737
    3838namespace WebCore {
    3939
    40 class TileGrid;
     40class LegacyTileGrid;
    4141
    4242// Refcount the tiles so they work nicely in vector and we know when to remove the tile layer from the parent.
    43 class TileGridTile : public RefCounted<TileGridTile> {
     43class LegacyTileGridTile : public RefCounted<LegacyTileGridTile> {
    4444public:
    45     static PassRefPtr<TileGridTile> create(TileGrid* grid, const IntRect& rect) { return adoptRef<TileGridTile>(new TileGridTile(grid, rect)); }
    46     ~TileGridTile();
     45    static PassRefPtr<LegacyTileGridTile> create(LegacyTileGrid* grid, const IntRect& rect) { return adoptRef<LegacyTileGridTile>(new LegacyTileGridTile(grid, rect)); }
     46    ~LegacyTileGridTile();
    4747
    48     TileLayer* tileLayer() const { return m_tileLayer.get(); }
     48    LegacyTileLayer* tileLayer() const { return m_tileLayer.get(); }
    4949    void invalidateRect(const IntRect& rectInSurface);
    5050    IntRect rect() const { return m_rect; }
     
    5353
    5454private:
    55     TileGridTile(TileGrid*, const IntRect&);
     55    LegacyTileGridTile(LegacyTileGrid*, const IntRect&);
    5656
    57     TileGrid* m_tileGrid;
    58     RetainPtr<TileLayer> m_tileLayer;
     57    LegacyTileGrid* m_tileGrid;
     58    RetainPtr<LegacyTileLayer> m_tileLayer;
    5959    IntRect m_rect;
    6060};
     
    6363
    6464#endif // PLATFORM(IOS)
    65 #endif // TileGridTile_h
     65#endif // LegacyTileGridTile_h
  • trunk/Source/WebCore/platform/ios/LegacyTileGridTile.mm

    r166453 r166529  
    2525
    2626#include "config.h"
    27 #include "TileGrid.h"
     27#include "LegacyTileGridTile.h"
    2828
    2929#if PLATFORM(IOS)
    3030
    3131#include "Color.h"
    32 #include "TileCache.h"
    33 #include "TileGridTile.h"
    34 #include "TileLayer.h"
    35 #include "TileLayerPool.h"
     32#include "LegacyTileCache.h"
     33#include "LegacyTileGrid.h"
     34#include "LegacyTileLayer.h"
     35#include "LegacyTileLayerPool.h"
    3636#include "WAKWindow.h"
    3737#include <QuartzCore/QuartzCore.h>
     
    4646#endif
    4747
    48 TileGridTile::TileGridTile(TileGrid* tileGrid, const IntRect& tileRect)
     48LegacyTileGridTile::LegacyTileGridTile(LegacyTileGrid* tileGrid, const IntRect& tileRect)
    4949    : m_tileGrid(tileGrid)
    5050    , m_rect(tileRect)
     
    5454    const CGFloat screenScale = m_tileGrid->tileCache()->screenScale();
    5555    pixelSize.scale(screenScale);
    56     m_tileLayer = TileLayerPool::sharedPool()->takeLayerWithSize(pixelSize);
     56    m_tileLayer = LegacyTileLayerPool::sharedPool()->takeLayerWithSize(pixelSize);
    5757    if (!m_tileLayer) {
    5858#if LOG_TILING
    5959        NSLog(@"unable to reuse layer with size %d x %d, creating one", pixelSize.width(), pixelSize.height());
    6060#endif
    61         m_tileLayer = adoptNS([[TileLayer alloc] init]);
     61        m_tileLayer = adoptNS([[LegacyTileLayer alloc] init]);
    6262    }
    63     TileLayer* layer = m_tileLayer.get();
     63    LegacyTileLayer* layer = m_tileLayer.get();
    6464    [layer setTileGrid:tileGrid];
    6565    [layer setOpaque:m_tileGrid->tileCache()->tilesOpaque()];
     
    8282}
    8383
    84 TileGridTile::~TileGridTile()
     84LegacyTileGridTile::~LegacyTileGridTile()
    8585{
    8686    [tileLayer() setTileGrid:0];
    8787    [tileLayer() removeFromSuperlayer];
    88     TileLayerPool::sharedPool()->addLayer(tileLayer());
     88    LegacyTileLayerPool::sharedPool()->addLayer(tileLayer());
    8989#if LOG_TILING
    9090    --totalTileCount;
     
    9393}
    9494
    95 void TileGridTile::invalidateRect(const IntRect& windowDirtyRect)
     95void LegacyTileGridTile::invalidateRect(const IntRect& windowDirtyRect)
    9696{
    9797    IntRect dirtyRect = intersection(windowDirtyRect, m_rect);
     
    105105}
    106106
    107 void TileGridTile::setRect(const IntRect& tileRect)
     107void LegacyTileGridTile::setRect(const IntRect& tileRect)
    108108{
    109109    if (m_rect == tileRect)
    110110        return;
    111111    m_rect = tileRect;
    112     TileLayer* layer = m_tileLayer.get();
     112    LegacyTileLayer* layer = m_tileLayer.get();
    113113    [layer setFrame:m_rect];
    114114    [layer setNeedsDisplay];
    115115}
    116116
    117 void TileGridTile::showBorder(bool flag)
     117void LegacyTileGridTile::showBorder(bool flag)
    118118{
    119     TileLayer* layer = m_tileLayer.get();
     119    LegacyTileLayer* layer = m_tileLayer.get();
    120120    if (flag) {
    121121        [layer setBorderColor:cachedCGColor(m_tileGrid->tileCache()->colorForGridTileBorder(m_tileGrid), ColorSpaceDeviceRGB)];
  • trunk/Source/WebCore/platform/ios/LegacyTileLayer.h

    r166453 r166529  
    2424 */
    2525
    26 #ifndef TileLayer_h
    27 #define TileLayer_h
     26#ifndef LegacyTileLayer_h
     27#define LegacyTileLayer_h
    2828
    2929#if PLATFORM(IOS)
     
    3232
    3333namespace WebCore {
    34 class TileGrid;
     34class LegacyTileGrid;
    3535};
    3636
    37 @interface TileLayer : CALayer {
    38     WebCore::TileGrid* _tileGrid;
     37@interface LegacyTileLayer : CALayer {
     38    WebCore::LegacyTileGrid* _tileGrid;
    3939    unsigned _paintCount;
    4040}
    4141@property (nonatomic) unsigned paintCount;
    42 @property (nonatomic) WebCore::TileGrid* tileGrid;
    43 + (TileLayer *)layerBeingPainted;
     42@property (nonatomic) WebCore::LegacyTileGrid* tileGrid;
     43+ (LegacyTileLayer *)layerBeingPainted;
    4444@end
    4545
    46 @interface TileHostLayer : CALayer {
    47     WebCore::TileGrid* _tileGrid;
     46@interface LegacyTileHostLayer : CALayer {
     47    WebCore::LegacyTileGrid* _tileGrid;
    4848}
    49 - (id)initWithTileGrid:(WebCore::TileGrid*)tileGrid;
     49- (id)initWithTileGrid:(WebCore::LegacyTileGrid*)tileGrid;
    5050@end
    5151
  • trunk/Source/WebCore/platform/ios/LegacyTileLayer.mm

    r166453 r166529  
    2525
    2626#include "config.h"
    27 #include "TileLayer.h"
     27#include "LegacyTileLayer.h"
    2828
    2929#if PLATFORM(IOS)
    3030
    31 #include "TileCache.h"
    32 #include "TileGrid.h"
     31#include "LegacyTileCache.h"
     32#include "LegacyTileGrid.h"
    3333#include "WebCoreThread.h"
    3434
    35 @implementation TileHostLayer
    36 - (id)initWithTileGrid:(WebCore::TileGrid*)tileGrid
     35@implementation LegacyTileHostLayer
     36- (id)initWithTileGrid:(WebCore::LegacyTileGrid*)tileGrid
    3737{
    3838    self = [super init];
     
    6060@end
    6161
    62 @implementation TileLayer
     62@implementation LegacyTileLayer
    6363@synthesize paintCount = _paintCount;
    6464@synthesize tileGrid = _tileGrid;
    6565
    66 static TileLayer *layerBeingPainted;
     66static LegacyTileLayer *layerBeingPainted;
    6767
    6868- (void)setNeedsDisplayInRect:(CGRect)rect
     
    9494}
    9595
    96 + (TileLayer *)layerBeingPainted
     96+ (LegacyTileLayer *)layerBeingPainted
    9797{
    9898    return layerBeingPainted;
  • trunk/Source/WebCore/platform/ios/LegacyTileLayerPool.h

    r166453 r166529  
    2424 */
    2525
    26 #ifndef TileLayerPool_h
    27 #define TileLayerPool_h
     26#ifndef LegacyTileLayerPool_h
     27#define LegacyTileLayerPool_h
    2828
    2929#if PLATFORM(IOS)
     
    4040#include <wtf/Vector.h>
    4141
    42 @class TileLayer;
     42@class LegacyTileLayer;
    4343
    4444namespace WebCore {
    4545
    46 class TileLayerPool {
    47     WTF_MAKE_NONCOPYABLE(TileLayerPool);
     46class LegacyTileLayerPool {
     47    WTF_MAKE_NONCOPYABLE(LegacyTileLayerPool);
    4848public:
    49     static TileLayerPool* sharedPool();
     49    static LegacyTileLayerPool* sharedPool();
    5050
    51     void addLayer(const RetainPtr<TileLayer>&);
    52     RetainPtr<TileLayer> takeLayerWithSize(const IntSize&);
     51    void addLayer(const RetainPtr<LegacyTileLayer>&);
     52    RetainPtr<LegacyTileLayer> takeLayerWithSize(const IntSize&);
    5353
    5454    // The maximum size of all queued layers in bytes.
     
    6262
    6363private:
    64     TileLayerPool();
     64    LegacyTileLayerPool();
    6565
    66     typedef Deque<RetainPtr<TileLayer> > LayerList;
     66    typedef Deque<RetainPtr<LegacyTileLayer> > LayerList;
    6767
    6868    bool canReuseLayerWithSize(const IntSize& size) const { return m_capacity && !size.isEmpty(); }
     
    8282    bool m_needsPrune;
    8383
    84     friend NeverDestroyed<TileLayerPool>;
     84    friend NeverDestroyed<LegacyTileLayerPool>;
    8585};
    8686
  • trunk/Source/WebCore/platform/ios/LegacyTileLayerPool.mm

    r166453 r166529  
    2525
    2626#include "config.h"
    27 #include "TileLayerPool.h"
     27#include "LegacyTileLayerPool.h"
    2828
    2929#if PLATFORM(IOS)
    3030
     31#include "LegacyTileLayer.h"
     32#include "LegacyTileGrid.h"
    3133#include "Logging.h"
    3234#include "MemoryPressureHandler.h"
    33 #include "TileLayer.h"
    34 #include "TileGrid.h"
    3535#include <wtf/CurrentTime.h>
    3636#include <wtf/NeverDestroyed.h>
     
    4040static const double capacityDecayTime = 5;
    4141
    42 TileLayerPool::TileLayerPool()
     42LegacyTileLayerPool::LegacyTileLayerPool()
    4343    : m_totalBytes(0)
    4444    , m_capacity(0)
     
    4848}
    4949
    50 TileLayerPool* TileLayerPool::sharedPool()
     50LegacyTileLayerPool* LegacyTileLayerPool::sharedPool()
    5151{
    52     static NeverDestroyed<TileLayerPool> sharedPool;
     52    static NeverDestroyed<LegacyTileLayerPool> sharedPool;
    5353    return &sharedPool.get();
    5454}
    5555
    56 unsigned TileLayerPool::bytesBackingLayerWithPixelSize(const IntSize& size)
     56unsigned LegacyTileLayerPool::bytesBackingLayerWithPixelSize(const IntSize& size)
    5757{
    5858    return size.width() * size.height() * 4;
    5959}
    6060
    61 TileLayerPool::LayerList& TileLayerPool::listOfLayersWithSize(const IntSize& size, AccessType accessType)
     61LegacyTileLayerPool::LayerList& LegacyTileLayerPool::listOfLayersWithSize(const IntSize& size, AccessType accessType)
    6262{
    6363    ASSERT(!m_layerPoolMutex.tryLock());
     
    7373}
    7474
    75 void TileLayerPool::addLayer(const RetainPtr<TileLayer>& layer)
     75void LegacyTileLayerPool::addLayer(const RetainPtr<LegacyTileLayer>& layer)
    7676{
    7777    IntSize layerSize([layer.get() frame].size);
     
    9393}
    9494
    95 RetainPtr<TileLayer> TileLayerPool::takeLayerWithSize(const IntSize& size)
     95RetainPtr<LegacyTileLayer> LegacyTileLayerPool::takeLayerWithSize(const IntSize& size)
    9696{
    9797    if (!canReuseLayerWithSize(size))
     
    105105}
    106106
    107 void TileLayerPool::setCapacity(unsigned capacity)
     107void LegacyTileLayerPool::setCapacity(unsigned capacity)
    108108{
    109109    MutexLocker reuseLocker(m_layerPoolMutex);
     
    113113}
    114114   
    115 unsigned TileLayerPool::decayedCapacity() const
     115unsigned LegacyTileLayerPool::decayedCapacity() const
    116116{
    117117    // Decay to one quarter over capacityDecayTime
     
    123123}
    124124
    125 void TileLayerPool::schedulePrune()
     125void LegacyTileLayerPool::schedulePrune()
    126126{
    127127    ASSERT(!m_layerPoolMutex.tryLock());
     
    135135}
    136136
    137 void TileLayerPool::prune()
     137void LegacyTileLayerPool::prune()
    138138{
    139139    MutexLocker locker(m_layerPoolMutex);
     
    162162}
    163163
    164 void TileLayerPool::drain()
     164void LegacyTileLayerPool::drain()
    165165{
    166166    MutexLocker reuseLocker(m_layerPoolMutex);
  • trunk/Source/WebCore/platform/ios/ScrollViewIOS.mm

    r166394 r166529  
    237237}
    238238
    239 TileCache* ScrollView::tileCache()
     239LegacyTileCache* ScrollView::legacyTileCache()
    240240{
    241241    // Make tile cache pointer available via the main frame only. Tile cache interaction should be managed by
  • trunk/Source/WebCore/platform/ios/wak/WAKWindow.h

    r161603 r166529  
    4141#ifdef __cplusplus
    4242namespace WebCore {
    43     class TileCache;
     43    class LegacyTileCache;
    4444}
    45 typedef WebCore::TileCache TileCache;
     45typedef WebCore::LegacyTileCache LegacyTileCache;
    4646#else
    47 typedef struct TileCache TileCache;
     47typedef struct LegacyTileCache LegacyTileCache;
    4848#endif
    4949
     
    7070{
    7171    CALayer* _hostLayer;
    72     TileCache* _tileCache;
     72    LegacyTileCache* _tileCache;
    7373    CGRect _frozenVisibleRect;
    7474    CALayer *_rootLayer;
     
    161161- (void)setKeepsZoomedOutTiles:(BOOL)keepsZoomedOutTiles;
    162162- (BOOL)keepsZoomedOutTiles;
    163 - (TileCache *)tileCache;
     163- (LegacyTileCache *)tileCache;
    164164
    165165- (void)dumpTiles;
  • trunk/Source/WebCore/platform/ios/wak/WAKWindow.mm

    r161603 r166529  
    2929#if PLATFORM(IOS)
    3030
    31 #import "TileCache.h"
     31#import "LegacyTileCache.h"
    3232#import "WAKViewPrivate.h"
    3333#import "WebCoreSystemInterface.h"
     
    7474    _screenScale = wkGetScreenScaleFactor();
    7575   
    76     _tileCache = new TileCache(self);
     76    _tileCache = new LegacyTileCache(self);
    7777
    7878    _frozenVisibleRect = CGRectNull;
     
    485485    if (!_tileCache)
    486486        return;
    487     _tileCache->setTilingMode((TileCache::TilingMode)mode);
     487    _tileCache->setTilingMode((LegacyTileCache::TilingMode)mode);
    488488}
    489489
     
    499499    if (!_tileCache)
    500500        return;
    501     _tileCache->setTilingDirection((TileCache::TilingDirection)tilingDirection);
     501    _tileCache->setTilingDirection((LegacyTileCache::TilingDirection)tilingDirection);
    502502}
    503503
     
    551551}
    552552
    553 - (TileCache*)tileCache
     553- (LegacyTileCache*)tileCache
    554554{
    555555    return _tileCache;
  • trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

    r166489 r166529  
    6767
    6868#if PLATFORM(IOS)
     69#include "LegacyTileCache.h"
    6970#include "MainFrame.h"
    7071#include "Region.h"
    7172#include "RenderScrollbar.h"
    72 #include "TileCache.h"
    7373#endif
    7474
     
    26822682{
    26832683#if PLATFORM(IOS)
    2684     TileCache* tileCache = nullptr;
     2684    LegacyTileCache* tileCache = nullptr;
    26852685    if (Page* page = this->page()) {
    26862686        if (FrameView* frameView = page->mainFrame().view())
    2687             tileCache = frameView->tileCache();
     2687            tileCache = frameView->legacyTileCache();
    26882688    }
    26892689
     
    26912691        return 1;
    26922692
    2693     return tileCache->tilingMode() == TileCache::Zooming ? 0.125 : 1;
     2693    return tileCache->tilingMode() == LegacyTileCache::Zooming ? 0.125 : 1;
    26942694#else
    26952695    return 1;
  • trunk/Source/WebKit/mac/ChangeLog

    r166448 r166529  
     12014-03-31  Antti Koivisto  <antti@apple.com>
     2
     3        Rename TileCache to LegacyTileCache
     4        https://bugs.webkit.org/show_bug.cgi?id=130986
     5
     6        Reviewed by Simon Fraser.
     7
     8        * WebView/WebView.mm:
     9        (+[WebView drainLayerPool]):
     10        (+[WebView _setTileCacheLayerPoolCapacity:]):
     11
    1122014-03-28  Darin Adler  <darin@apple.com>
    213
  • trunk/Source/WebKit/mac/WebView/WebView.mm

    r166378 r166529  
    233233#import <WebCore/GraphicsLayer.h>
    234234#import <WebCore/IconController.h>
     235#import <WebCore/LegacyTileCache.h>
    235236#import <WebCore/NetworkStateNotifier.h>
    236237#import <WebCore/RuntimeApplicationChecksIOS.h>
     
    238239#import <WebCore/SmartReplace.h>
    239240#import <WebCore/TextRun.h>
    240 #import <WebCore/TileCache.h>
    241241#import <WebCore/TileControllerMemoryHandlerIOS.h>
    242242#import <WebCore/WAKWindow.h>
     
    13311331    ASSERT(WebThreadIsCurrent());
    13321332    WebKit::MemoryMeasure measurer("Memory warning: Draining layer pool.");
    1333     WebCore::TileCache::drainLayerPool();
     1333    WebCore::LegacyTileCache::drainLayerPool();
    13341334}
    13351335
     
    45504550+ (void)_setTileCacheLayerPoolCapacity:(unsigned)capacity
    45514551{
    4552     TileCache::setLayerPoolCapacity(capacity);
     4552    LegacyTileCache::setLayerPoolCapacity(capacity);
    45534553}
    45544554#endif // PLATFORM(IOS)
Note: See TracChangeset for help on using the changeset viewer.