Invalidate subsequence caching & empty paint phases if clips changed.

third_party/WebKit/Source/core/paint/PaintLayerClipper.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>
@@ skipping 142 matching lines @@
       entry.clipRects = parentClipRects;
       return *parentClipRects;
     }
   }
   entry.clipRects = ClipRects::create(clipRects);
   return *entry.clipRects;
 }
 
 ClipRects& PaintLayerClipper::getClipRects(
     const ClipRectsContext& context) const {
-  if (ClipRects* result = clipRectsIfCached(context))
-    return *result;
+  // if (ClipRects* result = clipRectsIfCached(context))
+  //   return *result;
   // Note that it's important that we call getClipRects on our parent
   // before we call calculateClipRects so that calculateClipRects will hit
   // the cache.
   ClipRects* parentClipRects = nullptr;
   if (context.rootLayer != &m_layer && m_layer.parent())
     parentClipRects = &m_layer.parent()->clipper().getClipRects(context);
   RefPtr<ClipRects> clipRects = ClipRects::create();
+  //  LOG(ERROR) << "calculateClipRects:" <<
+  //  m_layer.layoutObject()->debugName();
   calculateClipRects(context, *clipRects);
   return storeClipRectsInCache(context, parentClipRects, *clipRects);
 }
 
 void PaintLayerClipper::clearCache(ClipRectsCacheSlot cacheSlot) {
   if (cacheSlot == NumberOfClipRectsCacheSlots)
     m_layer.clearClipRectsCache();
   else if (ClipRectsCache* cache = m_layer.clipRectsCache())
     cache->clear(cacheSlot);
 
@@ skipping 200 matching lines @@
     foregroundRect.setIsClippedByClipCss();
   }
 }
 
 void PaintLayerClipper::calculateClipRects(const ClipRectsContext& context,
                                            ClipRects& clipRects) const {
   const LayoutBoxModelObject& layoutObject = *m_layer.layoutObject();
   if (!m_layer.parent() &&
       !RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
     // The root layer's clip rect is always infinite.
+    // LOG(ERROR) << "wat";
     clipRects.reset(LayoutRect(LayoutRect::infiniteIntRect()));
     return;
   }
 
   bool isClippingRoot = &m_layer == context.rootLayer;
 
   // For transformed layers, the root layer was shifted to be us, so there is no
   // need to examine the parent. We want to cache clip rects with us as the
   // root.
   PaintLayer* parentLayer = !isClippingRoot ? m_layer.parent() : nullptr;
   // Ensure that our parent's clip has been calculated so that we can examine
   // the values.
   if (parentLayer) {
     parentLayer->clipper().getOrCalculateClipRects(context, clipRects);
   } else {
     clipRects.reset(LayoutRect(LayoutRect::infiniteIntRect()));
   }
 
   adjustClipRectsForChildren(layoutObject, clipRects);
-
+  // LOG(ERROR) << "just before: " << m_layer.layoutObject()->debugName();
   if (shouldClipOverflow(context) || layoutObject.hasClip()) {
+    //  LOG(ERROR) << "clipping overflow: " <<
+    //  m_layer.layoutObject()->debugName();
     // This offset cannot use convertToLayerCoords, because sometimes our
     // rootLayer may be across some transformed layer boundary, for example, in
     // the PaintLayerCompositor overlapMap, where clipRects are needed in view
     // space.
-    applyClipRects(context, layoutObject,
-                   LayoutPoint(layoutObject.localToAncestorPoint(
-                       FloatPoint(), context.rootLayer->layoutObject())),
-                   clipRects);
+    LOG(ERROR) << "mapping to ancestor: from=" << layoutObject.debugName()
+               << " to=" << context.rootLayer->layoutObject()->debugName();
+    LayoutPoint point(layoutObject.localToAncestorPoint(
+        FloatPoint(), context.rootLayer->layoutObject()));
+    applyClipRects(context, layoutObject, point, clipRects);
   }
 }
 
 static ClipRect backgroundClipRectForPosition(const ClipRects& parentRects,
                                               EPosition position) {
   if (position == FixedPosition)
     return parentRects.fixedClipRect();
 
   if (position == AbsolutePosition)
     return parentRects.posClipRect();
@@ skipping 41 matching lines @@
   clippedRectInRootLayerSpace.moveBy(
       -FloatPoint(context.rootLayer->layoutObject()->paintOffset()));
   return ClipRect(LayoutRect(clippedRectInRootLayerSpace));
 }
 
 ClipRect PaintLayerClipper::applyOverflowClipToBackgroundRectWithGeometryMapper(
     const ClipRectsContext& context,
     const ClipRect& clip) const {
   const LayoutObject& layoutObject = *m_layer.layoutObject();
   FloatRect clipRect(clip.rect());
+  // fix??
   if (shouldClipOverflow(context)) {
     LayoutRect layerBoundsWithVisualOverflow =
         layoutObject.isLayoutView()
             ? toLayoutView(layoutObject).viewRect()
             : toLayoutBox(layoutObject).visualOverflowRect();
     toLayoutBox(layoutObject)
         .flipForWritingMode(
             // PaintLayer are in physical coordinates, so the overflow has to be
             // flipped.
             layerBoundsWithVisualOverflow);
@@ skipping 44 matching lines @@
   if (context.usesCache())
     clipRects = getClipRects(context);
   else
     calculateClipRects(context, clipRects);
 }
 
 bool PaintLayerClipper::shouldClipOverflow(
     const ClipRectsContext& context) const {
   if (!m_layer.layoutObject()->isBox())
     return false;
+  // LOG(ERROR) << "wat";
   const LayoutBox& box = *toLayoutBox(m_layer.layoutObject());
 
   if (!shouldRespectOverflowClip(context))
     return false;
-
   return box.shouldClipOverflow();
 }
 
 bool PaintLayerClipper::shouldRespectOverflowClip(
     const ClipRectsContext& context) const {
   if (&m_layer != context.rootLayer)
     return true;
 
   if (context.respectOverflowClip == IgnoreOverflowClip)
     return false;
@@ skipping 11 matching lines @@
     const LayoutSize& subpixelAccumulation) const {
   DCHECK(!m_geometryMapper);
   ClipRectsContext context(rootLayer, PaintingClipRects,
                            IgnoreOverlayScrollbarSize, subpixelAccumulation);
   if (respectOverflowClip == IgnoreOverflowClip)
     context.setIgnoreOverflowClip();
   return getClipRects(context);
 }
 
 }  // namespace blink