Store local border box property cache outside ObjectPaintProperties

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 192 matching lines @@
     ClipRect clipRect;
     calculateClipRectWithGeometryMapper(context, false, clipRect);
     applyOverflowClipToBackgroundRectWithGeometryMapper(context, clipRect);
     LayoutRect premappedRect = clipRect.rect();
 
     // The rect now needs to be transformed to the local space of this
     // PaintLayer.
     premappedRect.moveBy(context.rootLayer->layoutObject().paintOffset());
 
     const auto* clipRootLayerTransform = clippingRootLayer.layoutObject()
-                                             .paintProperties()
-                                             ->localBorderBoxProperties()
+                                             .localBorderBoxProperties()
                                              ->transform();
-    const auto* layerTransform = m_layer.layoutObject()
-                                     .paintProperties()
-                                     ->localBorderBoxProperties()
-                                     ->transform();
+    const auto* layerTransform =
+        m_layer.layoutObject().localBorderBoxProperties()->transform();
     FloatRect clippedRectInLocalSpace(premappedRect);
     m_geometryMapper->sourceToDestinationRect(
         clipRootLayerTransform, layerTransform, clippedRectInLocalSpace);
     clippedRectInLocalSpace.moveBy(
         -FloatPoint(m_layer.layoutObject().paintOffset()));
 
     return LayoutRect(clippedRectInLocalSpace);
   }
 
   LayoutRect layerBounds;
@@ skipping 25 matching lines @@
                  << " actual=" << actual.toString();                    \
     }                                                                   \
   } while (false);
 #endif
 
 void PaintLayerClipper::mapLocalToRootWithGeometryMapper(
     const ClipRectsContext& context,
     LayoutRect& rectToMap) const {
   DCHECK(m_geometryMapper);
 
-  const auto* layerTransform = m_layer.layoutObject()
-                                   .paintProperties()
-                                   ->localBorderBoxProperties()
-                                   ->transform();
-  const auto* rootTransform = context.rootLayer->layoutObject()
-                                  .paintProperties()
-                                  ->localBorderBoxProperties()
-                                  ->transform();
+  const auto* layerTransform =
+      m_layer.layoutObject().localBorderBoxProperties()->transform();
+  const auto* rootTransform =
+      context.rootLayer->layoutObject().localBorderBoxProperties()->transform();
 
   FloatRect floatRect(rectToMap);
   floatRect.moveBy(FloatPoint(m_layer.layoutObject().paintOffset()));
   m_geometryMapper->sourceToDestinationRect(layerTransform, rootTransform,
                                             floatRect);
   rectToMap = LayoutRect(floatRect);
   rectToMap.moveBy(-context.rootLayer->layoutObject().paintOffset());
   rectToMap.move(context.subPixelAccumulation);
 }
 
 void PaintLayerClipper::calculateRectsWithGeometryMapper(
     const ClipRectsContext& context,
     const LayoutRect& paintDirtyRect,
     LayoutRect& layerBounds,
     ClipRect& backgroundRect,
     ClipRect& foregroundRect,
     const LayoutPoint* offsetFromRoot) const {
-  const auto* properties = m_layer.layoutObject().paintProperties();
-  // TODO(chrishtr): fix the underlying bug that causes this situation.
-  if (!properties) {
-    backgroundRect = ClipRect(LayoutRect(LayoutRect::infiniteIntRect()));
-    foregroundRect = ClipRect(LayoutRect(LayoutRect::infiniteIntRect()));
-  } else {
-    calculateClipRectWithGeometryMapper(context, false, backgroundRect);
+  calculateClipRectWithGeometryMapper(context, false, backgroundRect);
 
-    backgroundRect.move(context.subPixelAccumulation);
-    backgroundRect.intersect(paintDirtyRect);
+  backgroundRect.move(context.subPixelAccumulation);
+  backgroundRect.intersect(paintDirtyRect);
 
-    applyOverflowClipToBackgroundRectWithGeometryMapper(context,
-                                                        backgroundRect);
+  applyOverflowClipToBackgroundRectWithGeometryMapper(context, backgroundRect);
 
-    calculateClipRectWithGeometryMapper(context, true, foregroundRect);
-    foregroundRect.move(context.subPixelAccumulation);
-    foregroundRect.intersect(paintDirtyRect);
-  }
+  calculateClipRectWithGeometryMapper(context, true, foregroundRect);
+  foregroundRect.move(context.subPixelAccumulation);
+  foregroundRect.intersect(paintDirtyRect);
+
   LayoutPoint offset;
   if (offsetFromRoot)
     offset = *offsetFromRoot;
   else
     m_layer.convertToLayerCoords(context.rootLayer, offset);
   layerBounds = LayoutRect(offset, LayoutSize(m_layer.size()));
 
 #ifdef CHECK_CLIP_RECTS
   ClipRect testBackgroundRect, testForegroundRect;
   LayoutRect testLayerBounds;
@@ skipping 123 matching lines @@
     return parentRects.posClipRect();
 
   return parentRects.overflowClipRect();
 }
 
 void PaintLayerClipper::calculateClipRectWithGeometryMapper(
     const ClipRectsContext& context,
     bool isForeground,
     ClipRect& output) const {
   DCHECK(m_geometryMapper);
-  const auto* properties = m_layer.layoutObject().paintProperties();
-  DCHECK(properties && properties->localBorderBoxProperties());
+  const auto* localBorderBox =
+      m_layer.layoutObject().localBorderBoxProperties();
+  DCHECK(localBorderBox);
+  PropertyTreeState propertyTreeState = *localBorderBox;
 
-  PropertyTreeState propertyTreeState = *properties->localBorderBoxProperties();
+  const auto* ancestorLocalBorderBox =
+      context.rootLayer->layoutObject().localBorderBoxProperties();
+  DCHECK(ancestorLocalBorderBox);
+  PropertyTreeState destinationPropertyTreeState = *ancestorLocalBorderBox;
+
   const auto* ancestorProperties =
       context.rootLayer->layoutObject().paintProperties();
-  DCHECK(ancestorProperties && ancestorProperties->localBorderBoxProperties());
-  PropertyTreeState destinationPropertyTreeState =
-      *ancestorProperties->localBorderBoxProperties();
+  const auto* ancestorCssClip =
+      ancestorProperties ? ancestorProperties->cssClip() : nullptr;
   // CSS clip of the root is always applied.
-  if (ancestorProperties->cssClip()) {
-    DCHECK(destinationPropertyTreeState.clip() ==
-           ancestorProperties->cssClip());
-    destinationPropertyTreeState.setClip(
-        ancestorProperties->cssClip()->parent());
+  if (ancestorCssClip) {
+    DCHECK(destinationPropertyTreeState.clip() == ancestorCssClip);
+    destinationPropertyTreeState.setClip(ancestorCssClip->parent());
   }
 
+  const auto* properties = m_layer.layoutObject().paintProperties();
+  const auto* overflowClip = properties ? properties->overflowClip() : nullptr;
   if (&m_layer == context.rootLayer) {
     // Set the overflow clip for |propertyTreeState| so that it differs from
     // |destinationPropertyTreeState| in its clip.
     if (isForeground && context.respectOverflowClip == RespectOverflowClip &&
-        properties->overflowClip())
-      propertyTreeState.setClip(properties->overflowClip());
+        overflowClip)
+      propertyTreeState.setClip(overflowClip);
   } else {
+    const auto* ancestorOverflowClip =
+        ancestorProperties ? ancestorProperties->overflowClip() : nullptr;
     // Set the clip of |destinationPropertyTreeState| to be inside the
     // ancestor's overflow clip, so that that clip is not applied.
     if (context.respectOverflowClip == IgnoreOverflowClip &&
-        ancestorProperties->overflowClip())
-      destinationPropertyTreeState.setClip(ancestorProperties->overflowClip());
+        ancestorOverflowClip)
+      destinationPropertyTreeState.setClip(ancestorOverflowClip);
 
     // Set the overflow clip for |propertyTreeState| so that it differs from
     // destinationPropertyTreeState| in its clip.
-    if (isForeground && properties->overflowClip())
-      propertyTreeState.setClip(properties->overflowClip());
+    if (isForeground && overflowClip)
+      propertyTreeState.setClip(overflowClip);
   }
 
   const FloatClipRect& clippedRectInRootLayerSpace =
       m_geometryMapper->sourceToDestinationClipRect(
           propertyTreeState, destinationPropertyTreeState);
   output.setRect(clippedRectInRootLayerSpace);
 
   output.moveBy(-context.rootLayer->layoutObject().paintOffset());
 }
 
@@ skipping 101 matching lines @@
   DCHECK(!m_geometryMapper);
   ClipRectsContext context(rootLayer, PaintingClipRects,
                            IgnorePlatformOverlayScrollbarSize,
                            subpixelAccumulation);
   if (respectOverflowClip == IgnoreOverflowClip)
     context.setIgnoreOverflowClip();
   return getClipRects(context);
 }
 
 }  // namespace blink