Use tile caches in place of CATiledLayer

https://bugs.webkit.org/show_bug.cgi?id=99806
<rdar://problem/6474145>

Reviewed by Tim Horton.

Have GraphicsLayerCA use TileCaches instead of CATiledLayer now for
layers that exceed the 2000px size threshold.

* platform/graphics/TiledBacking.h:
(TiledBacking): Have normal getter and setter for the visible rect.
* platform/graphics/ca/GraphicsLayerCA.cpp:
(WebCore::GraphicsLayerCA::flushCompositingStateForThisLayerOnly): We need
to pass in an old visibleRect to commitLayerChangesBeforeSublayers(). Just use
our current visible rect, which result in no tile area work.
(WebCore::GraphicsLayerCA::computeVisibleRect): Make this const and have it
return the rect, for clarity.
(WebCore::GraphicsLayerCA::recursiveCommitChanges): Keep track of the old
visible rect, and use the change flags mechanism to ensure that we recompute
tile areas later.
When calling commitLayerChangesBeforeSublayers() on the mask layer, just pass
its own visible rect as the old visible rect.
(WebCore::GraphicsLayerCA::commitLayerChangesBeforeSublayers): Pass in the
oldVisibleRect so that updateVisibleRect() can use this to see how the
visibleRect is changing.
(WebCore::GraphicsLayerCA::adjustTiledLayerVisibleRect): This member function
compares the old and new visible rects, and extends the tile coverage area
in directions where more content is being exposed. It takes care to avoid
"jitter" in the visible rect deltas causing edge tiles to get created then
destroyed by keeping any extra padding that already exists in a direction
where more content is being exposed.
(WebCore::GraphicsLayerCA::updateVisibleRect): Call adjustTiledLayerVisibleRect()
and use the result to update the TiledBacking's visibleRect.
(WebCore::GraphicsLayerCA::swapFromOrToTiledLayer): Create layers of type
LayerTypeTileCacheLayer instead of LayerTypeWebTiledLayer. Because tile
cache layers involve adding an extra layer to the hierarchy (the tile container),
we call updateSublayerList() when changing layer type.
* platform/graphics/ca/GraphicsLayerCA.h: New m_sizeAtLastVisibleRectUpdate member
that is used to prevent the adjustTiledLayerVisibleRect() logic being confused by
size changes.
(WebCore::GraphicsLayerCA::visibleRect):
* platform/graphics/ca/mac/TileCache.h: Have normal getter and setter for the visible rect.
* platform/graphics/ca/mac/TileCache.mm:
(WebCore::TileCache::setVisibleRect): Renamed to setVisibleRect().
* rendering/RenderLayerCompositor.cpp:
(WebCore::RenderLayerCompositor::flushPendingLayerChanges): Avoid doing work
for pages in the page cache, for which the root layer is unattached.
(WebCore::RenderLayerCompositor::frameViewDidScroll): visibleRectChanged() was renamed
to setVisibleRect().

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

Author: [email protected]

Source/WebCore/ChangeLog

@@ -1,3 +1,55 @@
+2012-10-19  Simon Fraser  <[email protected]>
+
+        Use tile caches in place of CATiledLayer
+        https://bugs.webkit.org/show_bug.cgi?id=99806
+        <rdar://problem/6474145>
+
+        Reviewed by Tim Horton.
+
+        Have GraphicsLayerCA use TileCaches instead of CATiledLayer now for
+        layers that exceed the 2000px size threshold.
+
+        * platform/graphics/TiledBacking.h:
+        (TiledBacking): Have normal getter and setter for the visible rect.
+        * platform/graphics/ca/GraphicsLayerCA.cpp:
+        (WebCore::GraphicsLayerCA::flushCompositingStateForThisLayerOnly): We need
+        to pass in an old visibleRect to commitLayerChangesBeforeSublayers(). Just use
+        our current visible rect, which result in no tile area work.
+        (WebCore::GraphicsLayerCA::computeVisibleRect): Make this const and have it
+        return the rect, for clarity.
+        (WebCore::GraphicsLayerCA::recursiveCommitChanges): Keep track of the old
+        visible rect, and use the change flags mechanism to ensure that we recompute
+        tile areas later.
+        When calling commitLayerChangesBeforeSublayers() on the mask layer, just pass
+        its own visible rect as the old visible rect.
+        (WebCore::GraphicsLayerCA::commitLayerChangesBeforeSublayers): Pass in the
+        oldVisibleRect so that updateVisibleRect() can use this to see how the
+        visibleRect is changing.
+        (WebCore::GraphicsLayerCA::adjustTiledLayerVisibleRect): This member function
+        compares the old and new visible rects, and extends the tile coverage area
+        in directions where more content is being exposed. It takes care to avoid
+        "jitter" in the visible rect deltas causing edge tiles to get created then
+        destroyed by keeping any extra padding that already exists in a direction
+        where more content is being exposed.
+        (WebCore::GraphicsLayerCA::updateVisibleRect): Call adjustTiledLayerVisibleRect()
+        and use the result to update the TiledBacking's visibleRect.
+        (WebCore::GraphicsLayerCA::swapFromOrToTiledLayer): Create layers of type
+        LayerTypeTileCacheLayer instead of LayerTypeWebTiledLayer. Because tile
+        cache layers involve adding an extra layer to the hierarchy (the tile container),
+        we call updateSublayerList() when changing layer type.
+        * platform/graphics/ca/GraphicsLayerCA.h: New m_sizeAtLastVisibleRectUpdate member
+        that is used to prevent the adjustTiledLayerVisibleRect() logic being confused by
+        size changes.
+        (WebCore::GraphicsLayerCA::visibleRect):
+        * platform/graphics/ca/mac/TileCache.h: Have normal getter and setter for the visible rect.
+        * platform/graphics/ca/mac/TileCache.mm:
+        (WebCore::TileCache::setVisibleRect): Renamed to setVisibleRect().
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::RenderLayerCompositor::flushPendingLayerChanges): Avoid doing work
+        for pages in the page cache, for which the root layer is unattached.
+        (WebCore::RenderLayerCompositor::frameViewDidScroll): visibleRectChanged() was renamed
+        to setVisibleRect().
+
 2012-10-19  Beth Dakin  <[email protected]>
 
         https://bugs.webkit.org/show_bug.cgi?id=99768

Source/WebCore/platform/graphics/TiledBacking.h

@@ -34,7 +34,9 @@ class TiledBacking {
 public:
     virtual ~TiledBacking() { }
 
-    virtual void visibleRectChanged(const IntRect&) = 0;
+    virtual void setVisibleRect(const IntRect&) = 0;
+    virtual IntRect visibleRect() const = 0;
+
     virtual void setIsInWindow(bool) = 0;
 
     enum {

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

@@ -38,6 +38,7 @@
 #include "ScaleTransformOperation.h"
 #include "SystemTime.h"
 #include "TextStream.h"
+#include "TiledBacking.h"
 #include "TransformState.h"
 #include "TranslateTransformOperation.h"
 #include <QuartzCore/CATransform3D.h>
@@ -905,7 +906,7 @@ void GraphicsLayerCA::flushCompositingStateForThisLayerOnly()
 {
     float pageScaleFactor;
     FloatPoint offset = computePositionRelativeToBase(pageScaleFactor);
-    commitLayerChangesBeforeSublayers(pageScaleFactor, offset);
+    commitLayerChangesBeforeSublayers(pageScaleFactor, offset, m_visibleRect);
     commitLayerChangesAfterSublayers();
 }
 
@@ -914,7 +915,7 @@ TiledBacking* GraphicsLayerCA::tiledBacking()
     return m_layer->tiledBacking();
 }
 
-void GraphicsLayerCA::computeVisibleRect(TransformState& state)
+FloatRect GraphicsLayerCA::computeVisibleRect(TransformState& state) const
 {
     bool preserve3D = preserves3D() || (parent() ? parent()->preserves3D() : false);
     TransformState::TransformAccumulation accumulation = preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform;
@@ -954,13 +955,19 @@ void GraphicsLayerCA::computeVisibleRect(TransformState& state)
         state.setQuad(clipRectForSelf);
     }
 
-    m_visibleRect = clipRectForSelf;
+    return clipRectForSelf;
 }
 
 void GraphicsLayerCA::recursiveCommitChanges(const TransformState& state, float pageScaleFactor, const FloatPoint& positionRelativeToBase, bool affectedByPageScale)
 {
     TransformState localState = state;
-    computeVisibleRect(localState);
+    
+    FloatRect visibleRect = computeVisibleRect(localState);
+    FloatRect oldVisibleRect = m_visibleRect;
+    if (visibleRect != m_visibleRect) {
+        m_uncommittedChanges |= VisibleRectChanged;
+        m_visibleRect = visibleRect;
+    }
 
 #ifdef VISIBLE_TILE_WASH
     // Use having a transform as a key to making the tile wash layer. If every layer gets a wash,
@@ -995,10 +1002,12 @@ void GraphicsLayerCA::recursiveCommitChanges(const TransformState& state, float
     if (affectedByPageScale)
         baseRelativePosition += m_position;
 
-    commitLayerChangesBeforeSublayers(pageScaleFactor, baseRelativePosition);
+    commitLayerChangesBeforeSublayers(pageScaleFactor, baseRelativePosition, oldVisibleRect);
 
-    if (m_maskLayer)
-        static_cast<GraphicsLayerCA*>(m_maskLayer)->commitLayerChangesBeforeSublayers(pageScaleFactor, baseRelativePosition);
+    if (m_maskLayer) {
+        GraphicsLayerCA* maskLayerCA = static_cast<GraphicsLayerCA*>(m_maskLayer);
+        maskLayerCA->commitLayerChangesBeforeSublayers(pageScaleFactor, baseRelativePosition, maskLayerCA->visibleRect());
+    }
 
     const Vector<GraphicsLayer*>& childLayers = children();
     size_t numChildren = childLayers.size();
@@ -1055,7 +1064,7 @@ float GraphicsLayerCA::platformCALayerDeviceScaleFactor()
     return deviceScaleFactor();
 }
 
-void GraphicsLayerCA::commitLayerChangesBeforeSublayers(float pageScaleFactor, const FloatPoint& positionRelativeToBase)
+void GraphicsLayerCA::commitLayerChangesBeforeSublayers(float pageScaleFactor, const FloatPoint& positionRelativeToBase, const FloatRect& oldVisibleRect)
 {
     if (!m_uncommittedChanges)
         return;
@@ -1122,6 +1131,9 @@ void GraphicsLayerCA::commitLayerChangesBeforeSublayers(float pageScaleFactor, c
     if (m_uncommittedChanges & ContentsScaleChanged)
         updateContentsScale(pageScaleFactor, positionRelativeToBase);
 
+    if (m_uncommittedChanges & VisibleRectChanged)
+        updateVisibleRect(oldVisibleRect);
+
     if (m_uncommittedChanges & DirtyRectsChanged)
         repaintLayerDirtyRects();
 
@@ -1535,7 +1547,78 @@ void GraphicsLayerCA::updateAcceleratesDrawing()
 {
     m_layer->setAcceleratesDrawing(m_acceleratesDrawing);
 }
+
+FloatRect GraphicsLayerCA::adjustTiledLayerVisibleRect(TiledBacking* tiledBacking, const FloatRect& oldVisibleRect, const FloatSize& oldSize) const
+{
+    // If the old visible rect is empty, we have no information about how the visible area is changing
+    // (maybe the layer was just created), so don't attempt to expand. Also don't attempt to expand
+    // if the size changed.
+    if (oldVisibleRect.isEmpty() || m_size != oldSize)
+        return m_visibleRect;
+
+    const float paddingMultiplier = 2;
+
+    float leftEdgeDelta = paddingMultiplier * (m_visibleRect.x() - oldVisibleRect.x());
+    float rightEdgeDelta = paddingMultiplier * (m_visibleRect.maxX() - oldVisibleRect.maxX());
+
+    float topEdgeDelta = paddingMultiplier * (m_visibleRect.y() - oldVisibleRect.y());
+    float bottomEdgeDelta = paddingMultiplier * (m_visibleRect.maxY() - oldVisibleRect.maxY());
 
+    FloatRect existingTileBackingRect = tiledBacking->visibleRect();
+    FloatRect expandedRect = m_visibleRect;
+
+    // More exposed on left side.
+    if (leftEdgeDelta < 0) {
+        float newLeft = expandedRect.x() + leftEdgeDelta;
+        // Pad to the left, but don't reduce padding that's already in the backing store (since we're still exposing to the left).
+        if (newLeft < existingTileBackingRect.x())
+            expandedRect.shiftXEdgeTo(newLeft);
+        else
+            expandedRect.shiftXEdgeTo(existingTileBackingRect.x());
+    }
+
+    // More exposed on right.
+    if (rightEdgeDelta > 0) {
+        float newRight = expandedRect.maxX() + rightEdgeDelta;
+        // Pad to the right, but don't reduce padding that's already in the backing store (since we're still exposing to the right).
+        if (newRight > existingTileBackingRect.maxX())
+            expandedRect.setWidth(newRight - expandedRect.x());
+        else
+            expandedRect.setWidth(existingTileBackingRect.maxX() - expandedRect.x());
+    }
+
+    // More exposed at top.
+    if (topEdgeDelta < 0) {
+        float newTop = expandedRect.y() + topEdgeDelta;
+        if (newTop < existingTileBackingRect.y())
+            expandedRect.shiftYEdgeTo(newTop);
+        else
+            expandedRect.shiftYEdgeTo(existingTileBackingRect.y());
+    }
+
+    // More exposed on bottom.
+    if (bottomEdgeDelta > 0) {
+        float newBottom = expandedRect.maxY() + bottomEdgeDelta;
+        if (newBottom > existingTileBackingRect.maxY())
+            expandedRect.setHeight(newBottom - expandedRect.y());
+        else
+            expandedRect.setHeight(existingTileBackingRect.maxY() - expandedRect.y());
+    }
+    
+    return expandedRect;
+}
+
+void GraphicsLayerCA::updateVisibleRect(const FloatRect& oldVisibleRect)
+{
+    if (m_layer->layerType() != PlatformCALayer::LayerTypeTileCacheLayer)
+        return;
+
+    FloatRect tileArea = adjustTiledLayerVisibleRect(tiledBacking(), oldVisibleRect, m_sizeAtLastVisibleRectUpdate);
+    tiledBacking()->setVisibleRect(enclosingIntRect(tileArea));
+
+    m_sizeAtLastVisibleRectUpdate = m_size;
+}
+
 void GraphicsLayerCA::updateLayerBackgroundColor()
 {
     if (m_isPageTileCacheLayer) {
@@ -2501,7 +2584,7 @@ void GraphicsLayerCA::swapFromOrToTiledLayer(bool useTiledLayer, float pageScale
     ASSERT(useTiledLayer != m_usingTiledLayer);
     RefPtr<PlatformCALayer> oldLayer = m_layer;
 
-    m_layer = PlatformCALayer::create(useTiledLayer ? PlatformCALayer::LayerTypeWebTiledLayer : PlatformCALayer::LayerTypeWebLayer, this);
+    m_layer = PlatformCALayer::create(useTiledLayer ? PlatformCALayer::LayerTypeTileCacheLayer : PlatformCALayer::LayerTypeWebLayer, this);
     m_usingTiledLayer = useTiledLayer;
 
     m_layer->adoptSublayers(oldLayer.get());
@@ -2520,6 +2603,7 @@ void GraphicsLayerCA::swapFromOrToTiledLayer(bool useTiledLayer, float pageScale
     updateGeometry(pageScaleFactor, positionRelativeToBase);
     updateTransform();
     updateChildrenTransform();
+    updateSublayerList();
     updateMasksToBounds();
 #if ENABLE(CSS_FILTERS)
     updateFilters();

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

@@ -211,7 +211,7 @@ class GraphicsLayerCA : public GraphicsLayer, public PlatformCALayerClient {
         return m_runningAnimations.find(animationName) != m_runningAnimations.end();
     }
 
-    void commitLayerChangesBeforeSublayers(float pageScaleFactor, const FloatPoint& positionRelativeToBase);
+    void commitLayerChangesBeforeSublayers(float pageScaleFactor, const FloatPoint& positionRelativeToBase, const FloatRect& oldVisibleRect);
     void commitLayerChangesAfterSublayers();
 
     FloatPoint computePositionRelativeToBase(float& pageScale) const;
@@ -233,7 +233,10 @@ class GraphicsLayerCA : public GraphicsLayer, public PlatformCALayerClient {
 
     void computePixelAlignment(float pixelAlignmentScale, const FloatPoint& positionRelativeToBase,
         FloatPoint& position, FloatSize&, FloatPoint3D& anchorPoint, FloatSize& alignmentOffset) const;
-    void computeVisibleRect(TransformState&);
+    FloatRect computeVisibleRect(TransformState&) const;
+    const FloatRect& visibleRect() const { return m_visibleRect; }
+    
+    FloatRect adjustTiledLayerVisibleRect(TiledBacking*, const FloatRect& oldVisibleRect, const FloatSize& oldSize) const;
 
     // Used to track the path down the tree for replica layers.
     struct ReplicaState {
@@ -323,6 +326,7 @@ class GraphicsLayerCA : public GraphicsLayer, public PlatformCALayerClient {
     void updateLayerAnimations();
     void updateContentsNeedsDisplay();
     void updateAcceleratesDrawing();
+    void updateVisibleRect(const FloatRect& oldVisibleRect);
     void updateContentsScale(float pixelAlignmentScale, const FloatPoint& positionRelativeToBase);
 
     enum StructuralLayerPurpose {
@@ -372,8 +376,9 @@ class GraphicsLayerCA : public GraphicsLayer, public PlatformCALayerClient {
         AcceleratesDrawingChanged = 1 << 22,
         ContentsScaleChanged = 1 << 23,
         ContentsVisibilityChanged = 1 << 24,
+        VisibleRectChanged = 1 << 25,
 #if ENABLE(CSS_FILTERS)
-        FiltersChanged = 1 << 25,
+        FiltersChanged = 1 << 26,
 #endif
     };
     typedef unsigned LayerChangeFlags;
@@ -396,6 +401,7 @@ class GraphicsLayerCA : public GraphicsLayer, public PlatformCALayerClient {
     RefPtr<PlatformCALayer> m_visibleTileWashLayer;
 #endif
     FloatRect m_visibleRect;
+    FloatSize m_sizeAtLastVisibleRectUpdate;
 
     enum ContentsLayerPurpose {
         NoContentsLayer = 0,

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

@@ -73,7 +73,7 @@ class TileCache : public TiledBacking {
     void setTileDebugBorderWidth(float);
     void setTileDebugBorderColor(CGColorRef);
 
-    IntRect visibleRect() const { return m_visibleRect; }
+    virtual IntRect visibleRect() const OVERRIDE { return m_visibleRect; }
 
     unsigned blankPixelCount() const;
     static unsigned blankPixelCountForTiles(const WebTileLayerList&, IntRect, IntPoint);
@@ -82,7 +82,7 @@ class TileCache : public TiledBacking {
     TileCache(WebTileCacheLayer*, const IntSize& tileSize);
 
     // TiledBacking member functions.
-    virtual void visibleRectChanged(const IntRect&) OVERRIDE;
+    virtual void setVisibleRect(const IntRect&) OVERRIDE;
     virtual void setIsInWindow(bool) OVERRIDE;
     virtual void setTileCoverage(TileCoverage) OVERRIDE;
     virtual TileCoverage tileCoverage() const OVERRIDE { return m_tileCoverage; }

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

@@ -220,7 +220,7 @@ - (void)setAcceleratesDrawing:(BOOL)flag;
     }
 }
 
-void TileCache::visibleRectChanged(const IntRect& visibleRect)
+void TileCache::setVisibleRect(const IntRect& visibleRect)
 {
     if (m_visibleRect == visibleRect)
         return;

Source/WebCore/rendering/RenderLayerCompositor.cpp

@@ -283,6 +283,9 @@ void RenderLayerCompositor::flushPendingLayerChanges(bool isFlushRoot)
     if (!isFlushRoot && rootLayerAttachment() == RootLayerAttachedViaEnclosingFrame)
         return;
 
+    if (rootLayerAttachment() == RootLayerUnattached)
+        return;
+
     AnimationUpdateBlock animationUpdateBlock(m_renderView->frameView()->frame()->animation());
 
     ASSERT(!m_flushingLayers);
@@ -1097,7 +1100,7 @@ void RenderLayerCompositor::frameViewDidScroll()
     if (TiledBacking* tiledBacking = frameView->tiledBacking()) {
         IntRect visibleContentRect = frameView->visibleContentRect(false /* exclude scrollbars */);
         visibleContentRect.move(toSize(frameView->scrollOrigin()));
-        tiledBacking->visibleRectChanged(visibleContentRect);
+        tiledBacking->setVisibleRect(visibleContentRect);
     }
 
     if (!m_scrollLayer)