SPv2: Use GeometryMapper to implement PaintLayerClipper.

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>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 28 matching lines @@
  * other provisions required by the MPL or the GPL, as the case may be.
  * If you do not delete the provisions above, a recipient may use your
  * version of this file under any of the LGPL, the MPL or the GPL.
  */
 
 #include "core/paint/PaintLayerClipper.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutView.h"
+#include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintLayer.h"
 
 namespace blink {
 
 static void adjustClipRectsForChildren(const LayoutBoxModelObject& layoutObject, ClipRects& clipRects)
 {
     EPosition position = layoutObject.styleRef().position();
     // A fixed object is essentially the root of its containing block hierarchy, so when
     // we encounter such an object, we reset our clip rects to the fixedClipRect.
     if (position == FixedPosition) {
@@ skipping 28 matching lines @@
         }
     }
     if (layoutObject.hasClip()) {
         LayoutRect newClip = toLayoutBox(layoutObject).clipRect(offset);
         clipRects.setPosClipRect(intersection(newClip, clipRects.posClipRect()).setIsClippedByClipCss());
         clipRects.setOverflowClipRect(intersection(newClip, clipRects.overflowClipRect()).setIsClippedByClipCss());
         clipRects.setFixedClipRect(intersection(newClip, clipRects.fixedClipRect()).setIsClippedByClipCss());
     }
 }
 
+PaintLayerClipper::PaintLayerClipper(const PaintLayer& layer)
+    : m_layer(layer), m_geometryMapper(RuntimeEnabledFeatures::slimmingPaintV2Enabled() ? new GeometryMapper : nullptr)
+{ }
+
 ClipRects* PaintLayerClipper::clipRectsIfCached(const ClipRectsContext& context) const
 {
     ASSERT(context.usesCache());
     if (!m_layer.clipRectsCache())
         return nullptr;
     ClipRectsCache::Entry& entry = m_layer.clipRectsCache()->get(context.cacheSlot());
     // FIXME: We used to ASSERT that we always got a consistent root layer.
     // We should add a test that has an inconsistent root. See
     // http://crbug.com/366118 for an example.
     if (context.rootLayer != entry.root)
@@ skipping 38 matching lines @@
     ClipRects* parentClipRects = nullptr;
     if (context.rootLayer != &m_layer && m_layer.parent())
         parentClipRects = &m_layer.parent()->clipper().getClipRects(context);
     RefPtr<ClipRects> clipRects = ClipRects::create();
     calculateClipRects(context, *clipRects);
     return storeClipRectsInCache(context, parentClipRects, *clipRects);
 }
 
 void PaintLayerClipper::clearClipRectsIncludingDescendants()
 {
+    if (m_geometryMapper)
+        m_geometryMapper.reset(new GeometryMapper);

[Xianzhu, 2016/08/15 17:09:04]

Can you give some performance analysis? Can we share GeometryMapper among
PaintLayers?

[chrishtr, 2016/10/05 23:28:32]

Don't have any yet. I'd prefer to commit this first and then do a comparison
when the code is stable and known to be correct,
via the rasterize-and-record invalidation benchmark that Walter just added. What
do you think?
Yes it can be shared, good idea. Note however that the old system couldn't do
that. I've put a TODO. Resolving that TODO is related to the above request to do
performance testing later..

     m_layer.clearClipRectsCache();
 
     for (PaintLayer* layer = m_layer.firstChild(); layer; layer = layer->nextSibling()) {
         layer->clipper().clearClipRectsIncludingDescendants();
     }
 }
 
 void PaintLayerClipper::clearClipRectsIncludingDescendants(ClipRectsCacheSlot cacheSlot)
 {
+    if (m_geometryMapper)
+        m_geometryMapper.reset(new GeometryMapper);
+
     if (ClipRectsCache* cache = m_layer.clipRectsCache())
         cache->clear(cacheSlot);
 
     for (PaintLayer* layer = m_layer.firstChild(); layer; layer = layer->nextSibling()) {
         layer->clipper().clearClipRectsIncludingDescendants(cacheSlot);
     }
 }
 
 LayoutRect PaintLayerClipper::localClipRect(const PaintLayer* clippingRootLayer) const
 {
+    ClipRectsContext context(clippingRootLayer, PaintingClipRects);
+    if (m_geometryMapper) {
+        ClipRect clipRect = clipRectWithGeometryMapper(context, false);
+
+        // The rect now needs to be transformed to the local space of this PaintLayer.
+        bool success = false;
+        FloatRect clippedRectInLocalSpace = m_geometryMapper->mapRectToDestinationSpace(FloatRect(clipRect.rect()),
+            clippingRootLayer->layoutObject()->objectPaintProperties()->localBorderBoxProperties()->propertyTreeState,
+            m_layer.layoutObject()->objectPaintProperties()->localBorderBoxProperties()->propertyTreeState, success);
+        DCHECK(success);
+
+        return LayoutRect(clippedRectInLocalSpace);
+    }
+
     LayoutRect layerBounds;
     ClipRect backgroundRect, foregroundRect;
-    ClipRectsContext context(clippingRootLayer, PaintingClipRects);
     calculateRects(context, LayoutRect(LayoutRect::infiniteIntRect()), layerBounds, backgroundRect, foregroundRect);
 
     LayoutRect clipRect = backgroundRect.rect();
     // TODO(chrishtr): avoid converting to IntRect and back.
     if (clipRect == LayoutRect(LayoutRect::infiniteIntRect()))
         return clipRect;
 
     LayoutPoint clippingRootOffset;
     m_layer.convertToLayerCoords(clippingRootLayer, clippingRootOffset);
     clipRect.moveBy(-clippingRootOffset);
 
     return clipRect;
 }
 
 void PaintLayerClipper::calculateRects(const ClipRectsContext& context, const LayoutRect& paintDirtyRect, LayoutRect& layerBounds,
     ClipRect& backgroundRect, ClipRect& foregroundRect, const LayoutPoint* offsetFromRoot) const
 {
+    if (m_geometryMapper) {
+        backgroundRect = clipRectWithGeometryMapper(context, false);
+        backgroundRect.move(context.subPixelAccumulation); // TODO(chrishtr): is this needed?
+        backgroundRect.intersect(paintDirtyRect);
+
+        foregroundRect.move(context.subPixelAccumulation); // TODO(chrishtr): is this needed?
+        foregroundRect = clipRectWithGeometryMapper(context, true);
+        foregroundRect.intersect(paintDirtyRect);
+        return;
+    }
+
     bool isClippingRoot = &m_layer == context.rootLayer;
     LayoutBoxModelObject& layoutObject = *m_layer.layoutObject();
 
     if (!isClippingRoot && m_layer.parent()) {
         backgroundRect = backgroundClipRect(context);
         backgroundRect.move(context.subPixelAccumulation);
         backgroundRect.intersect(paintDirtyRect);
     } else {
         backgroundRect = paintDirtyRect;
     }
@@ skipping 70 matching lines @@
 {
     if (position == FixedPosition)
         return parentRects.fixedClipRect();
 
     if (position == AbsolutePosition)
         return parentRects.posClipRect();
 
     return parentRects.overflowClipRect();
 }
 
+ClipRect PaintLayerClipper::clipRectWithGeometryMapper(const ClipRectsContext& context, bool isForeground) const
+{
+    DCHECK(m_geometryMapper);
+    LayoutRect source(LayoutRect::infiniteIntRect());
+    bool success = false;
+    const ObjectPaintProperties* properties = m_layer.layoutObject()->objectPaintProperties();
+    PropertyTreeState propertyTreeState = properties->localBorderBoxProperties()->propertyTreeState;
+    if (isForeground) {
+        if (properties->cssClip())
+            propertyTreeState.clip = properties->cssClip();
+        else if (properties->overflowClip())
+            propertyTreeState.clip = properties->overflowClip();
+    }
+
+    const ObjectPaintProperties* ancestorProperties = m_layer.layoutObject()->objectPaintProperties();
+    PropertyTreeState destinationPropertyTreeState = ancestorProperties->localBorderBoxProperties()->propertyTreeState;
+    if (!context.rootLayer->clipper().shouldRespectOverflowClip(context)) {
+        if (ancestorProperties->overflowClip())
+            destinationPropertyTreeState.clip = ancestorProperties->overflowClip();
+    }
+
+    FloatRect clippedRectInRootLayerSpace = m_geometryMapper->mapToVisualRectInDestinationSpace(
+        FloatRect(source), propertyTreeState, destinationPropertyTreeState, success);
+    DCHECK(success);
+    return ClipRect(LayoutRect(clippedRectInRootLayerSpace));
+}
+
 ClipRect PaintLayerClipper::backgroundClipRect(const ClipRectsContext& context) const
 {
+    if (m_geometryMapper) {
+        return clipRectWithGeometryMapper(context, false);
+    }
+
     ASSERT(m_layer.parent());
     LayoutView* layoutView = m_layer.layoutObject()->view();
     ASSERT(layoutView);
 
     RefPtr<ClipRects> parentClipRects = ClipRects::create();
     if (&m_layer == context.rootLayer)
         parentClipRects->reset(LayoutRect(LayoutRect::infiniteIntRect()));
     else
         m_layer.parent()->clipper().getOrCalculateClipRects(context, *parentClipRects);
 
@@ skipping 23 matching lines @@
         return false;
 
     if (m_layer.isRootLayer() && context.respectOverflowClipForViewport == IgnoreOverflowClip)
         return false;
 
     return true;
 }
 
 ClipRects& PaintLayerClipper::paintingClipRects(const PaintLayer* rootLayer, ShouldRespectOverflowClipType respectOverflowClip, const LayoutSize& subpixelAccumulation) const
 {
+    DCHECK(!m_geometryMapper);
     ClipRectsContext context(rootLayer, PaintingClipRects, IgnoreOverlayScrollbarSize, subpixelAccumulation);
     if (respectOverflowClip == IgnoreOverflowClip)
         context.setIgnoreOverflowClip();
     return getClipRects(context);
 }
 
 } // namespace blink