Move AbsoluteClipRects to the state machine

Source/core/paint/DeprecatedPaintLayerClipper.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 151 matching lines @@
     // CSS clip (different than clipping due to overflow) can clip to any box, even if it falls outside of the border box.
     if (m_layoutObject.hasClip()) {
         // Clip applies to *us* as well, so go ahead and update the damageRect.
         LayoutRect newPosClip = toLayoutBox(m_layoutObject).clipRect(offset);
         backgroundRect.intersect(newPosClip);
         foregroundRect.intersect(newPosClip);
         outlineRect.intersect(newPosClip);
     }
 }
 
-static void precalculate(const ClipRectsContext& context)
+void precalculate(const ClipRectsContext& context)
 {
     bool isComputingPaintingRect = context.isComputingPaintingRect();
     ClipRectComputationState rects;
     const DeprecatedPaintLayer* rootLayer = context.rootLayer;
     if (isComputingPaintingRect) {
         // Starting arbitrarily in the tree when calculating painting clipRects will
         // not allow you to fill in all layers cache because some intermediate layer
         // may need clips with respect to an ancestor further up. For efficiency we
         // start at the top in order to fill in the cache for all layers.
         rootLayer = context.rootLayer->layoutObject()->view()->layer();
         rects.stackingContextClipRects.setRootLayer(rootLayer);
     }
     rects.currentClipRects.setRootLayer(rootLayer);
 
     rootLayer->clipper().calculateClipRects(context, rects);
 }
 
+void DeprecatedPaintLayerClipper::precalculateAbsoluteClipRects()
+{
+    ASSERT(m_layoutObject.layer()->isRootLayer());
+    // The absolute rectangles rely on layout sizes and position only.
+    ASSERT(m_layoutObject.document().lifecycle().state() >= DocumentLifecycle::LayoutClean);
+    precalculate(ClipRectsContext(m_layoutObject.layer(), AbsoluteClipRects));
+}
 
 // Calculates clipRect for each element in the section of the tree starting with context.rootLayer
 // For painting, context.rootLayer is ignored and the entire tree is calculated.
 // TODO(chadarmstrong): When using the cache context shouldn't be able to specify the rootLayer. This affects
 // what is stored in the 5 caches, and should therefore be enforced internally. Currently
 // different callers have different ideas of what the rootLayer should be for a particular
 // cacheSlot, which can fill the cache with bad data. If this can be made consistent it should
 // be possible to eliminate rootLayer.
 ClipRect DeprecatedPaintLayerClipper::backgroundClipRect(const ClipRectsContext& context) const
 {
     ASSERT(m_layoutObject.layer()->parent());
     ASSERT(m_layoutObject.view());
 
     // Ideally backgroundClipRect would not be called with itself as the rootLayer.
     // This behavior can be seen in the following test
     // LayoutTests/compositing/squashing/abspos-under-abspos-overflow-scroll.html
     if (m_layoutObject.layer() == context.rootLayer)
         return LayoutRect(LayoutRect::infiniteIntRect());
 
     // TODO(chadarmstrong): If possible, all queries should use one of the clipRectsCacheSlots.
     // Without caching this operation involves walking all the way to rootLayer.
     if (!context.usesCache())
         return uncachedBackgroundClipRect(context);
 
     // TODO(chadarmstrong): precalculation for painting should be moved to updateLifecyclePhasesInternal
     // and precalculation could be done for all hit testing. This would let us avoid clearing the cache
-    if (!m_clips[context.cacheSlot()])
+    if (!m_clips[context.cacheSlot()]) {
+        // AbsoluteClipRects should have been updated during compositing updates so we shouldn't miss here.
+        ASSERT(context.cacheSlot() != AbsoluteClipRects);
         precalculate(context);
+    }
 
     // TODO(chadarmstrong): eliminate this if possible.
     // It is necessary only because of a seemingly atypical use of rootLayer that
     // can be seen in LayoutTests/fullscreen/full-screen-line-boxes-crash.html and
     // fast/block/multicol-paint-invalidation-assert.html.
     if (!m_clips[context.cacheSlot()])
         return uncachedBackgroundClipRect(context);
     // As soon as crbug.com/517173 is resolved this assert should be enabled in place of the check
     // ASSERT(m_clips[context.cacheSlot()]->rootLayer() == context.rootLayer);
     if (m_clips[context.cacheSlot()]->rootLayer() != context.rootLayer)
@@ skipping 218 matching lines @@
     if (context.respectOverflowClip == IgnoreOverflowClip)
         return false;
 
     if (layer->isRootLayer() && context.respectOverflowClipForViewport == IgnoreOverflowClip)
         return false;
 
     return true;
 }
 
 } // namespace blink