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 191 matching lines @@
   if (m_geometryMapper) {
     ClipRect clipRect;
     calculateBackgroundClipRectWithGeometryMapper(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 27 matching lines @@
   } while (false);
 #endif
 
 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 {
-    calculateBackgroundClipRectWithGeometryMapper(context, backgroundRect);
-    backgroundRect.move(context.subPixelAccumulation);
-    backgroundRect.intersect(paintDirtyRect);
+  calculateBackgroundClipRectWithGeometryMapper(context, backgroundRect);
+  backgroundRect.move(context.subPixelAccumulation);
+  backgroundRect.intersect(paintDirtyRect);
 
-    calculateForegroundClipRectWithGeometryMapper(context, foregroundRect);
-    foregroundRect.move(context.subPixelAccumulation);
-    foregroundRect.intersect(paintDirtyRect);
-  }
+  calculateForegroundClipRectWithGeometryMapper(context, 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 118 matching lines @@
 }
 
 void PaintLayerClipper::calculateBackgroundClipRectWithGeometryMapper(
     const ClipRectsContext& context,
     ClipRect& output) const {
   DCHECK(m_geometryMapper);
   PropertyTreeState sourcePropertyTreeState(nullptr, nullptr, nullptr);
   PropertyTreeState destinationPropertyTreeState(nullptr, nullptr, nullptr);
   initializeCommonClipRectState(context, sourcePropertyTreeState,
                                 destinationPropertyTreeState);
-  const auto* ancestorProperties =
-      context.rootLayer->layoutObject().paintProperties();
 
   if (&m_layer != context.rootLayer) {
+    auto* ancestorProperties =
+        context.rootLayer->layoutObject().paintProperties();
+    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);
   }
 
   // The background rect applies all clips *above* m_layer, but not the overflow
   // clip of m_layer. It also applies a clip to the total painting bounds
   // of m_layer, because nothing in m_layer or its children within the clip can
   // paint outside of those bounds.
   // The total painting bounds includes any visual overflow (such as shadow) and
   // filter bounds.
   if (shouldClipOverflow(context)) {
     FloatRect clipRect(localVisualRect());
     clipRect.moveBy(FloatPoint(m_layer.layoutObject().paintOffset()));
     m_geometryMapper->sourceToDestinationVisualRect(
         sourcePropertyTreeState, destinationPropertyTreeState, clipRect);
     output.setRect(FloatClipRect(clipRect));
   } else {
     const FloatClipRect& clippedRectInRootLayerSpace =
         m_geometryMapper->sourceToDestinationClipRect(
             sourcePropertyTreeState, destinationPropertyTreeState);
     output.setRect(clippedRectInRootLayerSpace);
   }
 
   output.moveBy(-context.rootLayer->layoutObject().paintOffset());
 }
 
 void PaintLayerClipper::initializeCommonClipRectState(
     const ClipRectsContext& context,
     PropertyTreeState& sourcePropertyTreeState,
     PropertyTreeState& destinationPropertyTreeState) const {
   DCHECK(m_geometryMapper);
-  const auto* properties = m_layer.layoutObject().paintProperties();
-  DCHECK(properties && properties->localBorderBoxProperties());
+  DCHECK(m_layer.layoutObject().localBorderBoxProperties());
 
-  sourcePropertyTreeState = *properties->localBorderBoxProperties();
-  const auto* ancestorProperties =
+  sourcePropertyTreeState = *m_layer.layoutObject().localBorderBoxProperties();
+  DCHECK(context.rootLayer->layoutObject().localBorderBoxProperties());
+  destinationPropertyTreeState =
+      *context.rootLayer->layoutObject().localBorderBoxProperties();
+
+  auto* ancestorProperties =
       context.rootLayer->layoutObject().paintProperties();
-  DCHECK(ancestorProperties && ancestorProperties->localBorderBoxProperties());
-  destinationPropertyTreeState =
-      *ancestorProperties->localBorderBoxProperties();
+  const auto* ancestorCssClip =
+      ancestorProperties ? ancestorProperties->cssClip() : nullptr;
   // CSS clip of the root is always applied.
-  if (ancestorProperties->cssClip()) {
+  if (ancestorCssClip) {
     DCHECK(destinationPropertyTreeState.clip() ==
            ancestorProperties->cssClip());
-    destinationPropertyTreeState.setClip(
-        ancestorProperties->cssClip()->parent());
+    destinationPropertyTreeState.setClip(ancestorCssClip->parent());
   }
 }
 
 void PaintLayerClipper::calculateForegroundClipRectWithGeometryMapper(
     const ClipRectsContext& context,
     ClipRect& output) const {
   DCHECK(m_geometryMapper);
   PropertyTreeState sourcePropertyTreeState(nullptr, nullptr, nullptr);
   PropertyTreeState destinationPropertyTreeState(nullptr, nullptr, nullptr);
   initializeCommonClipRectState(context, sourcePropertyTreeState,
                                 destinationPropertyTreeState);
   const auto* properties = m_layer.layoutObject().paintProperties();
-  const auto* ancestorProperties =
-      context.rootLayer->layoutObject().paintProperties();
 
   if (&m_layer == context.rootLayer) {
     // Set the overflow clip for |sourcePropertyTreeState| so that it differs
     // from |destinationPropertyTreeState| in its clip.
-    if (context.respectOverflowClip == RespectOverflowClip &&
+    if (context.respectOverflowClip == RespectOverflowClip && properties &&
         properties->overflowClip())
       sourcePropertyTreeState.setClip(properties->overflowClip());
   } else {
+    const auto* ancestorProperties =
+        context.rootLayer->layoutObject().paintProperties();
+
     // 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())
+        ancestorProperties && ancestorProperties->overflowClip())
       destinationPropertyTreeState.setClip(ancestorProperties->overflowClip());
 
     // Set the overflow clip for |sourcePropertyTreeState| so that it differs
     // from destinationPropertyTreeState| in its clip.
-    if (properties->overflowClip())
+    if (properties && properties->overflowClip())
       sourcePropertyTreeState.setClip(properties->overflowClip());
   }
 
   const FloatClipRect& clippedRectInRootLayerSpace =
       m_geometryMapper->sourceToDestinationClipRect(
           sourcePropertyTreeState, destinationPropertyTreeState);
   output.setRect(clippedRectInRootLayerSpace);
 
   output.moveBy(-context.rootLayer->layoutObject().paintOffset());
 }
@@ skipping 16 matching lines @@
         m_layer.mapLayoutRectForFilter(layerBoundsWithVisualOverflow);
   }
   return layerBoundsWithVisualOverflow;
 }
 
 void PaintLayerClipper::calculateBackgroundClipRect(
     const ClipRectsContext& context,
     ClipRect& output) const {
   if (m_geometryMapper) {
     // TODO(chrishtr): fix the underlying bug that causes this situation.
-    if (!m_layer.layoutObject().paintProperties()) {
+    if (!m_layer.layoutObject().paintProperties() &&
+        !m_layer.layoutObject().localBorderBoxProperties()) {
       output.setRect(FloatClipRect());
       return;
     }
 
     calculateBackgroundClipRectWithGeometryMapper(context, output);
 #ifdef CHECK_CLIP_RECTS
     ClipRect testBackgroundClipRect =
         PaintLayerClipper(m_layer, nullptr).backgroundClipRect(context);
     CHECK_RECTS_EQ(testBackgroundClipRect, output);
 #endif
@@ skipping 66 matching lines @@
   DCHECK(!m_geometryMapper);
   ClipRectsContext context(rootLayer, PaintingClipRects,
                            IgnorePlatformOverlayScrollbarSize,
                            subpixelAccumulation);
   if (respectOverflowClip == IgnoreOverflowClip)
     context.setIgnoreOverflowClip();
   return getClipRects(context);
 }
 
 }  // namespace blink