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>
@@ skipping 30 matching lines @@
  * 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/layout/svg/LayoutSVGRoot.h"
+#include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintLayer.h"
+#include "core/paint/PaintPropertyTreePrinter.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 15 matching lines @@
          (layoutObject.isSVGRoot() &&
           toLayoutSVGRoot(&layoutObject)->shouldApplyViewportClip()));
   LayoutView* view = layoutObject.view();
   DCHECK(view);
   if (clipRects.fixed() && context.rootLayer->layoutObject() == view)
     offset -= toIntSize(view->frameView()->scrollPosition());
   if (layoutObject.hasOverflowClip() ||
       (layoutObject.isSVGRoot() &&
        toLayoutSVGRoot(&layoutObject)->shouldApplyViewportClip()) ||
       (layoutObject.styleRef().containsPaint() && layoutObject.isBox())) {
-    ClipRect newOverflowClip =
+    ClipRect newOverflowClip;
+    newOverflowClip =
         toLayoutBox(layoutObject)
             .overflowClipRect(offset, context.overlayScrollbarClipBehavior);
     newOverflowClip.setHasRadius(layoutObject.styleRef().hasBorderRadius());
     clipRects.setOverflowClipRect(
         intersection(newOverflowClip, clipRects.overflowClipRect()));
     if (layoutObject.isPositioned())
       clipRects.setPosClipRect(
           intersection(newOverflowClip, clipRects.posClipRect()));
     if (layoutObject.isLayoutView())
       clipRects.setFixedClipRect(
@@ skipping 10 matching lines @@
     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,
+                                     bool useGeometryMapper)
+    : m_layer(layer),
+      m_geometryMapper(useGeometryMapper ? new GeometryMapper : nullptr) {}
+
 ClipRects* PaintLayerClipper::clipRectsIfCached(
     const ClipRectsContext& context) const {
   DCHECK(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.
@@ skipping 36 matching lines @@
   // 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();
   calculateClipRects(context, *clipRects);
   return storeClipRectsInCache(context, parentClipRects, *clipRects);
 }
 
 void PaintLayerClipper::clearClipRectsIncludingDescendants() {
+  if (m_geometryMapper)
+    m_geometryMapper.reset(new GeometryMapper);
   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 = applyOverflowClipToBackgroundRectWithGeometryMapper(
+        context, 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;
 }
 
+#ifdef CHECK_CLIP_RECTS
+#define CHECK_RECTS_EQ(expected, actual)                                \
+  CHECK((expected.isEmpty() && actual.isEmpty()) || expected == actual) \
+      << "expected=" << expected.toString() << " actual=" << actual.toString()
+#endif
+
+void PaintLayerClipper::mapLocalToRootWithGeometryMapper(
+    const ClipRectsContext& context,
+    LayoutRect& layoutRect) const {
+  DCHECK(m_geometryMapper);
+  bool success;
+
+  const ObjectPaintProperties::PropertyTreeStateWithOffset*
+      layerBorderBoxProperties = m_layer.layoutObject()
+                                     ->objectPaintProperties()
+                                     ->localBorderBoxProperties();
+  FloatRect localRect(layoutRect);
+  localRect.moveBy(FloatPoint(layerBorderBoxProperties->paintOffset));
+
+  layoutRect = LayoutRect(m_geometryMapper->mapRectToDestinationSpace(
+      localRect, layerBorderBoxProperties->propertyTreeState,
+      context.rootLayer->layoutObject()
+          ->objectPaintProperties()
+          ->localBorderBoxProperties()
+          ->propertyTreeState,
+      success));
+  DCHECK(success);
+}
+
+void PaintLayerClipper::calculateRectsWithGeometryMapper(
+    const ClipRectsContext& context,
+    const LayoutRect& paintDirtyRect,
+    LayoutRect& layerBounds,
+    ClipRect& backgroundRect,
+    ClipRect& foregroundRect,
+    const LayoutPoint* offsetFromRoot) const {
+  backgroundRect = applyOverflowClipToBackgroundRectWithGeometryMapper(
+      context, 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);
+  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;
+  PaintLayerClipper(m_layer, false)
+      .calculateRects(context, paintDirtyRect, testLayerBounds,
+                      testBackgroundRect, testForegroundRect);
+  CHECK_RECTS_EQ(testBackgroundRect, backgroundRect);
+  CHECK_RECTS_EQ(testForegroundRect, foregroundRect);
+  CHECK_RECTS_EQ(testLayerBounds, layerBounds);
+#endif
+}
+
 void PaintLayerClipper::calculateRects(
     const ClipRectsContext& context,
     const LayoutRect& paintDirtyRect,
     LayoutRect& layerBounds,
     ClipRect& backgroundRect,
     ClipRect& foregroundRect,
     const LayoutPoint* offsetFromRoot) const {
+  if (m_geometryMapper) {
+    calculateRectsWithGeometryMapper(context, paintDirtyRect, layerBounds,
+                                     backgroundRect, foregroundRect,
+                                     offsetFromRoot);
+    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 63 matching lines @@
   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);
-
   if ((layoutObject.hasOverflowClip() && shouldRespectOverflowClip(context)) ||
       (layoutObject.isSVGRoot() &&
        toLayoutSVGRoot(&layoutObject)->shouldApplyViewportClip()) ||
       layoutObject.hasClip() || layoutObject.styleRef().containsPaint()) {
     // 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,
                    roundedLayoutPoint(layoutObject.localToAncestorPoint(
                        FloatPoint(), context.rootLayer->layoutObject())),
                    clipRects);
   }
 }
 
 static ClipRect backgroundClipRectForPosition(const ClipRects& parentRects,
                                               EPosition position) {
   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 (properties->cssClip())
+    propertyTreeState.setClip(properties->cssClip());
+
+  const LayoutObject& layoutObject = *m_layer.layoutObject();
+  if (shouldRespectOverflowClip(context) && isForeground &&
+      (layoutObject.hasOverflowClip() ||
+       layoutObject.styleRef().containsPaint())) {
+    if (properties->overflowClip())
+      propertyTreeState.setClip(properties->overflowClip());
+  }
+
+  const ObjectPaintProperties* ancestorProperties =
+      context.rootLayer->layoutObject()->objectPaintProperties();
+  PropertyTreeState destinationPropertyTreeState =
+      ancestorProperties->localBorderBoxProperties()->propertyTreeState;
+  if (!context.rootLayer->clipper().shouldRespectOverflowClip(context)) {
+    if (ancestorProperties->overflowClip())
+      destinationPropertyTreeState.setClip(ancestorProperties->overflowClip());
+  }
+  FloatRect clippedRectInRootLayerSpace =
+      m_geometryMapper->mapToVisualRectInDestinationSpace(
+          FloatRect(source), propertyTreeState, destinationPropertyTreeState,
+          success);
+  DCHECK(success);
+  return ClipRect(LayoutRect(clippedRectInRootLayerSpace));
+}
+
+ClipRect PaintLayerClipper::applyOverflowClipToBackgroundRectWithGeometryMapper(
+    const ClipRectsContext& context,
+    const ClipRect& clip) const {
+  const LayoutObject& layoutObject = *m_layer.layoutObject();
+  FloatRect clipRect(clip.rect());
+  if ((layoutObject.hasOverflowClip() ||
+       layoutObject.styleRef().containsPaint()) &&
+      shouldRespectOverflowClip(context)) {
+    LayoutRect layerBoundsWithVisualOverflow =
+        layoutObject.isLayoutView()
+            ? toLayoutView(layoutObject).viewRect()
+            : toLayoutBox(layoutObject).visualOverflowRect();
+    toLayoutBox(layoutObject)
+        .flipForWritingMode(
+            layerBoundsWithVisualOverflow);  // PaintLayer are in physical coordinates, so the overflow has to be flipped.
+    mapLocalToRootWithGeometryMapper(context, layerBoundsWithVisualOverflow);
+    clipRect.intersect(FloatRect(layerBoundsWithVisualOverflow));
+  }
+
+  return ClipRect(LayoutRect(clipRect));
+}
+
 ClipRect PaintLayerClipper::backgroundClipRect(
     const ClipRectsContext& context) const {
+  if (m_geometryMapper) {
+    ClipRect backgroundClipRect = clipRectWithGeometryMapper(context, false);
+#ifdef CHECK_CLIP_RECTS
+    ClipRect testBackgroundClipRect =
+        PaintLayerClipper(m_layer, false).backgroundClipRect(context);
+    CHECK_RECTS_EQ(testBackgroundClipRect, backgroundClipRect);
+#endif
+    return backgroundClipRect;
+  }
+
   DCHECK(m_layer.parent());
   LayoutView* layoutView = m_layer.layoutObject()->view();
   DCHECK(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 31 matching lines @@
       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