ChangeLog

2013-10-24  Tim Horton  <timothy_horton@apple.com>

        Make TileController manipulate PlatformCALayers instead of CALayers

        https://bugs.webkit.org/show_bug.cgi?id=123279

        Reviewed by NOBODY (OOPS!).

        In the interest of making TileController more platform-independent

        (so that it can be used with the remote layer tree, and maybe Windows),

        move TileController onto our PlatformCALayer abstraction instead of

        direct manipulation of CALayers.

        Some fallout from this includes getting rid of special Mac-specific

        TileController-specific CALayer subclasses, and reworking tile

        painting to work in a more generic way.

        This is a first step, and doesn't get us all the way to a platform independent

        TileController, but more patches are forthcoming.

        No new tests, just a (largeish) refactor.

        * WebCore.exp.in:

        The signature of some methods has changed.

        * WebCore.xcodeproj/project.pbxproj:

        Remove WebTileLayer.*

        * page/scrolling/mac/ScrollingTreeScrollingNodeMac.mm:

        (WebCore::ScrollingTreeScrollingNodeMac::logExposedUnfilledArea):

        Use the "isTile" key on the CALayer dictionary instead of the layer's

        class to determine if it's a tile. TileController will set this on a tile

        when it is created, for now.

        * platform/graphics/TiledBacking.h:

        tiledScrollingIndicatorLayer() should return a PlatformCALayer.

        * platform/graphics/ca/GraphicsLayerCA.cpp:

        (WebCore::GraphicsLayerCA::platformCALayerPaintContents):

        * platform/graphics/ca/GraphicsLayerCA.h:

        (WebCore::GraphicsLayerCA::platformCALayerIncrementRepaintCount):

        * platform/graphics/ca/PlatformCALayerClient.h:

        The PlatformCALayerClient paintContents and incrementRepaintCount callbacks

        should include the platformCALayer that caused the callback.

        * platform/graphics/ca/PlatformCALayer.h:

        Add LayerTypeSimpleLayer, which is similar to LayerTypeWebLayer

        except it just calls back its client to paint, instead of doing

        complicated things with repaint rects. This is so that TileController

        doesn't re-enter drawLayerContents when asking its GraphicsLayer

        to paint for each PlatformCALayer (it will be entering drawLayerContents

        for the first time for each layer). It also happens to be useful

        for things like the tile controller overlay, which don't need

        all that complication.

        Add LayerTypeTiledBackingTileLayer, which is used simply to distinguish

        TileController Tile layers from other LayerTypeSimpleLayers.

        * platform/graphics/ca/mac/LayerPool.h:

        * platform/graphics/ca/mac/LayerPool.mm:

        (WebCore::LayerPool::addLayer):

        (WebCore::LayerPool::takeLayerWithSize):

        LayerPool should operate on PlatformCALayers now.

        * platform/graphics/ca/mac/PlatformCALayerMac.h:

        * platform/graphics/ca/mac/PlatformCALayerMac.mm:

        (PlatformCALayerMac::PlatformCALayerMac):

        Set the "isTile" key on the CALayer to true for TiledBackingTileLayers,

        so that the scrolling performance logging can tell a tile apart from

        any other layer, on the scrolling thread, without touching PlatformCALayers

        or the TileController or any other main-thread data structures.

        (PlatformCALayerMac::setEdgeAntialiasingMask): Added.

        * platform/graphics/ca/mac/TileController.h:

        Remove references to Objective-C classes; instead use PlatformCALayer everywhere.

        TileController is now a PlatformCALayerClient, and the layers it owns are

        all PlatformCALayers (and it is constructed with a PlatformCALayer, etc.).

        Hand in the tile debug border color as a WebCore color, instead of a CGColorRef.

        blankPixelCountForTiles() now operates on a list of PlatformLayers instead of

        WebTileLayers specifically, since WebTileLayer is gone.

        Make drawTileMapContents private because WebTileCacheMapLayer no longer exists.

        (WebCore::TileController::platformCALayerDrawsContent):

        All of the layers who have TileController as their client paint their contents.

        (WebCore::TileController::platformCALayerContentsOpaque):

        This will only be called for layers which paint via drawLayerContents,

        so it's OK that we don't special-case the debugging overlay here.

        * platform/graphics/ca/mac/TileController.mm:

        Remove CALayer (WebCALayerDetails), WebTiledScrollingIndicatorLayer,

        and a bunch of includes that we don't need anymore.

        (WebCore::TileController::create):

        (WebCore::TileController::TileController):

        TileController is passed a PlatformCALayer for the tile cache root layer,

        instead of a WebTiledBackingLayer. It also creates a PlatformCALayer with

        LayerTypeLayer instead of a bare CALayer for the container layer.

        (WebCore::TileController::~TileController):

        Clear the owner of the PlatformCALayers which the TileController previously owned,

        so they don't try to call back a destroyed TileController.

        (WebCore::TileController::tileCacheLayerBoundsChanged):

        (WebCore::TileController::setNeedsDisplay):

        Straightforward adjustments towards use of PlatformCALayer.

        (WebCore::TileController::setTileNeedsDisplayInRect):

        Adjustments towards use of PlatformCALayer; we need FloatRects so we can

        pass pointers to PlatformCALayer::setNeedsDisplay.

        (WebCore::TileController::platformCALayerPaintContents):

        Replace drawLayer with platformCALayerPaintContents, which will be called

        back from our various WebSimpleLayers. If the PlatformCALayer is our

        tiled scrolling debug indicator, paint that. Otherwise, it's a tile.

        Make use of drawLayerContents() to paint the tile contents.

        Make use of drawRepaintIndicator() to paint the repaint indicator if needed.

        Move scrolling performance logging code that used to be in WebTileLayer here.

        (WebCore::TileController::platformCALayerDeviceScaleFactor):

        (WebCore::TileController::platformCALayerShowDebugBorders):

        (WebCore::TileController::platformCALayerShowRepaintCounter):

        Forward these to the owning GraphicsLayerCA, because it will have the right answers.

        (WebCore::TileController::setScale):

        Adjustments towards use of PlatformCALayer; remove some code that Simon

        caused to be unused in 156291 but did not remove.

        (WebCore::TileController::setAcceleratesDrawing):

        (WebCore::TileController::setTilesOpaque):

        (WebCore::TileController::setVisibleRect):

        (WebCore::TileController::revalidateTiles):

        (WebCore::TileController::setTileDebugBorderWidth):

        (WebCore::TileController::setTileDebugBorderColor):

        (WebCore::TileController::bounds):

        (WebCore::TileController::blankPixelCount):

        (WebCore::TileController::blankPixelCountForTiles):

        (WebCore::queueTileForRemoval):

        (WebCore::TileController::setNeedsRevalidateTiles):

        (WebCore::TileController::ensureTilesForRect):

        (WebCore::TileController::retainedTileBackingStoreMemory):

        Straightforward adjustments towards use of PlatformCALayer.

        (WebCore::TileController::updateTileCoverageMap):

        Adjustments towards use of PlatformCALayer; rename backgroundColor

        to visibleRectIndicatorColor, since it's actually a border, not a background.

        (WebCore::TileController::tiledScrollingIndicatorLayer):

        Create a LayerTypeSimpleLayer PlatformCALayer for the tiled scrolling indicator.

        It will be asked to paint straightforwardly, like a CALayer would.

        Create a LayerTypeLayer PlatformCALayer for the visible rect indicator.

        It doesn't need to paint anything, so it doesn't get an owner.

        (WebCore::TileController::createTileLayer):

        When creating a new tile layer, adopt it by setting its owner.

        Otherwise, straightforward adjustments towards use of PlatformCALayer.

        (WebCore::TileController::platformCALayerIncrementRepaintCount):

        Manage repaint counts for tiles in TileController now.

        (WebCore::TileController::drawTileMapContents):

        Adjustments towards use of PlatformCALayer.

        * platform/graphics/ca/mac/WebTileLayer.h: Removed.

        * platform/graphics/ca/mac/WebTileLayer.mm: Removed.

        We don't need WebTileLayer anymore, tiles are now just WebSimpleLayers

        owned by TileController. Its behavior has been moved into TileController.

        * platform/graphics/ca/mac/WebTiledBackingLayer.h:

        * platform/graphics/ca/mac/WebTiledBackingLayer.mm:

        (-[WebTiledBackingLayer createTileController:]):

        Add createTileController: so that the WebTiledBackingLayer's owner can

        hand the TileController the PlatformCALayer for the WebTiledBackingLayer

        without propagating additional usage of PlatformCALayer::platformCALayer(),

        which we need to remove in light of the remote layer tree work.

        (-[WebTiledBackingLayer setBorderColor:]):

        * platform/graphics/ca/win/PlatformCALayerWin.h:

        Add an empty implementation of setEdgeAntialiasingMask.

        We'll probably want to implement it before adopting TileController on Windows.

        * platform/graphics/ca/win/PlatformCALayerWinInternal.cpp:

        (PlatformCALayerWinInternal::displayCallback):

        * platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.cpp:

        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::LayerClient::platformCALayerPaintContents):

        (WebCore::MediaPlayerPrivateQuickTimeVisualContext::LayerClient::platformCALayerIncrementRepaintCount):

        * platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.cpp:

        (WebCore::LayerClient::platformCALayerPaintContents):

        (WebCore::LayerClient::platformCALayerIncrementRepaintCount):

        Adjust for new parameters on PlatformCALayerClient callbacks.

        * platform/graphics/mac/WebLayer.h:

        Add WebSimpleLayer, which inherits directly from CALayer, and make

        our standard WebLayer (which is used for compositing layers in web content)

        inherit from that.

        * platform/graphics/mac/WebLayer.mm:

        Move most of the behavior of WebLayer onto WebSimpleLayer, except for its

        complex painting code. That stays as an override on WebLayer.

        (WebCore::drawLayerContents):

        Use the PlatformCALayer's PlatformLayer - if it exists - to extract

        fine-grained repaint rects. If it doesn't, we'll just use the CGContext's

        clip rect as our single repaint rect.

        Rename platformLayer to platformCALayer for accuracy.

        Remove special code for CATiledLayer since we ought not use it on Mac anymore.

        (WebCore::drawRepaintIndicator):

        Factor repaint indicator code out into its own function so that TileController

        can use it. It can't be called from drawLayerContents for TileController, since

        the PlatformCALayer that TileController passes in to drawLayerContents is actually

        that of the tile cache's root layer, not the tile itself.

        Also, add a custom background color parameter so TileController can override

        the default green color with its own standard purple.

        (-[WebLayer drawInContext:]):

        (-[WebSimpleLayer drawInContext:]):

        * platform/graphics/mac/WebTiledLayer.mm:

        (-[WebTiledLayer drawInContext:]):

        Removed a param from drawLayerContents because it's trivially acquirable

        from the PlatformCALayer.

2013-10-23  Mark Lam  <mark.lam@apple.com>

        Re-instate ProposedDatabases needed by detailsForNameAndOrigin().

Source/WebCore/WebCore.exp.in

@@__ZN7WebCore15GraphicsLayerCA23setContentsNeedsDisplayEv

__ZN7WebCore15GraphicsLayerCA23setContentsToSolidColorERKNS_5ColorE

__ZN7WebCore15GraphicsLayerCA23setDebugBackgroundColorERKNS_5ColorE

__ZN7WebCore15GraphicsLayerCA26setMaintainsPixelAlignmentEb

543 __ZN7WebCore15GraphicsLayerCA28platformCALayerPaintContentsERNS_15GraphicsContextERKNS_7IntRectE

543__ZN7WebCore15GraphicsLayerCA28platformCALayerPaintContentsEPNS_15PlatformCALayerERNS_15GraphicsContextERKNS_7IntRectE

__ZN7WebCore15GraphicsLayerCA30deviceOrPageScaleFactorChangedEv

__ZN7WebCore15GraphicsLayerCA31platformCALayerAnimationStartedEd

__ZN7WebCore15GraphicsLayerCA32platformCALayerDeviceScaleFactorEv

@@__ZN7WebCore17SQLiteTransactionC1ERNS_14SQLiteDatabaseEb

__ZN7WebCore17SQLiteTransactionD1Ev

__ZN7WebCore17SubresourceLoader6createEPNS_5FrameEPNS_14CachedResourceERKNS_15ResourceRequestERKNS_21ResourceLoaderOptionsE

__ZN7WebCore17cacheDOMStructureEPNS_17JSDOMGlobalObjectEPN3JSC9StructureEPKNS2_9ClassInfoE

683 __ZN7WebCore17drawLayerContentsEP9CGContextPNS_15PlatformCALayerENS_9FloatRectE~~N3WTF6VectorIS4_~~Lm5ENS5_15CrashOnOverflowEEEb

683__ZN7WebCore17drawLayerContentsEP9CGContextPNS_15PlatformCALayerEN3WTF6VectorINS_9FloatRectELm5ENS4_15CrashOnOverflowEEE

__ZN7WebCore17languageDidChangeEv

__ZN7WebCore17openTemporaryFileERKN3WTF6StringERi

__ZN7WebCore17setCookiesFromDOMERKNS_21NetworkStorageSessionERKNS_3URLES5_RKN3WTF6StringE

@@__ZTVN7WebCore25DropShadowFilterOperationE

__ZTVN7WebCore28InspectorFrontendClientLocal8SettingsE

__ZTVN7WebCore31BasicColorMatrixFilterOperationE

__ZTVN7WebCore37BasicComponentTransferFilterOperationE

1816 __ZThn???_N7WebCore15GraphicsLayerCA28platformCALayerPaintContentsERNS_15GraphicsContextERKNS_7IntRectE

1816__ZThn???_N7WebCore15GraphicsLayerCA28platformCALayerPaintContentsEPNS_15PlatformCALayerERNS_15GraphicsContextERKNS_7IntRectE

__ZThn???_N7WebCore15GraphicsLayerCA31platformCALayerAnimationStartedEd

__ZThn???_N7WebCore15GraphicsLayerCA32platformCALayerDeviceScaleFactorEv

__ZThn???_N7WebCore15GraphicsLayerCA40platformCALayerSetNeedsToRevalidateTilesEv

Source/WebCore/WebCore.xcodeproj/project.pbxproj

		1AA21250163F0DA80000E63F /* AtomicStringCF.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1AA2124F163F0DA80000E63F /* AtomicStringCF.cpp */; };

		1AA7160A149BC4DB0016EC19 /* TileController.mm in Sources */ = {isa = PBXBuildFile; fileRef = 1AA71608149BC4DA0016EC19 /* TileController.mm */; };

		1AA7160B149BC4DB0016EC19 /* TileController.h in Headers */ = {isa = PBXBuildFile; fileRef = 1AA71609149BC4DB0016EC19 /* TileController.h */; };

689 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 */; };

		1AA8799011CBE846003C664F /* PluginStrategy.h in Headers */ = {isa = PBXBuildFile; fileRef = 1AA8798F11CBE846003C664F /* PluginStrategy.h */; settings = {ATTRIBUTES = (Private, ); }; };

		1AA2124F163F0DA80000E63F /* AtomicStringCF.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AtomicStringCF.cpp; 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>"; };

7157 1AA7161C149BF2FA0016EC19 /* WebTileLayer.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = WebTileLayer.mm; path = ca/mac/WebTileLayer.mm; sourceTree = "<group>"; };

7158 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>"; };

		1AA84F03143BA7BD0051D153 /* ScrollElasticityController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollElasticityController.h; sourceTree = "<group>"; };

		1AA8798F11CBE846003C664F /* PluginStrategy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PluginStrategy.h; sourceTree = "<group>"; };

				1AA71608149BC4DA0016EC19 /* TileController.mm */,

				0F580FA11496939100FB5BD8 /* WebTiledBackingLayer.h */,

				0F580FA21496939100FB5BD8 /* WebTiledBackingLayer.mm */,

14736 1AA71625149BFFB20016EC19 /* WebTileLayer.h */,

14737 1AA7161C149BF2FA0016EC19 /* WebTileLayer.mm */,

			);

			name = mac;

			sourceTree = "<group>";

				97AABD2614FA09D5007457AE /* WebSocketHandshake.cpp in Sources */,

				0F580FA41496939100FB5BD8 /* WebTiledBackingLayer.mm in Sources */,

				0FCF332C0F2B9A25004B6795 /* WebTiledLayer.mm in Sources */,

27639 1AA7161E149BF2FA0016EC19 /* WebTileLayer.mm in Sources */,

				CD82030B1395AB6A00F956C6 /* WebVideoFullscreenController.mm in Sources */,

				CD61FE691794AADB004101EB /* WebKitSourceBuffer.cpp in Sources */,

				CD82030D1395AB6A00F956C6 /* WebVideoFullscreenHUDWindowController.mm in Sources */,

Source/WebCore/page/scrolling/mac/ScrollingTreeScrollingNodeMac.mm

#import "ScrollingStateTree.h"

#import "Settings.h"

#import "TileController.h"

39 #import "Web~~Tile~~Layer.h"

39#import "WebLayer.h"

#import <QuartzCore/QuartzCore.h>

#import <wtf/CurrentTime.h>

@@void ScrollingTreeScrollingNodeMac::logExposedUnfilledArea()

    Deque<CALayer*> layerQueue;

    layerQueue.append(m_scrollLayer.get());

422 ~~WebTi~~leLayerList tiles;

422 PlatformLayerList tiles;

    while (!layerQueue.isEmpty() && tiles.isEmpty()) {

        CALayer* layer = layerQueue.takeFirst();

        NSArray* sublayers = [[layer sublayers] copy];

        // If this layer is the parent of a tile, it is the parent of all of the tiles and nothing else.

        if ([[sublayers objectAtIndex:0] isKindOfClass:[WebTileLayer class]]) {

            for (CALayer* sublayer in sublayers) {

                ASSERT([sublayer isKindOfClass:[WebTileLayer class]]);

                tiles.append(static_cast<WebTileLayer*>(sublayer));

            }

        if ([[[sublayers objectAtIndex:0] valueForKey:@"isTile"] boolValue]) {

            for (CALayer* sublayer in sublayers)

                tiles.append(sublayer);

        } else {

            for (CALayer* sublayer in sublayers)

                layerQueue.append(sublayer);

Source/WebCore/platform/graphics/TiledBacking.h

#ifndef TiledBacking_h

#define TiledBacking_h

#if PLATFORM(MAC)

OBJC_CLASS CALayer;

#endif

namespace WebCore {

class IntRect;

#if PLATFORM(MAC)

class PlatformCALayer;

#endif

enum ScrollingModeIndication {

    MainThreadScrollingBecauseOfStyleIndication,

@@public:

    virtual void setScrollingModeIndication(ScrollingModeIndication) = 0;

#if PLATFORM(MAC)

93 virtual CALayer *tiledScrollingIndicatorLayer() = 0;

92 virtual PlatformCALayer* tiledScrollingIndicatorLayer() = 0;

#endif

};

Source/WebCore/platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.cpp

@@private:

    virtual void platformCALayerAnimationStarted(CFTimeInterval beginTime) { }

    virtual GraphicsLayer::CompositingCoordinatesOrientation platformCALayerContentsOrientation() const { return GraphicsLayer::CompositingCoordinatesBottomUp; }

188 virtual void platformCALayerPaintContents(GraphicsContext&, const IntRect& inClip) { }

188 virtual void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const IntRect& inClip) { }

189189 virtual bool platformCALayerShowDebugBorders() const { return false; }

190190 virtual bool platformCALayerShowRepaintCounter(PlatformCALayer*) const { return false; }

191 virtual int platformCALayerIncrementRepaintCount() { return 0; }

191 virtual int platformCALayerIncrementRepaintCount(PlatformCALayer*) { return 0; }

    virtual bool platformCALayerContentsOpaque() const { return false; }

    virtual bool platformCALayerDrawsContent() const { return false; }

Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp

@@bool GraphicsLayerCA::platformCALayerShowRepaintCounter(PlatformCALayer* platfor

    // so we don't want to overpaint the repaint counter when called with the TileController's own layer.

    if (m_isPageTiledBackingLayer && platformLayer)

        return false;

1217

    return isShowingRepaintCounter();

}

1221 void GraphicsLayerCA::platformCALayerPaintContents(GraphicsContext& context, const IntRect& clip)

1221void GraphicsLayerCA::platformCALayerPaintContents(PlatformCALayer*, GraphicsContext& context, const IntRect& clip)

{

    paintGraphicsLayerContents(context, clip);

}

Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h

@@private:

    virtual void platformCALayerAnimationStarted(CFTimeInterval beginTime);

    virtual CompositingCoordinatesOrientation platformCALayerContentsOrientation() const { return contentsOrientation(); }

170 virtual void platformCALayerPaintContents(GraphicsContext&, const IntRect& clip);

170 virtual void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const IntRect& clip);

171171 virtual bool platformCALayerShowDebugBorders() const { return isShowingDebugBorder(); }

172172 virtual bool platformCALayerShowRepaintCounter(PlatformCALayer*) const;

173 virtual int platformCALayerIncrementRepaintCount() { return incrementRepaintCount(); }

173 virtual int platformCALayerIncrementRepaintCount(PlatformCALayer*) { return incrementRepaintCount(); }

    virtual bool platformCALayerContentsOpaque() const { return contentsOpaque(); }

    virtual bool platformCALayerDrawsContent() const { return drawsContent(); }

Source/WebCore/platform/graphics/ca/PlatformCALayer.h

@@public:

    enum LayerType {

        LayerTypeLayer,

        LayerTypeWebLayer,

67 LayerTypeSimpleLayer,

        LayerTypeTransformLayer,

        LayerTypeWebTiledLayer,

        LayerTypeTiledBackingLayer,

        LayerTypePageTiledBackingLayer,

72 LayerTypeTiledBackingTileLayer,

        LayerTypeRootLayer,

        LayerTypeAVPlayerLayer,

        LayerTypeCustom

@@public:

    virtual float contentsScale() const = 0;

    virtual void setContentsScale(float) = 0;

188 virtual void setEdgeAntialiasingMask(unsigned) = 0;

189

    virtual TiledBacking* tiledBacking() = 0;

#if PLATFORM(WIN)

Source/WebCore/platform/graphics/ca/PlatformCALayerClient.h

@@public:

    virtual void platformCALayerAnimationStarted(CFTimeInterval beginTime) = 0;

    virtual GraphicsLayer::CompositingCoordinatesOrientation platformCALayerContentsOrientation() const = 0;

53 virtual void platformCALayerPaintContents(GraphicsContext&, const IntRect& inClip) = 0;

53 virtual void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const IntRect& inClip) = 0;

5454 virtual bool platformCALayerShowDebugBorders() const = 0;

5555 virtual bool platformCALayerShowRepaintCounter(PlatformCALayer*) const = 0;

56 virtual int platformCALayerIncrementRepaintCount() = 0;

56 virtual int platformCALayerIncrementRepaintCount(PlatformCALayer*) = 0;

    
    virtual bool platformCALayerContentsOpaque() const = 0;

    virtual bool platformCALayerDrawsContent() const = 0;

Source/WebCore/platform/graphics/ca/mac/LayerPool.h

#include "IntSize.h"

#include "IntSizeHash.h"

31#include "PlatformCALayer.h"

#include "Timer.h"

#include <wtf/Deque.h>

#include <wtf/HashMap.h>

#include <wtf/RetainPtr.h>

#include <wtf/Vector.h>

38 @class WebTileLayer;

39

namespace WebCore {

class LayerPool {

@@class LayerPool {

public:

    static LayerPool* sharedPool();

47 void addLayer(const Re~~tain~~Ptr<~~WebTi~~leLayer>&);

48 Re~~tain~~Ptr<~~WebTi~~leLayer> takeLayerWithSize(const IntSize&);

46 void addLayer(const RefPtr<PlatformCALayer>&);

47 RefPtr<PlatformCALayer> takeLayerWithSize(const IntSize&);

    void drain();

@@public:

private:

    LayerPool();

58 typedef Deque<Re~~tain~~Ptr<~~WebTi~~leLayer>> LayerList;

57 typedef Deque<RefPtr<PlatformCALayer>> LayerList;

    unsigned decayedCapacity() const;

Source/WebCore/platform/graphics/ca/mac/LayerPool.mm

#include "LayerPool.h"

#include "Logging.h"

30 #include "WebTileLayer.h"

#include <wtf/CurrentTime.h>

namespace WebCore {

34

33

3534static const double capacityDecayTime = 5;

36

35

LayerPool::LayerPool()

    : m_totalBytes(0)

    , m_maxBytesForPool(48 * 1024 * 1024)

@@LayerPool::LayerList& LayerPool::listOfLayersWithSize(const IntSize& size, Acces

    return it->value;

}

69 void LayerPool::addLayer(const Re~~tain~~Ptr<~~WebTi~~leLayer>& layer)

68void LayerPool::addLayer(const RefPtr<PlatformCALayer>& layer)

7069{

71 IntSize layerSize([layer~~.get()~~ bounds].size);

70 IntSize layerSize(expandedIntSize(layer->bounds().size()));

    if (!canReuseLayerWithSize(layerSize))

        return;

@@void LayerPool::addLayer(const RetainPtr<WebTileLayer>& layer)

    schedulePrune();

}

82 ~~Retain~~Ptr<~~WebTi~~leLayer> LayerPool::takeLayerWithSize(const IntSize& size)

81RefPtr<PlatformCALayer> LayerPool::takeLayerWithSize(const IntSize& size)

{

    if (!canReuseLayerWithSize(size))

        return nil;

Source/WebCore/platform/graphics/ca/mac/PlatformCALayerMac.h

@@public:

    virtual float contentsScale() const OVERRIDE;

    virtual void setContentsScale(float) OVERRIDE;

136 virtual void setEdgeAntialiasingMask(unsigned) OVERRIDE;

137

    virtual TiledBacking* tiledBacking() OVERRIDE;

    virtual void synchronouslyDisplayTilesInRect(const FloatRect&) OVERRIDE;

Source/WebCore/platform/graphics/ca/mac/PlatformCALayerMac.mm

#import "PlatformCAFilters.h"

#import "SoftLinking.h"

#import "TiledBacking.h"

40#import "TileController.h"

#import "WebLayer.h"

#import "WebTiledLayer.h"

#import "WebTiledBackingLayer.h"

@@PlatformCALayerMac::PlatformCALayerMac(LayerType layerType, PlatformLayer* layer

        case LayerTypeWebLayer:

            layerClass = [WebLayer class];

            break;

        case LayerTypeSimpleLayer:

        case LayerTypeTiledBackingTileLayer:

            layerClass = [WebSimpleLayer class];

            break;

        case LayerTypeTransformLayer:

            layerClass = [CATransformLayer class];

            break;

@@PlatformCALayerMac::PlatformCALayerMac(LayerType layerType, PlatformLayer* layer

        [tiledLayer setLevelsOfDetailBias:0];

        [tiledLayer setContentsGravity:@"bottomLeft"];

    }

    // So that the scrolling thread's performance logging code can find all the tiles, mark this as being a tile.

    if (m_layerType == LayerTypeTiledBackingTileLayer)

        [m_layer setValue:@YES forKey:@"isTile"];

227236

228237 if (usesTiledBackingLayer()) {

        WebTiledBackingLayer* tiledBackingLayer = static_cast<WebTiledBackingLayer*>(m_layer.get());

        TileController* tileController = [tiledBackingLayer createTileController:this];

229241 m_customSublayers = adoptPtr(new PlatformCALayerList(1));

230 CALayer* tileCacheTileContainerLayer = [s~~tatic_cast<WebT~~ile~~dBackingLay~~er *~~>(m_layer.get())~~ tileContainerLayer];

231 (*m_customSublayers)[0] = ~~PlatformCALayerMac::create(~~tileCacheTileContainerLayer~~, 0)~~;

242 PlatformCALayer* tileCacheTileContainerLayer = tileController->tileContainerLayer();

243 (*m_customSublayers)[0] = tileCacheTileContainerLayer;

    }

    END_BLOCK_OBJC_EXCEPTIONS

@@void PlatformCALayerMac::setContentsScale(float value)

    END_BLOCK_OBJC_EXCEPTIONS

}

void PlatformCALayerMac::setEdgeAntialiasingMask(unsigned mask)

{

    BEGIN_BLOCK_OBJC_EXCEPTIONS

    [m_layer.get() setEdgeAntialiasingMask:mask];

    END_BLOCK_OBJC_EXCEPTIONS

}

TiledBacking* PlatformCALayerMac::tiledBacking()

{

    if (!usesTiledBackingLayer())

Source/WebCore/platform/graphics/ca/mac/TileController.h

#include "FloatRect.h"

#include "IntPointHash.h"

#include "IntRect.h"

32#include "PlatformCALayer.h"

33#include "PlatformCALayerClient.h"

#include "TiledBacking.h"

#include "Timer.h"

#include <wtf/Deque.h>

#include <wtf/PassOwnPtr.h>

#include <wtf/RetainPtr.h>

OBJC_CLASS CALayer;

OBJC_CLASS WebTiledBackingLayer;

OBJC_CLASS WebTileLayer;

OBJC_CLASS WebTiledScrollingIndicatorLayer;

namespace WebCore {

class FloatRect;

class IntPoint;

class IntRect;

51 typedef Vector<RetainPtr<~~WebTi~~leLayer>> ~~WebTi~~leLayerList;

48typedef Vector<RetainPtr<PlatformLayer>> PlatformLayerList;

5249

53 class TileController : public TiledBacking {

50class TileController : public TiledBacking, public PlatformCALayerClient {

    WTF_MAKE_NONCOPYABLE(TileController);

public:

57 static PassOwnPtr<TileController> create(~~WebTiledBacking~~Layer*);

54 static PassOwnPtr<TileController> create(PlatformCALayer*);

    ~TileController();

    void tileCacheLayerBoundsChanged();

    void setNeedsDisplay();

    void setNeedsDisplayInRect(const IntRect&);

64 void drawLayer(WebTileLayer *, CGContextRef);

    void setScale(CGFloat);

    CGFloat scale() const { return m_scale; }

@@public:

    void setTilesOpaque(bool);

    bool tilesAreOpaque() const { return m_tilesAreOpaque; }

75 CALayer *tileContainerLayer() const { return m_tileContainerLayer.get(); }

71 PlatformCALayer *tileContainerLayer() const { return m_tileContainerLayer.get(); }

7672

7773 void setTileDebugBorderWidth(float);

78 void setTileDebugBorderColor(CGColor~~Ref~~);

74 void setTileDebugBorderColor(Color);

    virtual FloatRect visibleRect() const OVERRIDE { return m_visibleRect; }

    unsigned blankPixelCount() const;

    static unsigned blankPixelCountForTiles(const WebTileLayerList&, const FloatRect&, const IntPoint&);

    // Only public for the WebTileCacheMapLayer.

    void drawTileMapContents(CGContextRef, CGRect);

79 static unsigned blankPixelCountForTiles(const PlatformLayerList&, const FloatRect&, const IntPoint&);

public:

    // Only public for inline methods in the implementation file.

    typedef IntPoint TileIndex;

    typedef unsigned TileCohort;

    static const TileCohort VisibleTileCohort = UINT_MAX;

86 typedef HashMap<PlatformCALayer*, int> RepaintCountMap;

9387

9488 struct TileInfo {

95 Re~~tain~~Ptr<~~WebTi~~leLayer> layer;

89 RefPtr<PlatformCALayer> layer;

        TileCohort cohort; // VisibleTileCohort is visible.

        bool hasStaleContent;

@@public:

    };

private:

106 TileController(~~WebTiledBacking~~Layer*);

100 TileController(PlatformCALayer*);

    // TiledBacking member functions.

    virtual void setVisibleRect(const FloatRect&) OVERRIDE;

@@private:

    virtual bool unparentsOffscreenTiles() const OVERRIDE { return m_unparentsOffscreenTiles; }

    virtual double retainedTileBackingStoreMemory() const OVERRIDE;

    virtual IntRect tileCoverageRect() const OVERRIDE;

130 virtual CALayer *tiledScrollingIndicatorLayer() OVERRIDE;

124 virtual PlatformCALayer* tiledScrollingIndicatorLayer() OVERRIDE;

131125 virtual void setScrollingModeIndication(ScrollingModeIndication) OVERRIDE;

132126

    // PlatformCALayerClient

    virtual void platformCALayerLayoutSublayersOfLayer(PlatformCALayer*) OVERRIDE { }

    virtual bool platformCALayerRespondsToLayoutChanges() const OVERRIDE { return false; }

    virtual void platformCALayerAnimationStarted(CFTimeInterval) OVERRIDE { }

    virtual GraphicsLayer::CompositingCoordinatesOrientation platformCALayerContentsOrientation() const OVERRIDE { return GraphicsLayer::CompositingCoordinatesTopDown; }

    virtual void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const IntRect&) OVERRIDE;

    virtual bool platformCALayerShowDebugBorders() const OVERRIDE;

    virtual bool platformCALayerShowRepaintCounter(PlatformCALayer*) const OVERRIDE;

    virtual int platformCALayerIncrementRepaintCount(PlatformCALayer*) OVERRIDE;

    virtual bool platformCALayerContentsOpaque() const OVERRIDE { return m_tilesAreOpaque; }

    virtual bool platformCALayerDrawsContent() const OVERRIDE { return true; }

    virtual void platformCALayerLayerDidDisplay(PlatformLayer*) OVERRIDE { }

    virtual void platformCALayerSetNeedsToRevalidateTiles() OVERRIDE { }

    virtual float platformCALayerDeviceScaleFactor() OVERRIDE;

    IntRect bounds() const;

    IntRect rectForTileIndex(const TileIndex&) const;

@@private:

    void setTileNeedsDisplayInRect(const TileIndex&, TileInfo&, const IntRect& repaintRectInTileCoords, const IntRect& coverageRectInTileCoords);

169 WebTileLayer* tileLayerAtIndex(const TileIndex&) const;

170 RetainPtr<WebTileLayer> createTileLayer(const IntRect&);

180 RefPtr<PlatformCALayer> createTileLayer(const IntRect&);

171181

172 bool shouldShowRepaintCounters() const;

173 void drawRepaintCounter(WebTileLayer *, CGContextRef);

182 void drawTileMapContents(CGContextRef, CGRect);

174183

    WebTiledBackingLayer* m_tileCacheLayer;

    RetainPtr<CALayer> m_tileContainerLayer;

    RetainPtr<WebTiledScrollingIndicatorLayer> m_tiledScrollingIndicatorLayer; // Used for coverage visualization.

    PlatformCALayer* m_tileCacheLayer;

    RefPtr<PlatformCALayer> m_tileContainerLayer;

    RefPtr<PlatformCALayer> m_tiledScrollingIndicatorLayer; // Used for coverage visualization.

    RefPtr<PlatformCALayer> m_visibleRectIndicatorLayer;

    IntSize m_tileSize;

    FloatRect m_visibleRect;

@@private:

    Timer<TileController> m_tileRevalidationTimer;

    Timer<TileController> m_cohortRemovalTimer;

202 RepaintCountMap m_tileRepaintCounts;

203

    struct TileCohortInfo {

        TileCohort cohort;

        double creationTime; // in monotonicallyIncreasingTime().

@@private:

    bool m_tilesAreOpaque;

    bool m_clipsToExposedRect;

217 ~~RetainPtr<CG~~Color~~Ref>~~ m_tileDebugBorderColor;

229 Color m_tileDebugBorderColor;

    float m_tileDebugBorderWidth;

    ScrollingModeIndication m_indicatorMode;

};

Source/WebCore/platform/graphics/ca/mac/TileController.mm

#import "IntRect.h"

#import "PlatformCALayer.h"

31#import "PlatformCALayerMac.h"

#import "Region.h"

#import "LayerPool.h"

#import "WebLayer.h"

#import "WebTiledBackingLayer.h"

#import "WebTileLayer.h"

#import <QuartzCore/QuartzCore.h>

3735#import <wtf/MainThread.h>

38 #import <WebCore/BlockExceptions.h>

#import <utility>

using namespace std;

@interface CALayer (WebCALayerDetails)

- (void)setAcceleratesDrawing:(BOOL)flag;

@end

@interface WebTiledScrollingIndicatorLayer : CALayer {

    WebCore::TileController* _tileController;

    CALayer *_visibleRectFrameLayer; // Owned by being a sublayer.

}

@property (assign) WebCore::TileController* tileController;

@property (assign) CALayer* visibleRectFrameLayer;

@end

@implementation WebTiledScrollingIndicatorLayer

@synthesize tileController = _tileController;

@synthesize visibleRectFrameLayer = _visibleRectFrameLayer;

- (id)init

{

    if ((self = [super init])) {

        [self setStyle:[NSDictionary dictionaryWithObject:[NSDictionary dictionaryWithObjectsAndKeys:[NSNull null], @"bounds", [NSNull null], @"position", [NSNull null], @"contents", nil] forKey:@"actions"]];

        _visibleRectFrameLayer = [CALayer layer];

        [_visibleRectFrameLayer setStyle:[NSDictionary dictionaryWithObject:[NSDictionary dictionaryWithObjectsAndKeys:[NSNull null], @"bounds", [NSNull null], @"position", [NSNull null], @"borderColor", nil] forKey:@"actions"]];

        [self addSublayer:_visibleRectFrameLayer];

        [_visibleRectFrameLayer setBorderColor:WebCore::cachedCGColor(WebCore::Color(255, 0, 0), WebCore::ColorSpaceDeviceRGB)];

        [_visibleRectFrameLayer setBorderWidth:2];

        return self;

    }

    return nil;

}

- (void)drawInContext:(CGContextRef)context

{

    if (_tileController)

        _tileController->drawTileMapContents(context, [self bounds]);

}

@end

namespace WebCore {

enum TileValidationPolicyFlag {

@@enum TileValidationPolicyFlag {

static const int defaultTileWidth = 512;

static const int defaultTileHeight = 512;

90 PassOwnPtr<TileController> TileController::create(~~WebTiledBacking~~Layer* ti~~leCache~~Layer)

50PassOwnPtr<TileController> TileController::create(PlatformCALayer* rootPlatformLayer)

9151{

92 return adoptPtr(new TileController(ti~~leCache~~Layer));

52 return adoptPtr(new TileController(rootPlatformLayer));

9353}

9454

TileController::TileController(WebTiledBackingLayer* tileCacheLayer)

    : m_tileCacheLayer(tileCacheLayer)

    , m_tileContainerLayer(adoptNS([[CALayer alloc] init]))

55TileController::TileController(PlatformCALayer* rootPlatformLayer)

56 : m_tileCacheLayer(rootPlatformLayer)

    , m_tileSize(defaultTileWidth, defaultTileHeight)

    , m_tileRevalidationTimer(this, &TileController::tileRevalidationTimerFired)

    , m_cohortRemovalTimer(this, &TileController::cohortRemovalTimerFired)

@@TileController::TileController(WebTiledBackingLayer* tileCacheLayer)

    , m_tileDebugBorderWidth(0)

    , m_indicatorMode(ThreadedScrollingIndication)

{

    [CATransaction begin];

    [CATransaction setDisableActions:YES];

    [m_tileCacheLayer addSublayer:m_tileContainerLayer.get()];

73 m_tileContainerLayer = PlatformCALayerMac::create(PlatformCALayer::LayerTypeLayer, nullptr);

11774#ifndef NDEBUG

118 [m_tileContainerLayer~~.get()~~ setName:@"TileController Container Layer"];

75 m_tileContainerLayer->setName("TileController Container Layer");

11976#endif

120 ~~[CAT~~ransacti~~on comm~~it];

77 rootPlatformLayer->appendSublayer(m_tileContainerLayer.get());

}

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() setTileController:0];

    }

    for (TileMap::iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it)

        it->value.layer->setOwner(nullptr);

13287 if (m_tiledScrollingIndicatorLayer)

133 [m_tiledScrollingIndicatorLayer~~.get()~~ setTi~~leController:nil]~~;

88 m_tiledScrollingIndicatorLayer->setOwner(nullptr);

}

void TileController::tileCacheLayerBoundsChanged()

{

138 ASSERT~~(PlatformCALayer::platformCALayer~~(m_tileCacheLayer)->owner()->isCommittingChanges());

93 ASSERT(m_tileCacheLayer->owner()->isCommittingChanges());

    setNeedsRevalidateTiles();

}

@@void TileController::setNeedsDisplay()

{

    for (TileMap::const_iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it) {

        const TileInfo& tileInfo = it->value;

146 [tileInfo.layer~~.get()~~ setNeedsDisplay];

101 tileInfo.layer->setNeedsDisplay();

    }

}

@@void TileController::setNeedsDisplayInRect(const IntRect& rect)

void TileController::setTileNeedsDisplayInRect(const TileIndex& tileIndex, TileInfo& tileInfo, const IntRect& repaintRectInTileCoords, const IntRect& coverageRectInTileCoords)

{

183 ~~WebTi~~leLayer* tileLayer = tileInfo.layer.get();

138 PlatformCALayer* tileLayer = tileInfo.layer.get();

184139

185140 IntRect tileRect = rectForTileIndex(tileIndex);

186 IntRect tileRepaintRect = tileRect;

141 FloatRect tileRepaintRect = tileRect;

    tileRepaintRect.intersect(repaintRectInTileCoords);

    if (tileRepaintRect.isEmpty())

        return;

@@void TileController::setTileNeedsDisplayInRect(const TileIndex& tileIndex, TileI

    // We could test for intersection with the visible rect. This would reduce painting yet more,

    // but may make scrolling stale tiles into view more frequent.

    if (tileRect.intersects(coverageRectInTileCoords)) {

196 [tileLayer setNeedsDisplay~~InRect:~~tileRepaintRect];

151 tileLayer->setNeedsDisplay(&tileRepaintRect);

197152

        if (shouldShowRepaintCounters()) {

            CGRect bounds = [tileLayer bounds];

            CGRect indicatorRect = CGRectMake(bounds.origin.x, bounds.origin.y, 52, 27);

            [tileLayer setNeedsDisplayInRect:indicatorRect];

        if (m_tileCacheLayer->owner()->platformCALayerShowRepaintCounter(0)) {

            FloatRect indicatorRect(0, 0, 52, 27);

            tileLayer->setNeedsDisplay(&indicatorRect);

        }

    } else

        tileInfo.hasStaleContent = true;

}

207

208 void TileController::drawLayer(WebTileLayer *layer, CGContextRef context)

161void TileController::platformCALayerPaintContents(PlatformCALayer* platformCALayer, GraphicsContext& context, const IntRect&)

209162{

210 ~~Plat~~formCALayer* ~~platformLayer = PlatformCALayer::~~platformCALayer(m_tileC~~ache~~Layer);

211 if (!platformLayer)

163 if (platformCALayer == m_tiledScrollingIndicatorLayer.get()) {

164 drawTileMapContents(context.platformContext(), m_tiledScrollingIndicatorLayer->bounds());

212165 return;

    }

    {

        GraphicsContextStateSaver stateSaver(context);

213170

214 CGContextSaveGState(context);

        FloatPoint3D layerOrigin = platformCALayer->position();

        context.translate(-layerOrigin.x(), -layerOrigin.y());

        context.scale(FloatSize(m_scale, m_scale));

        drawLayerContents(context.platformContext(), m_tileCacheLayer);

    }

215177

    CGPoint layerOrigin = [layer frame].origin;

    CGContextTranslateCTM(context, -layerOrigin.x, -layerOrigin.y);

    CGContextScaleCTM(context, m_scale, m_scale);

    drawLayerContents(context, layer, platformLayer);

    int repaintCount = platformCALayerIncrementRepaintCount(platformCALayer);

    if (m_tileCacheLayer->owner()->platformCALayerShowRepaintCounter(0))

        drawRepaintIndicator(context.platformContext(), platformCALayer, repaintCount, cachedCGColor(m_tileDebugBorderColor, ColorSpaceDeviceRGB));

220181

221 CGContextRestoreGState(context);

    if (scrollingPerformanceLoggingEnabled()) {

        FloatRect visiblePart(platformCALayer->position().x(), platformCALayer->position().y(), platformCALayer->bounds().size().width(), platformCALayer->bounds().size().height());

        visiblePart.intersect(visibleRect());

222185

223 drawRepaintCounter(layer, context);

        if (repaintCount == 1 && !visiblePart.isEmpty())

            WTFLogAlways("SCROLLING: Filled visible fresh tile. Time: %f Unfilled Pixels: %u\n", WTF::monotonicallyIncreasingTime(), blankPixelCount());

    }

}

float TileController::platformCALayerDeviceScaleFactor()

{

    return m_tileCacheLayer->owner()->platformCALayerDeviceScaleFactor();

}

bool TileController::platformCALayerShowDebugBorders() const

{

    return m_tileCacheLayer->owner()->platformCALayerShowDebugBorders();

}

bool TileController::platformCALayerShowRepaintCounter(PlatformCALayer*) const

{

    return m_tileCacheLayer->owner()->platformCALayerShowRepaintCounter(0);

}

void TileController::setScale(CGFloat scale)

{

228 PlatformCALayer* platformLayer = PlatformCALayer::platformCALayer(m_tileCacheLayer);

229 ASSERT(platformLayer->owner()->isCommittingChanges());

208 ASSERT(m_tileCacheLayer->owner()->isCommittingChanges());

230209

231 float deviceScaleFactor = pl~~atform~~Layer->owner()->platformCALayerDeviceScaleFactor();

210 float deviceScaleFactor = m_tileCacheLayer->owner()->platformCALayerDeviceScaleFactor();

232211

233 // The scale we get is the produce of the page scale factor and device scale factor.

212 // The scale we get is the product of the page scale factor and device scale factor.

    // Divide by the device scale factor so we'll get the page scale factor.

    scale /= deviceScaleFactor;

    if (m_scale == scale && m_deviceScaleFactor == deviceScaleFactor)

        return;

240 Vector<FloatRect> dirtyRects;

241

242219 m_deviceScaleFactor = deviceScaleFactor;

243220 m_scale = scale;

244 [m_tileContainerLayer.get() setTransform:CATransform3DMakeScale(1 / m_scale, 1 / m_scale, 1)];

    TransformationMatrix transform;

    transform.scale(1 / m_scale);

    m_tileContainerLayer->setTransform(transform);

    // FIXME: we may revalidateTiles twice in this commit.

    revalidateTiles(PruneSecondaryTiles, PruneSecondaryTiles);

    for (TileMap::const_iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it) {

        const TileInfo& tileInfo = it->value;

        [tileInfo.layer.get() setContentsScale:deviceScaleFactor];

        IntRect tileRect = rectForTileIndex(it->key);

        FloatRect scaledTileRect = tileRect;

        scaledTileRect.scale(1 / m_scale);

        dirtyRects.append(scaledTileRect);

    }

229 for (TileMap::const_iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it)

230 it->value.layer->setContentsScale(deviceScaleFactor);

}

void TileController::setAcceleratesDrawing(bool acceleratesDrawing)

@@void TileController::setAcceleratesDrawing(bool acceleratesDrawing)

    for (TileMap::const_iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it) {

        const TileInfo& tileInfo = it->value;

270 [tileInfo.layer~~.get()~~ setAcceleratesDrawing:m_acceleratesDrawing];

242 tileInfo.layer->setAcceleratesDrawing(m_acceleratesDrawing);

    }

}

@@void TileController::setTilesOpaque(bool opaque)

    for (TileMap::iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it) {

        const TileInfo& tileInfo = it->value;

283 [tileInfo.layer~~.get()~~ setOpaque:opaque];

255 tileInfo.layer->setOpaque(opaque);

    }

}

void TileController::setVisibleRect(const FloatRect& visibleRect)

{

289 ASSERT~~(PlatformCALayer::platformCALayer~~(m_tileCacheLayer)->owner()->isCommittingChanges());

261 ASSERT(m_tileCacheLayer->owner()->isCommittingChanges());

    if (m_visibleRect == visibleRect)

        return;

@@void TileController::setTileCoverage(TileCoverage coverage)

void TileController::revalidateTiles()

{

386 ASSERT~~(PlatformCALayer::platformCALayer~~(m_tileCacheLayer)->owner()->isCommittingChanges());

358 ASSERT(m_tileCacheLayer->owner()->isCommittingChanges());

    revalidateTiles(0, 0);

}

@@void TileController::setTileDebugBorderWidth(float borderWidth)

    m_tileDebugBorderWidth = borderWidth;

    for (TileMap::const_iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it) {

        const TileInfo& tileInfo = it->value;

403 [tileInfo.layer~~.get()~~ setBorderWidth:m_tileDebugBorderWidth];

375 tileInfo.layer->setBorderWidth(m_tileDebugBorderWidth);

    }

}

407 void TileController::setTileDebugBorderColor(CGColor~~Ref~~ borderColor)

379void TileController::setTileDebugBorderColor(Color borderColor)

{

    if (m_tileDebugBorderColor == borderColor)

        return;

    m_tileDebugBorderColor = borderColor;

    for (TileMap::const_iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it) {

        const TileInfo& tileInfo = it->value;

        [tileInfo.layer.get() setBorderColor:m_tileDebugBorderColor.get()];

    }

385 for (TileMap::const_iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it)

386 it->value.layer->setBorderColor(borderColor);

}

IntRect TileController::bounds() const

{

421 return IntRect(IntPoint(), IntSize([m_tileCacheLayer bounds].size));

391 return IntRect(IntPoint(), expandedIntSize(m_tileCacheLayer->bounds().size()));

}

IntRect TileController::rectForTileIndex(const TileIndex& tileIndex) const

@@void TileController::tileRevalidationTimerFired(Timer<TileController>*)

unsigned TileController::blankPixelCount() const

{

526 ~~WebTi~~leLayerList tiles(m_tiles.size());

496 PlatformLayerList tiles(m_tiles.size());

527497

528 for (TileMap::const_iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it)

529 tiles.append(it->value.layer);

    for (TileMap::const_iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it) {

        if (PlatformLayer *layer = it->value.layer->platformLayer())

            tiles.append(layer);

    }

    return blankPixelCountForTiles(tiles, m_visibleRect, IntPoint(0,0));

}

534 unsigned TileController::blankPixelCountForTiles(const ~~WebTi~~leLayerList& tiles, const FloatRect& visibleRect, const IntPoint& tileTranslation)

506unsigned TileController::blankPixelCountForTiles(const PlatformLayerList& tiles, const FloatRect& visibleRect, const IntPoint& tileTranslation)

{

    Region paintedVisibleTiles;

538 for (~~WebTi~~leLayerList::const_iterator it = tiles.begin(), end = tiles.end(); it != end; ++it) {

539 const ~~WebTi~~leLayer* tileLayer = it->get();

510 for (PlatformLayerList::const_iterator it = tiles.begin(), end = tiles.end(); it != end; ++it) {

511 const PlatformLayer* tileLayer = it->get();

        FloatRect visiblePart(CGRectOffset([tileLayer frame], tileTranslation.x(), tileTranslation.y()));

        visiblePart.intersect(visibleRect);

@@unsigned TileController::blankPixelCountForTiles(const WebTileLayerList& tiles,

    return uncoveredRegion.totalArea();

}

554 static inline void queueTileForRemoval(const TileController::TileIndex& tileIndex, const TileController::TileInfo& tileInfo, Vector<TileController::TileIndex>& tilesToRemove)

526static inline void queueTileForRemoval(const TileController::TileIndex& tileIndex, const TileController::TileInfo& tileInfo, Vector<TileController::TileIndex>& tilesToRemove, TileController::RepaintCountMap& repaintCounts)

555527{

    WebTileLayer* tileLayer = tileInfo.layer.get();

    [tileLayer removeFromSuperlayer];

    [tileLayer setTileController:0];

528 tileInfo.layer->removeFromSuperlayer();

529 repaintCounts.remove(tileInfo.layer.get());

    tilesToRemove.append(tileIndex);

}

@@void TileController::removeAllTiles()

    Vector<TileIndex> tilesToRemove;

    for (TileMap::iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it)

567 queueTileForRemoval(it->key, it->value, tilesToRemove);

538 queueTileForRemoval(it->key, it->value, tilesToRemove, m_tileRepaintCounts);

    for (size_t i = 0; i < tilesToRemove.size(); ++i) {

        TileInfo tileInfo = m_tiles.take(tilesToRemove[i]);

@@void TileController::removeAllSecondaryTiles()

        if (tileInfo.cohort == VisibleTileCohort)

            continue;

584 queueTileForRemoval(it->key, it->value, tilesToRemove);

555 queueTileForRemoval(it->key, it->value, tilesToRemove, m_tileRepaintCounts);

    }

    for (size_t i = 0; i < tilesToRemove.size(); ++i) {

@@void TileController::removeTilesInCohort(TileCohort cohort)

        if (tileInfo.cohort != cohort)

            continue;

603 queueTileForRemoval(it->key, it->value, tilesToRemove);

574 queueTileForRemoval(it->key, it->value, tilesToRemove, m_tileRepaintCounts);

    }

    for (size_t i = 0; i < tilesToRemove.size(); ++i) {

@@void TileController::removeTilesInCohort(TileCohort cohort)

void TileController::setNeedsRevalidateTiles()

{

614 PlatformCALayer* platformLayer = PlatformCALayer::platformCALayer(m_tileCacheLayer);

615 platformLayer->owner()->platformCALayerSetNeedsToRevalidateTiles();

585 m_tileCacheLayer->owner()->platformCALayerSetNeedsToRevalidateTiles();

}

void TileController::revalidateTiles(TileValidationPolicyFlags foregroundValidationPolicy, TileValidationPolicyFlags backgroundValidationPolicy)

{

    // 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)

        return;

    FloatRect visibleRect = m_visibleRect;

    IntRect bounds = this->bounds();

@@void TileController::revalidateTiles(TileValidationPolicyFlags foregroundValidat

            TileInfo& tileInfo = it->value;

            TileIndex tileIndex = it->key;

658 ~~WebTi~~leLayer* tileLayer = tileInfo.layer.get();

622 PlatformCALayer* tileLayer = tileInfo.layer.get();

            IntRect tileRect = rectForTileIndex(tileIndex);

            if (tileRect.intersects(coverageRectInTileCoords)) {

                tileInfo.cohort = VisibleTileCohort;

                if (tileInfo.hasStaleContent) {

                    // FIXME: store a dirty region per layer?

664 [tileLayer setNeedsDisplay];

628 tileLayer->setNeedsDisplay();

                    tileInfo.hasStaleContent = false;

                }

            } else {

@@void TileController::revalidateTiles(TileValidationPolicyFlags foregroundValidat

                    ++tilesInCohort;

                    if (m_unparentsOffscreenTiles)

674 [tile~~Info.l~~ayer~~.get()~~ removeFromSuperlayer];

638 tileLayer->removeFromSuperlayer();

@@void TileController::revalidateTiles(TileValidationPolicyFlags foregroundValidat

    if (m_unparentsOffscreenTiles && (validationPolicy & UnparentAllTiles)) {

        for (TileMap::iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it)

700 [it->value.layer~~.get()~~ removeFromSuperlayer];

664 it->value.layer->removeFromSuperlayer();

    }

    if (m_boundsAtLastRevalidate != bounds) {

@@void TileController::revalidateTiles(TileValidationPolicyFlags foregroundValidat

                || index.y() > bottomRightForBounds.y()

                || index.x() < topLeftForBounds.x()

                || index.x() > bottomRightForBounds.x())

719 queueTileForRemoval(index, it->value, tilesToRemove);

683 queueTileForRemoval(index, it->value, tilesToRemove, m_tileRepaintCounts);

        }

        for (size_t i = 0, size = tilesToRemove.size(); i < size; ++i) {

@@IntRect TileController::ensureTilesForRect(const FloatRect& rect, CoverageType n

    if (m_unparentsOffscreenTiles && !m_isInWindow)

        return IntRect();

    PlatformCALayer* platformLayer = PlatformCALayer::platformCALayer(m_tileCacheLayer);

    if (!platformLayer)

        return IntRect();

    FloatRect scaledRect(rect);

    scaledRect.scale(m_scale);

    IntRect rectInTileCoords(enclosingIntRect(scaledRect));

@@IntRect TileController::ensureTilesForRect(const FloatRect& rect, CoverageType n

    TileIndex bottomRight;

    getTileIndexRangeForRect(rectInTileCoords, topLeft, bottomRight);

803 Vector<FloatRect> dirtyRects;

    TileCohort currCohort = nextTileCohort();

    unsigned tilesInCohort = 0;

@@IntRect TileController::ensureTilesForRect(const FloatRect& rect, CoverageType n

                tileInfo.layer = createTileLayer(tileRect);

            else {

                // We already have a layer for this tile. Ensure that its size is correct.

824 FloatSize tileLayerSize([tileInfo.layer~~.get() frame]~~.size);

783 FloatSize tileLayerSize(tileInfo.layer->bounds().size());

825784 shouldChangeTileLayerFrame = tileLayerSize != FloatSize(tileRect.size());

826785

827 if (shouldChangeTileLayerFrame)

828 [tileInfo.layer.get() setFrame:tileRect];

                if (shouldChangeTileLayerFrame) {

                    tileInfo.layer->setBounds(FloatRect(FloatPoint(), tileRect.size()));

                    tileInfo.layer->setPosition(tileRect.location());

                }

            }

            if (newTileType == CoverageType::SecondaryTiles && !tileRect.intersects(m_primaryTileCoverageRect)) {

@@IntRect TileController::ensureTilesForRect(const FloatRect& rect, CoverageType n

                ++tilesInCohort;

            }

836 bool shouldParentTileLayer = (!m_unparentsOffscreenTiles || m_isInWindow) && ![tileInfo.layer~~.get()~~ superlayer];

797 bool shouldParentTileLayer = (!m_unparentsOffscreenTiles || m_isInWindow) && !tileInfo.layer->superlayer();

837798

838799 if (shouldParentTileLayer)

                [m_tileContainerLayer.get() addSublayer:tileInfo.layer.get()];

            if ((shouldParentTileLayer && [tileInfo.layer.get() needsDisplay]) || shouldChangeTileLayerFrame) {

                FloatRect scaledTileRect = tileRect;

                scaledTileRect.scale(1 / m_scale);

                dirtyRects.append(scaledTileRect);

            }

800 m_tileContainerLayer->appendSublayer(tileInfo.layer.get());

        }

    }

@@void TileController::updateTileCoverageMap()

    float indicatorScale = scale * m_scale;

    FloatRect mapBounds = containerBounds;

    mapBounds.scale(indicatorScale, indicatorScale);

    
    BEGIN_BLOCK_OBJC_EXCEPTIONS

830

878831 if (m_clipsToExposedRect)

879 [m_tiledScrollingIndicatorLayer~~.get()~~ setPosition:m_exposedRect.location() + FloatPoint(2, 2)];

832 m_tiledScrollingIndicatorLayer->setPosition(m_exposedRect.location() + FloatPoint(2, 2));

880833 else

881 [m_tiledScrollingIndicatorLayer~~.get()~~ setPosition~~:CG~~Point~~Make~~(2, 2)];

834 m_tiledScrollingIndicatorLayer->setPosition(FloatPoint(2, 2));

882835

883 [m_tiledScrollingIndicatorLayer~~.get()~~ setBounds:mapBounds];

884 [m_tiledScrollingIndicatorLayer~~.get()~~ setNeedsDisplay];

836 m_tiledScrollingIndicatorLayer->setBounds(mapBounds);

837 m_tiledScrollingIndicatorLayer->setNeedsDisplay();

    visibleRect.scale(indicatorScale, indicatorScale);

    visibleRect.expand(2, 2);

888 [[m_tiledScrollingIndicatorLayer.get() visibleRectFrameLayer] setFrame:visibleRect];

841 m_visibleRectIndicatorLayer->setPosition(visibleRect.location());

842 m_visibleRectIndicatorLayer->setBounds(FloatRect(FloatPoint(), visibleRect.size()));

889843

890 Color ba~~ckgrou~~ndColor;

844 Color visibleRectIndicatorColor;

891845 switch (m_indicatorMode) {

892846 case MainThreadScrollingBecauseOfStyleIndication:

893 ba~~ckgrou~~ndColor = Color(255, 0, 0);

847 visibleRectIndicatorColor = Color(255, 0, 0);

894848 break;

895849 case MainThreadScrollingBecauseOfEventHandlersIndication:

896 ba~~ckgrou~~ndColor = Color(255, 255, 0);

850 visibleRectIndicatorColor = Color(255, 255, 0);

897851 break;

898852 case ThreadedScrollingIndication:

899 ba~~ckgrou~~ndColor = Color(0, 200, 0);

853 visibleRectIndicatorColor = Color(0, 200, 0);

        break;

    }

    [[m_tiledScrollingIndicatorLayer.get() visibleRectFrameLayer] setBorderColor:cachedCGColor(backgroundColor, ColorSpaceDeviceRGB)];

    END_BLOCK_OBJC_EXCEPTIONS

857 m_visibleRectIndicatorLayer->setBorderColor(visibleRectIndicatorColor);

}

IntRect TileController::tileGridExtent() const

@@double TileController::retainedTileBackingStoreMemory() const

    
    for (TileMap::const_iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it) {

        const TileInfo& tileInfo = it->value;

        if ([tileInfo.layer.get() superlayer]) {

            CGRect bounds = [tileInfo.layer.get() bounds];

            double contentsScale = [tileInfo.layer.get() contentsScale];

            totalBytes += 4 * bounds.size.width * contentsScale * bounds.size.height * contentsScale;

        if (tileInfo.layer->superlayer()) {

            FloatRect bounds = tileInfo.layer->bounds();

            double contentsScale = tileInfo.layer->contentsScale();

            totalBytes += 4 * bounds.width() * contentsScale * bounds.height() * contentsScale;

        }

    }

@@IntRect TileController::tileCoverageRect() const

    return coverageRectInLayerCoords;

}

942 CALayer *TileController::tiledScrollingIndicatorLayer()

894PlatformCALayer* TileController::tiledScrollingIndicatorLayer()

943895{

944896 if (!m_tiledScrollingIndicatorLayer) {

        m_tiledScrollingIndicatorLayer = [WebTiledScrollingIndicatorLayer layer];

        [m_tiledScrollingIndicatorLayer.get() setTileController:this];

        [m_tiledScrollingIndicatorLayer.get() setOpacity:0.75];

        [m_tiledScrollingIndicatorLayer.get() setAnchorPoint:CGPointZero];

        [m_tiledScrollingIndicatorLayer.get() setBorderColor:cachedCGColor(Color::black, ColorSpaceDeviceRGB)];

        [m_tiledScrollingIndicatorLayer.get() setBorderWidth:1];

        [m_tiledScrollingIndicatorLayer.get() setPosition:CGPointMake(2, 2)];

        m_tiledScrollingIndicatorLayer = PlatformCALayerMac::create(PlatformCALayer::LayerTypeSimpleLayer, this);

        m_tiledScrollingIndicatorLayer->setOpacity(0.75);

        m_tiledScrollingIndicatorLayer->setAnchorPoint(FloatPoint3D());

        m_tiledScrollingIndicatorLayer->setBorderColor(Color::black);

        m_tiledScrollingIndicatorLayer->setBorderWidth(1);

        m_tiledScrollingIndicatorLayer->setPosition(FloatPoint(2, 2));

        m_visibleRectIndicatorLayer = PlatformCALayerMac::create(PlatformCALayer::LayerTypeLayer, nullptr);

        m_visibleRectIndicatorLayer->setBorderWidth(2);

        m_visibleRectIndicatorLayer->setAnchorPoint(FloatPoint3D());

        m_visibleRectIndicatorLayer->setBorderColor(Color(255, 0, 0));

        m_tiledScrollingIndicatorLayer->appendSublayer(m_visibleRectIndicatorLayer.get());

        updateTileCoverageMap();

    }

@@void TileController::setScrollingModeIndication(ScrollingModeIndication scrollin

        updateTileCoverageMap();

}

969 W~~ebTi~~leLayer* TileController::tileLayer~~AtIndex~~(const Tile~~Index& index) const~~

928RefPtr<PlatformCALayer> TileController::createTileLayer(const IntRect& tileRect)

970929{

971 return m_tiles.get(index).layer.get();

972 }

930 RefPtr<PlatformCALayer> layer = LayerPool::sharedPool()->takeLayerWithSize(tileRect.size());

973931

RetainPtr<WebTileLayer> TileController::createTileLayer(const IntRect& tileRect)

{

    RetainPtr<WebTileLayer> layer = LayerPool::sharedPool()->takeLayerWithSize(tileRect.size());

    if (layer)

        [layer resetPaintCount];

    else

        layer = adoptNS([[WebTileLayer alloc] init]);

    [layer.get() setAnchorPoint:CGPointZero];

    [layer.get() setFrame:tileRect];

    [layer.get() setTileController:this];

    [layer.get() setBorderColor:m_tileDebugBorderColor.get()];

    [layer.get() setBorderWidth:m_tileDebugBorderWidth];

    [layer.get() setEdgeAntialiasingMask:0];

    [layer.get() setOpaque:m_tilesAreOpaque];

    if (layer) {

        m_tileRepaintCounts.remove(layer.get());

        layer->setOwner(this);

    } else

        layer = PlatformCALayerMac::create(PlatformCALayer::LayerTypeTiledBackingTileLayer, this);

    layer->setAnchorPoint(FloatPoint3D());

    layer->setBounds(FloatRect(FloatPoint(), tileRect.size()));

    layer->setPosition(tileRect.location());

    layer->setBorderColor(m_tileDebugBorderColor);

    layer->setBorderWidth(m_tileDebugBorderWidth);

    layer->setEdgeAntialiasingMask(0);

    layer->setOpaque(m_tilesAreOpaque);

988945#ifndef NDEBUG

989 [layer~~.get()~~ setName:@"Tile"];

946 layer->setName("Tile");

990947#endif

991948

992 [layer~~.get()~~ setContentsScale:m_deviceScaleFactor];

993 [layer~~.get()~~ setAcceleratesDrawing:m_acceleratesDrawing];

949 layer->setContentsScale(m_deviceScaleFactor);

950 layer->setAcceleratesDrawing(m_acceleratesDrawing);

994951

995 [layer setNeedsDisplay];

952 layer->setNeedsDisplay();

    return layer;

}

1000 ~~bool~~ TileController::sh~~ouldShow~~RepaintCount~~ers() const~~

957int TileController::platformCALayerIncrementRepaintCount(PlatformCALayer* platformCALayer)

1001958{

    PlatformCALayer* platformLayer = PlatformCALayer::platformCALayer(m_tileCacheLayer);

    if (!platformLayer)

        return false;

    WebCore::PlatformCALayerClient* layerContents = platformLayer->owner();

    ASSERT(layerContents);

    if (!layerContents)

        return false;

    return layerContents->platformCALayerShowRepaintCounter(0);

}

959 int repaintCount = 0;

1013960

void TileController::drawRepaintCounter(WebTileLayer *layer, CGContextRef context)

{

    unsigned paintCount = [layer incrementPaintCount];

    if (!shouldShowRepaintCounters())

        return;

    // FIXME: Some of this code could be shared with WebLayer.

    char text[16]; // that's a lot of repaints

    snprintf(text, sizeof(text), "%d", paintCount);

    CGRect indicatorBox = [layer bounds];

    indicatorBox.size.width = 12 + 10 * strlen(text);

    indicatorBox.size.height = 27;

    CGContextSaveGState(context);

    CGContextSetAlpha(context, 0.5f);

    CGContextBeginTransparencyLayerWithRect(context, indicatorBox, 0);

    CGContextSetFillColorWithColor(context, m_tileDebugBorderColor.get());

    CGContextFillRect(context, indicatorBox);

    PlatformCALayer* platformLayer = PlatformCALayer::platformCALayer(m_tileCacheLayer);

    if (platformLayer->acceleratesDrawing())

        CGContextSetRGBFillColor(context, 1, 0, 0, 1);

    else

        CGContextSetRGBFillColor(context, 1, 1, 1, 1);

961 if (m_tileRepaintCounts.contains(platformCALayer))

962 repaintCount = m_tileRepaintCounts.get(platformCALayer);

1041963

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wdeprecated-declarations"

    CGContextSetTextMatrix(context, CGAffineTransformMakeScale(1, -1));

    CGContextSelectFont(context, "Helvetica", 22, kCGEncodingMacRoman);

    CGContextShowTextAtPoint(context, indicatorBox.origin.x + 5, indicatorBox.origin.y + 22, text, strlen(text));

#pragma clang diagnostic pop

964 m_tileRepaintCounts.set(platformCALayer, ++repaintCount);

1048965

1049 CGContextEndTransparencyLayer(context);

1050 CGContextRestoreGState(context);

966 return repaintCount;

}

void TileController::drawTileMapContents(CGContextRef context, CGRect layerBounds)

@@void TileController::drawTileMapContents(CGContextRef context, CGRect layerBound

    
    for (TileMap::const_iterator it = m_tiles.begin(), end = m_tiles.end(); it != end; ++it) {

        const TileInfo& tileInfo = it->value;

1065 ~~WebTi~~leLayer* tileLayer = tileInfo.layer.get();

981 PlatformCALayer* tileLayer = tileInfo.layer.get();

        CGFloat red = 1;

        CGFloat green = 1;

@@void TileController::drawTileMapContents(CGContextRef context, CGRect layerBound

        } else

            CGContextSetRGBFillColor(context, red, green, blue, 1);

1085 if ([tileLayer superlayer]) {

1001 if (tileLayer->superlayer()) {

            CGContextSetLineWidth(context, 0.5 / contextScale);

            CGContextSetRGBStrokeColor(context, 0, 0, 0, 1);

        } else {

@@void TileController::drawTileMapContents(CGContextRef context, CGRect layerBound

            CGContextSetRGBStrokeColor(context, 0.2, 0.1, 0.9, 1);

        }

1093 CGRect frame = [tileLayer frame];

1009 CGRect frame = CGRectMake(tileLayer->position().x(), tileLayer->position().y(), tileLayer->bounds().size().width(), tileLayer->bounds().size().height());

        CGContextFillRect(context, frame);

        CGContextStrokeRect(context, frame);

    }

Source/WebCore/platform/graphics/ca/mac/WebTileLayer.h

/*

 * Copyright (C) 2011 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#ifndef WebTileLayer_h

#define WebTileLayer_h

namespace WebCore {

class TileController;

}

@interface WebTileLayer : CALayer {

    WebCore::TileController* _tileController;

    unsigned _paintCount;

}

- (void)setTileController:(WebCore::TileController*)tileController;

- (void)resetPaintCount;

- (unsigned)incrementPaintCount;

- (unsigned)paintCount;

@end

#endif // WebTileLayer_h

Source/WebCore/platform/graphics/ca/mac/WebTileLayer.mm

/*

 * Copyright (C) 2011 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#import "config.h"

#import "WebTileLayer.h"

#import "TileController.h"

#import <wtf/CurrentTime.h>

using namespace WebCore;

@interface WebTileLayer (ScrollingPerformanceLoggingInternal)

- (void)logFilledFreshTile;

@end

@implementation WebTileLayer

- (id<CAAction>)actionForKey:(NSString *)key

{

    UNUSED_PARAM(key);

    // Disable all animations.

    return nil;

}

- (void)drawInContext:(CGContextRef)context

{

    if (_tileController) {

        _tileController->drawLayer(self, context);

        if (static_cast<TiledBacking*>(_tileController)->scrollingPerformanceLoggingEnabled())

            [self logFilledFreshTile];

    }

}

- (void)setTileController:(WebCore::TileController*)tileController

{

    _tileController = tileController;

}

- (void)resetPaintCount

{

    _paintCount = 0;

}

- (unsigned)incrementPaintCount

{

    return ++_paintCount;

}

- (unsigned)paintCount

{

    return _paintCount;

}

- (void)logFilledFreshTile

{

    FloatRect visiblePart([self frame]);

    visiblePart.intersect(_tileController->visibleRect());

    if ([self paintCount] == 1 && !visiblePart.isEmpty())

        WTFLogAlways("SCROLLING: Filled visible fresh tile. Time: %f Unfilled Pixels: %u\n", WTF::monotonicallyIncreasingTime(), _tileController->blankPixelCount());

}

@end

Source/WebCore/platform/graphics/ca/mac/WebTiledBackingLayer.h

namespace WebCore {

class IntRect;

34class PlatformCALayer;

class TileController;

class TiledBacking;

}

@@class TiledBacking;

    OwnPtr<WebCore::TileController> _tileController;

}

42 - (CALayer *)~~tileContainer~~Layer;

43- (WebCore::TileController*)createTileController:(WebCore::PlatformCALayer*)rootLayer;

- (WebCore::TiledBacking*)tiledBacking;

- (void)invalidate;

Source/WebCore/platform/graphics/ca/mac/WebTiledBackingLayer.mm

@@using namespace WebCore;

    if (!self)

        return nil;

43 _tileController = TileController::create(self);

#ifndef NDEBUG

    [self setName:@"WebTiledBackingLayer"];

#endif

@@using namespace WebCore;

    return nil;

}

- (TileController*)createTileController:(PlatformCALayer*)rootLayer

{

    ASSERT(!_tileController);

    _tileController = TileController::create(rootLayer);

    return _tileController.get();

}

- (id<CAAction>)actionForKey:(NSString *)key

{

    UNUSED_PARAM(key);

@@using namespace WebCore;

    _tileController->setScale(contentsScale);

}

- (CALayer *)tileContainerLayer

{

    return _tileController->tileContainerLayer();

}

- (WebCore::TiledBacking*)tiledBacking

{

    return _tileController.get();

@@using namespace WebCore;

- (void)setBorderColor:(CGColorRef)borderColor

{

134 _tileController->setTileDebugBorderColor(borderColor);

135 _tileController->setTileDebugBorderColor(Color(borderColor));

}

- (void)setBorderWidth:(CGFloat)borderWidth

Source/WebCore/platform/graphics/ca/win/PlatformCALayerWin.h

@@public:

    virtual float contentsScale() const OVERRIDE;

    virtual void setContentsScale(float) OVERRIDE;

129 virtual void setEdgeAntialiasingMask(unsigned) OVERRIDE { ASSERT_NOT_REACHED(); }

130

    virtual TiledBacking* tiledBacking() OVERRIDE { return nullptr; }

    virtual PlatformCALayer* rootLayer() const OVERRIDE;

Source/WebCore/platform/graphics/ca/win/PlatformCALayerWinInternal.cpp

@@void PlatformCALayerWinInternal::displayCallback(CACFLayerRef caLayer, CGContext

        // smaller than the layer bounds (e.g. tiled layers)

        CGRect clipBounds = CGContextGetClipBoundingBox(context);

        IntRect clip(enclosingIntRect(clipBounds));

86 owner()->owner()->platformCALayerPaintContents(graphicsContext, clip);

86 owner()->owner()->platformCALayerPaintContents(owner(), graphicsContext, clip);

    }

#ifndef NDEBUG

    else {

@@void PlatformCALayerWinInternal::displayCallback(CACFLayerRef caLayer, CGContext

    if (owner()->owner()->platformCALayerShowRepaintCounter(owner())) {

        FontCachePurgePreventer fontCachePurgePreventer;

102 String text = String::number(owner()->owner()->platformCALayerIncrementRepaintCount());

102 String text = String::number(owner()->owner()->platformCALayerIncrementRepaintCount(owner()));

        CGContextSaveGState(context);

Source/WebCore/platform/graphics/mac/WebLayer.h

const unsigned webLayerMaxRectsToPaint = 5;

const float webLayerWastedSpaceThreshold = 0.75f;

38 @interface WebLayer : CALayer

@interface WebSimpleLayer : CALayer

@end

@interface WebLayer : WebSimpleLayer

@end

namespace WebCore {

@@class PlatformCALayer;

class PlatformCALayerClient;

// Functions allows us to share implementation across WebTiledLayer and WebLayer

47 void drawLayerContents(CGContextRef, CALayer *, WebCore::PlatformCALayer*);

48 void drawLayerContents(CGContextRef, WebCore::PlatformCALayer*, WebCore::FloatRect layerBounds, Vector<WebCore::FloatRect, webLayerMaxRectsToPaint> dirtyRects, bool isTiledLayer);

void drawLayerContents(CGContextRef, WebCore::PlatformCALayer*);

void drawLayerContents(CGContextRef, WebCore::PlatformCALayer*, Vector<WebCore::FloatRect, webLayerMaxRectsToPaint> dirtyRects);

void drawRepaintIndicator(CGContextRef, WebCore::PlatformCALayer*, int repaintCount, CGColorRef customBackgroundColor);

}

#endif // USE(ACCELERATED_COMPOSITING)

Source/WebCore/platform/graphics/mac/WebLayer.mm

@@using namespace WebCore;

namespace WebCore {

48 void drawLayerContents(CGContextRef context, ~~CALayer *layer,~~ WebCore::PlatformCALayer* platformLayer)

48void drawLayerContents(CGContextRef context, WebCore::PlatformCALayer* platformCALayer)

4949{

50 CGRect layerBounds = [layer bounds];

51

    __block double totalRectArea = 0;

    __block unsigned rectCount = 0;

    __block Vector<FloatRect, webLayerMaxRectsToPaint> dirtyRects;

    wkCALayerEnumerateRectsBeingDrawnWithBlock(layer, context, ^(CGRect rect) {

        if (++rectCount > webLayerMaxRectsToPaint)

            return;

    if (PlatformLayer *platformLayer = platformCALayer->platformLayer()) {

        wkCALayerEnumerateRectsBeingDrawnWithBlock(platformLayer, context, ^(CGRect rect) {

            if (++rectCount > webLayerMaxRectsToPaint)

                return;

5958

        totalRectArea += rect.size.width * rect.size.height;

        dirtyRects.append(rect);

    });

            totalRectArea += rect.size.width * rect.size.height;

            dirtyRects.append(rect);

        });

    }

    FloatRect clipBounds = CGContextGetClipBoundingBox(context);

    double clipArea = clipBounds.width() * clipBounds.height();

@@void drawLayerContents(CGContextRef context, CALayer *layer, WebCore::PlatformCA

    if (rectCount >= webLayerMaxRectsToPaint || totalRectArea >= clipArea * webLayerWastedSpaceThreshold)

        dirtyRects.clear();

70 bool isTiledLayer = [layer isKindOfClass:[CATiledLayer class]];

71 drawLayerContents(context, platformLayer, layerBounds, dirtyRects, isTiledLayer);

70 drawLayerContents(context, platformCALayer, dirtyRects);

7271}

7372

74 void drawLayerContents(CGContextRef context, WebCore::PlatformCALayer* platformLayer~~, FloatRect layerBounds~~, Vector<FloatRect, webLayerMaxRectsToPaint> dirtyRects~~, bool isTiledLayer~~)

73void drawLayerContents(CGContextRef context, WebCore::PlatformCALayer* platformCALayer, Vector<FloatRect, webLayerMaxRectsToPaint> dirtyRects)

7574{

76 WebCore::PlatformCALayerClient* layerContents = platformLayer->owner();

75 WebCore::PlatformCALayerClient* layerContents = platformCALayer->owner();

    if (!layerContents)

        return;

    CGContextSaveGState(context);

    if (layerContents->platformCALayerContentsOrientation() == WebCore::GraphicsLayer::CompositingCoordinatesBottomUp) {

82 FloatRect layerBounds = platformCALayer->bounds();

        CGContextScaleCTM(context, 1, -1);

        CGContextTranslateCTM(context, 0, -layerBounds.height());

    }

@@void drawLayerContents(CGContextRef context, WebCore::PlatformCALayer* platformL

    GraphicsContext graphicsContext(context);

    graphicsContext.setIsCALayerContext(true);

96 graphicsContext.setIsAcceleratedContext(platformLayer->acceleratesDrawing());

96 graphicsContext.setIsAcceleratedContext(platformCALayer->acceleratesDrawing());

    if (!layerContents->platformCALayerContentsOpaque()) {

        // Turn off font smoothing to improve the appearance of text rendered onto a transparent background.

@@void drawLayerContents(CGContextRef context, WebCore::PlatformCALayer* platformL

    if (dirtyRects.isEmpty()) {

        // CGContextGetClipBoundingBox() gives us the bounds of the dirty region, so clipBounds

        // encompasses all the dirty rects.

119 layerContents->platformCALayerPaintContents(graphicsContext, enclosingIntRect(clipBounds));

119 layerContents->platformCALayerPaintContents(platformCALayer, graphicsContext, enclosingIntRect(clipBounds));

    } else {

        for (unsigned i = 0; i < dirtyRects.size(); ++i) {

            const FloatRect& currentRect = dirtyRects[i];

@@void drawLayerContents(CGContextRef context, WebCore::PlatformCALayer* platformL

            GraphicsContextStateSaver stateSaver(graphicsContext);

            graphicsContext.clip(currentRect);

127 layerContents->platformCALayerPaintContents(graphicsContext, enclosingIntRect(currentRect));

127 layerContents->platformCALayerPaintContents(platformCALayer, graphicsContext, enclosingIntRect(currentRect));

        }

    }

@@void drawLayerContents(CGContextRef context, WebCore::PlatformCALayer* platformL

    [NSGraphicsContext restoreGraphicsState];

    // Re-fetch the layer owner, since <rdar://problem/9125151> indicates that it might have been destroyed during painting.

136 layerContents = platformLayer->owner();

136 layerContents = platformCALayer->owner();

    ASSERT(layerContents);

    CGContextRestoreGState(context);

    // Always update the repaint count so that it's accurate even if the count itself is not shown. This will be useful

    // for the Web Inspector feeding this information through the LayerTreeAgent. 

    int repaintCount = layerContents->platformCALayerIncrementRepaintCount();

    if (!platformLayer->usesTiledBackingLayer() && layerContents && layerContents->platformCALayerShowRepaintCounter(platformLayer)) {

        char text[16]; // that's a lot of repaints

        snprintf(text, sizeof(text), "%d", repaintCount);

        CGRect indicatorBox = layerBounds;

        indicatorBox.size.width = 12 + 10 * strlen(text);

        indicatorBox.size.height = 27;

        CGContextSaveGState(context);

        CGContextSetAlpha(context, 0.5f);

        CGContextBeginTransparencyLayerWithRect(context, indicatorBox, 0);

        if (isTiledLayer)

            CGContextSetRGBFillColor(context, 1, 0.5f, 0, 1);

        else

            CGContextSetRGBFillColor(context, 0, 0.5f, 0.25f, 1);

        CGContextFillRect(context, indicatorBox);

        if (platformLayer->acceleratesDrawing())

            CGContextSetRGBFillColor(context, 1, 0, 0, 1);

        else

            CGContextSetRGBFillColor(context, 1, 1, 1, 1);

    // for the Web Inspector feeding this information through the LayerTreeAgent.

    int repaintCount = layerContents->platformCALayerIncrementRepaintCount(platformCALayer);

    if (!platformCALayer->usesTiledBackingLayer() && layerContents && layerContents->platformCALayerShowRepaintCounter(platformCALayer))

        drawRepaintIndicator(context, platformCALayer, repaintCount, nullptr);

}

void drawRepaintIndicator(CGContextRef context, PlatformCALayer* platformCALayer, int repaintCount, CGColorRef customBackgroundColor)

{

    char text[16]; // that's a lot of repaints

    snprintf(text, sizeof(text), "%d", repaintCount);

    CGRect indicatorBox = platformCALayer->bounds();

    indicatorBox.size.width = 12 + 10 * strlen(text);

    indicatorBox.size.height = 27;

    CGContextSaveGState(context);

    CGContextSetAlpha(context, 0.5f);

    CGContextBeginTransparencyLayerWithRect(context, indicatorBox, 0);

    if (customBackgroundColor)

        CGContextSetFillColorWithColor(context, customBackgroundColor);

    else

        CGContextSetRGBFillColor(context, 0, 0.5f, 0.25f, 1);

    CGContextFillRect(context, indicatorBox);

    if (platformCALayer->acceleratesDrawing())

        CGContextSetRGBFillColor(context, 1, 0, 0, 1);

    else

        CGContextSetRGBFillColor(context, 1, 1, 1, 1);

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wdeprecated-declarations"

        CGContextSetTextMatrix(context, CGAffineTransformMakeScale(1, -1));

        CGContextSelectFont(context, "Helvetica", 22, kCGEncodingMacRoman);

        CGContextShowTextAtPoint(context, indicatorBox.origin.x + 5, indicatorBox.origin.y + 22, text, strlen(text));

    CGContextSetTextMatrix(context, CGAffineTransformMakeScale(1, -1));

    CGContextSelectFont(context, "Helvetica", 22, kCGEncodingMacRoman);

    CGContextShowTextAtPoint(context, indicatorBox.origin.x + 5, indicatorBox.origin.y + 22, text, strlen(text));

174179#pragma clang diagnostic pop

175180

        CGContextEndTransparencyLayer(context);

        CGContextRestoreGState(context);

    }

181 CGContextEndTransparencyLayer(context);

182 CGContextRestoreGState(context);

}

}

@implementation WebLayer

- (void)drawInContext:(CGContextRef)context

{

    PlatformCALayer* layer = PlatformCALayer::platformCALayer(self);

    if (layer)

        drawLayerContents(context, layer);

}

@end // implementation WebLayer

@implementation WebSimpleLayer

- (id<CAAction>)actionForKey:(NSString *)key

{

    // Fix for <rdar://problem/9015675>: Force the layer content to be updated when the tree is reparented.

@@void drawLayerContents(CGContextRef context, WebCore::PlatformCALayer* platformL

- (void)drawInContext:(CGContextRef)context

{

    PlatformCALayer* layer = PlatformCALayer::platformCALayer(self);

239 if (layer)

240 drawLayerContents(context, self, layer);

    if (layer && layer->owner()) {

        GraphicsContext graphicsContext(context);

        graphicsContext.setIsCALayerContext(true);

        graphicsContext.setIsAcceleratedContext(layer->acceleratesDrawing());

        FloatRect clipBounds = CGContextGetClipBoundingBox(context);

        layer->owner()->platformCALayerPaintContents(layer, graphicsContext, enclosingIntRect(clipBounds));

    }

241262}

242263

243 @end // implementation WebLayer

264@end // implementation WebSimpleLayer

// MARK: -

Source/WebCore/platform/graphics/mac/WebTiledLayer.mm

@@using namespace WebCore;

{

    PlatformCALayer* layer = PlatformCALayer::platformCALayer(self);

    if (layer)

110 drawLayerContents(context, ~~self,~~ layer);

110 drawLayerContents(context, layer);

}

@end // implementation WebTiledLayer

Source/WebCore/platform/graphics/win/MediaPlayerPrivateQuickTimeVisualContext.cpp

@@private:

    virtual void platformCALayerAnimationStarted(CFTimeInterval beginTime) { }

    virtual GraphicsLayer::CompositingCoordinatesOrientation platformCALayerContentsOrientation() const { return GraphicsLayer::CompositingCoordinatesBottomUp; }

103 virtual void platformCALayerPaintContents(GraphicsContext&, const IntRect& inClip) { }

103 virtual void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const IntRect& inClip) { }

104104 virtual bool platformCALayerShowDebugBorders() const { return false; }

105105 virtual bool platformCALayerShowRepaintCounter(PlatformCALayer*) const { return false; }

106 virtual int platformCALayerIncrementRepaintCount() { return 0; }

106 virtual int platformCALayerIncrementRepaintCount(PlatformCALayer*) { return 0; }

    virtual bool platformCALayerContentsOpaque() const { return false; }

    virtual bool platformCALayerDrawsContent() const { return false; }

Source/WebKit/win/ChangeLog

2013-10-25  Tim Horton  <timothy_horton@apple.com>

        Make TileController manipulate PlatformCALayers instead of CALayers

        https://bugs.webkit.org/show_bug.cgi?id=123279

        Reviewed by NOBODY (OOPS!).

        * FullscreenVideoController.cpp:

        (FullscreenVideoController::LayerClient::platformCALayerPaintContents):

        (FullscreenVideoController::LayerClient::platformCALayerIncrementRepaintCount):

        Adjust for new parameters on PlatformCALayerClient callbacks.

2013-10-16  Tim Horton  <timothy_horton@apple.com>

        Attempt to fix the Windows build after http://trac.webkit.org/changeset/157547.

Source/WebKit/win/FullscreenVideoController.cpp

@@private:

    virtual void platformCALayerAnimationStarted(CFTimeInterval beginTime) { }

    virtual GraphicsLayer::CompositingCoordinatesOrientation platformCALayerContentsOrientation() const { return GraphicsLayer::CompositingCoordinatesBottomUp; }

190 virtual void platformCALayerPaintContents(GraphicsContext&, const IntRect& inClip) { }

190 virtual void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const IntRect& inClip) { }

191191 virtual bool platformCALayerShowDebugBorders() const { return false; }

192192 virtual bool platformCALayerShowRepaintCounter(PlatformCALayer*) const { return false; }

193 virtual int platformCALayerIncrementRepaintCount() { return 0; }

193 virtual int platformCALayerIncrementRepaintCount(PlatformCALayer*) { return 0; }

    virtual bool platformCALayerContentsOpaque() const { return false; }

    virtual bool platformCALayerDrawsContent() const { return false; }

Source/WebKit2/ChangeLog

2013-10-24  Tim Horton  <timothy_horton@apple.com>

        Make TileController manipulate PlatformCALayers instead of CALayers

        https://bugs.webkit.org/show_bug.cgi?id=123279

        Reviewed by NOBODY (OOPS!).

        * Shared/mac/RemoteLayerTreeTransaction.mm:

        (WebKit::RemoteLayerTreeTransaction::dump):

        Support the new LayerTypes.

        * WebProcess/WebPage/mac/PlatformCALayerRemote.cpp:

        (PlatformCALayerRemote::setEdgeAntialiasingMask):

        * WebProcess/WebPage/mac/PlatformCALayerRemote.h:

        Add an empty implementation of setEdgeAntialiasingMask.

        * WebProcess/WebPage/mac/RemoteLayerBackingStore.mm:

        (RemoteLayerBackingStore::display):

        Removed a parameter from drawLayerContents.

        * WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm:

        (WebKit::TiledCoreAnimationDrawingArea::updateDebugInfoLayer):

        TiledCoreAnimationDrawingArea still operates in terms of CALayers, so

        grab the PlatformLayer out from TileController's indicator.

2013-10-23  Tim Horton  <timothy_horton@apple.com>

        Remove the ifdef to exclude remote layer tree transaction logging

Source/WebKit2/Shared/mac/RemoteLayerTreeTransaction.mm

@@void RemoteLayerTreeTransaction::dump() const

            switch (createdLayer.type) {

            case PlatformCALayer::LayerTypeLayer:

            case PlatformCALayer::LayerTypeWebLayer:

658 case PlatformCALayer::LayerTypeSimpleLayer:

                ts << "layer";

                break;

            case PlatformCALayer::LayerTypeTransformLayer:

@@void RemoteLayerTreeTransaction::dump() const

            case PlatformCALayer::LayerTypePageTiledBackingLayer:

                ts << "page-tiled-backing-layer";

                break;

            case PlatformCALayer::LayerTypeTiledBackingTileLayer:

                ts << "tiled-backing-tile";

                break;

            case PlatformCALayer::LayerTypeRootLayer:

                ts << "root-layer";

                break;

Source/WebKit2/WebProcess/WebPage/mac/PlatformCALayerRemote.cpp

@@void PlatformCALayerRemote::setContentsScale(float value)

    ensureBackingStore();

}

void PlatformCALayerRemote::setEdgeAntialiasingMask(unsigned)

{

    ASSERT_NOT_REACHED();

}

TiledBacking* PlatformCALayerRemote::tiledBacking()

{

    return nullptr;

Source/WebKit2/WebProcess/WebPage/mac/PlatformCALayerRemote.h

@@public:

    virtual float contentsScale() const OVERRIDE;

    virtual void setContentsScale(float) OVERRIDE;

140 virtual void setEdgeAntialiasingMask(unsigned) OVERRIDE;

141

    virtual WebCore::TiledBacking* tiledBacking() OVERRIDE;

    virtual void synchronouslyDisplayTilesInRect(const WebCore::FloatRect&) OVERRIDE;

Source/WebKit2/WebProcess/WebPage/mac/RemoteLayerBackingStore.mm

@@bool RemoteLayerBackingStore::display()

    }

    context->scale(FloatSize(m_scale, m_scale));

152 drawLayerContents(context->platformContext(), m_layer, ~~FloatRect(FloatPoint(), scaledSize),~~ rectsToPaint~~, false~~);

152 drawLayerContents(context->platformContext(), m_layer, rectsToPaint);

    m_dirtyRegion = Region();

    m_frontBuffer = m_backBuffer;

Source/WebKit2/WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm

@@TiledBacking* TiledCoreAnimationDrawingArea::mainFrameTiledBacking() const

void TiledCoreAnimationDrawingArea::updateDebugInfoLayer(bool showLayer)

{

    if (showLayer) {

        if (TiledBacking* tiledBacking = mainFrameTiledBacking())

            m_debugInfoLayer = tiledBacking->tiledScrollingIndicatorLayer();

        if (TiledBacking* tiledBacking = mainFrameTiledBacking()) {

            if (PlatformCALayer* indicatorLayer = tiledBacking->tiledScrollingIndicatorLayer())

                m_debugInfoLayer = indicatorLayer->platformLayer();

        }

        if (m_debugInfoLayer) {

#ifndef NDEBUG

            [m_debugInfoLayer.get() setName:@"Debug Info"];