Land layer squashing behind a flag

Source/core/rendering/CompositedLayerMapping.h

 /*
  * Copyright (C) 2009, 2010, 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
@@ skipping 34 matching lines @@
     ContainerCompositingLayer // layer with no backing store
 };
 
 
 // A GraphicsLayerPaintInfo contains all the info needed to paint a partial subtree of RenderLayers into a GraphicsLayer.
 struct GraphicsLayerPaintInfo {
     RenderLayer* renderLayer;
 
     IntRect compositedBounds;
 
+    // A temporary offset used for squashing layers, when the origin of the
+    // squashing layer is not yet known.
+    IntSize offsetFromBackingRoot;
+
     IntSize offsetFromRenderer;
 
     GraphicsLayerPaintingPhase paintingPhase;
 
     bool isBackgroundLayer;
 };
 
 // CompositedLayerMapping keeps track of how RenderLayers of the render tree correspond to
 // GraphicsLayers of the composited layer tree. Each instance of CompositedLayerMapping
 // manages a small cluster of GraphicsLayers and the references to which RenderLayers
@@ skipping 43 matching lines @@
     bool hasScrollingLayer() const { return m_scrollingLayer; }
     GraphicsLayer* scrollingLayer() const { return m_scrollingLayer.get(); }
     GraphicsLayer* scrollingContentsLayer() const { return m_scrollingContentsLayer.get(); }
 
     bool hasMaskLayer() const { return m_maskLayer; }
     bool hasChildClippingMaskLayer() const { return m_childClippingMaskLayer; }
 
     GraphicsLayer* parentForSublayers() const;
     GraphicsLayer* childForSuperlayers() const;
 
+    GraphicsLayer* squashingLayer() const { return m_squashingLayer.get(); }
+
     // Returns true for a composited layer that has no backing store of its own, so
     // paints into some ancestor layer.
     bool paintsIntoCompositedAncestor() const { return !(m_requiresOwnBackingStoreForAncestorReasons || m_requiresOwnBackingStoreForIntrinsicReasons); }
 
     // Updates whether a backing store is needed based on the layer's compositing ancestor's
     // properties; returns true if the need for a backing store for ancestor reasons changed.
     bool updateRequiresOwnBackingStoreForAncestorReasons(const RenderLayer* compositingAncestor);
 
     // Updates whether a backing store is needed for intrinsic reasons (that is, based on the
     // layer's own properties or compositing reasons); returns true if the intrinsic need for
@@ skipping 17 matching lines @@
     void animationFinished(const String& name);
 
     IntRect compositedBounds() const;
     void setCompositedBounds(const IntRect&);
     void updateCompositedBounds();
 
     void updateAfterWidgetResize();
     void positionOverflowControlsLayers(const IntSize& offsetFromRoot);
     bool hasUnpositionedOverflowControlsLayers() const;
 
+    void clearSquashingGraphicsLayer();
+    void addRenderLayerToSquashingGraphicsLayer(RenderLayer*, IntSize offsetFromTargetBacking);
+    void beginAccumulatingSquashingLayers();
+    void finishAccumulatingSquashingLayers();
+
     // GraphicsLayerClient interface
     virtual void notifyAnimationStarted(const GraphicsLayer*, double startTime) OVERRIDE;
 
     virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const IntRect& clip) OVERRIDE;
 
     virtual void didCommitChangesForLayer(const GraphicsLayer*) const OVERRIDE;
     virtual bool getCurrentTransform(const GraphicsLayer*, TransformationMatrix&) const OVERRIDE;
 
     virtual bool isTrackingRepaints() const OVERRIDE;
 
@@ skipping 38 matching lines @@
     bool updateForegroundLayer(bool needsForegroundLayer);
     bool updateBackgroundLayer(bool needsBackgroundLayer);
     bool updateMaskLayer(bool needsMaskLayer);
     bool updateClippingMaskLayers(bool needsChildClippingMaskLayer);
     bool requiresHorizontalScrollbarLayer() const { return m_owningLayer->scrollableArea() && m_owningLayer->scrollableArea()->horizontalScrollbar(); }
     bool requiresVerticalScrollbarLayer() const { return m_owningLayer->scrollableArea() && m_owningLayer->scrollableArea()->verticalScrollbar(); }
     bool requiresScrollCornerLayer() const { return m_owningLayer->scrollableArea() && !m_owningLayer->scrollableArea()->scrollCornerAndResizerRect().isEmpty(); }
     bool updateScrollingLayers(bool scrollingLayers);
     void updateScrollParent(RenderLayer*);
     void updateClipParent(RenderLayer*);
+    bool updateSquashingLayers(bool needsSquashingLayers);
     void updateDrawsContent(bool isSimpleContainer);
     void registerScrollingLayers();
 
     void setBackgroundLayerPaintsFixedRootBackground(bool);
 
     GraphicsLayerPaintingPhase paintingPhaseForPrimaryLayer() const;
 
     IntSize contentOffsetInCompostingLayer() const;
     // Result is transform origin in pixels.
     FloatPoint3D computeTransformOrigin(const IntRect& borderBox) const;
@@ skipping 98 matching lines @@
     // the background layer (or repainting).
     OwnPtr<GraphicsLayer> m_foregroundLayer; // Only used in cases where we need to draw the foreground separately.
     OwnPtr<GraphicsLayer> m_backgroundLayer; // Only used in cases where we need to draw the background separately.
 
     OwnPtr<GraphicsLayer> m_layerForHorizontalScrollbar;
     OwnPtr<GraphicsLayer> m_layerForVerticalScrollbar;
     OwnPtr<GraphicsLayer> m_layerForScrollCorner;
 
     OwnPtr<WebAnimationProvider> m_animationProvider;
 
+    OwnPtr<GraphicsLayer> m_squashingContainmentLayer; // Only used if any squashed layers exist, to contain the squashed layers as siblings to the rest of the GraphicsLayer tree chunk.
+    OwnPtr<GraphicsLayer> m_squashingLayer; // Only used if any squashed layers exist, this is the backing that squashed layers paint into.
+    Vector<GraphicsLayerPaintInfo> m_squashedLayers;
+
+    size_t m_nextSquashedLayerIndex; // Only used to track changes when RenderLayers are being added to the squashing layer.
+
     IntRect m_compositedBounds;
 
     bool m_artificiallyInflatedBounds; // bounds had to be made non-zero to make transform-origin work
     bool m_boundsConstrainedByClipping;
     bool m_isMainFrameRenderViewLayer;
     bool m_requiresOwnBackingStoreForIntrinsicReasons;
     bool m_requiresOwnBackingStoreForAncestorReasons;
     bool m_canCompositeFilters;
     bool m_backgroundLayerPaintsFixedRootBackground;
 };
 
 } // namespace WebCore
 
 #endif // CompositedLayerMapping_h