Revert of Reduce copying of local data structures in GeometryMapper and 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 182 matching lines @@
     for (const PaintLayer* layer = currentLayer->firstChild(); layer;
          layer = layer->nextSibling())
       layers.push(layer);
   }
 }
 
 LayoutRect PaintLayerClipper::localClipRect(
     const PaintLayer& clippingRootLayer) const {
   ClipRectsContext context(&clippingRootLayer, PaintingClipRects);
   if (m_geometryMapper) {
-    ClipRect clipRect;
-    calculateClipRectWithGeometryMapper(context, false, clipRect);
+    ClipRect clipRect = clipRectWithGeometryMapper(context, false);
     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()
                                              ->transform();
     const auto* layerTransform = m_layer.layoutObject()
                                      .paintProperties()
                                      ->localBorderBoxProperties()
                                      ->transform();
-    FloatRect clippedRectInLocalSpace(premappedRect);
-    m_geometryMapper->sourceToDestinationRect(
-        clipRootLayerTransform, layerTransform, clippedRectInLocalSpace);
+    FloatRect clippedRectInLocalSpace =
+        m_geometryMapper->sourceToDestinationRect(
+            FloatRect(premappedRect), clipRootLayerTransform, layerTransform);
     clippedRectInLocalSpace.moveBy(
         -FloatPoint(m_layer.layoutObject().paintOffset()));
 
     return LayoutRect(clippedRectInLocalSpace);
   }
 
   LayoutRect layerBounds;
   ClipRect backgroundRect, foregroundRect;
   calculateRects(context, LayoutRect(LayoutRect::infiniteIntRect()),
                  layerBounds, backgroundRect, foregroundRect);
@@ skipping 31 matching lines @@
 
   const auto* layerTransform = m_layer.layoutObject()
                                    .paintProperties()
                                    ->localBorderBoxProperties()
                                    ->transform();
   const auto* rootTransform = context.rootLayer->layoutObject()
                                   .paintProperties()
                                   ->localBorderBoxProperties()
                                   ->transform();
 
-  FloatRect floatRect(rectToMap);
-  floatRect.moveBy(FloatPoint(m_layer.layoutObject().paintOffset()));
-  m_geometryMapper->sourceToDestinationRect(layerTransform, rootTransform,
-                                            floatRect);
-  rectToMap = LayoutRect(floatRect);
+  FloatRect localRect(rectToMap);
+  localRect.moveBy(FloatPoint(m_layer.layoutObject().paintOffset()));
+  rectToMap = LayoutRect(m_geometryMapper->sourceToDestinationRect(
+      localRect, layerTransform, rootTransform));
   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);
+    backgroundRect = clipRectWithGeometryMapper(context, false);
 
     backgroundRect.move(context.subPixelAccumulation);
     backgroundRect.intersect(paintDirtyRect);
 
     applyOverflowClipToBackgroundRectWithGeometryMapper(context,
                                                         backgroundRect);
 
-    calculateClipRectWithGeometryMapper(context, true, foregroundRect);
+    foregroundRect = clipRectWithGeometryMapper(context, true);
     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()));
 
@@ skipping 20 matching lines @@
     calculateRectsWithGeometryMapper(context, paintDirtyRect, layerBounds,
                                      backgroundRect, foregroundRect,
                                      offsetFromRoot);
     return;
   }
 
   bool isClippingRoot = &m_layer == context.rootLayer;
   LayoutBoxModelObject& layoutObject = m_layer.layoutObject();
 
   if (!isClippingRoot && m_layer.parent()) {
-    calculateBackgroundClipRect(context, backgroundRect);
+    backgroundRect = backgroundClipRect(context);
     backgroundRect.move(context.subPixelAccumulation);
     backgroundRect.intersect(paintDirtyRect);
   } else {
     backgroundRect = paintDirtyRect;
   }
 
   foregroundRect = backgroundRect;
 
   LayoutPoint offset;
   if (offsetFromRoot)
@@ skipping 80 matching lines @@
                                               EPosition position) {
   if (position == EPosition::kFixed)
     return parentRects.fixedClipRect();
 
   if (position == EPosition::kAbsolute)
     return parentRects.posClipRect();
 
   return parentRects.overflowClipRect();
 }
 
-void PaintLayerClipper::calculateClipRectWithGeometryMapper(
+ClipRect PaintLayerClipper::clipRectWithGeometryMapper(
     const ClipRectsContext& context,
-    bool isForeground,
-    ClipRect& output) const {
+    bool isForeground) const {
   DCHECK(m_geometryMapper);
   const auto* properties = m_layer.layoutObject().paintProperties();
   DCHECK(properties && properties->localBorderBoxProperties());
 
   PropertyTreeState propertyTreeState = *properties->localBorderBoxProperties();
   const auto* ancestorProperties =
       context.rootLayer->layoutObject().paintProperties();
   DCHECK(ancestorProperties && ancestorProperties->localBorderBoxProperties());
   PropertyTreeState destinationPropertyTreeState =
       *ancestorProperties->localBorderBoxProperties();
@@ skipping 10 matching lines @@
     if (context.respectOverflowClip == IgnoreOverflowClip &&
         ancestorProperties->overflowClip())
       destinationPropertyTreeState.setClip(ancestorProperties->overflowClip());
 
     // Set the overflow clip for |propertyTreeState| so that it differs from
     // destinationPropertyTreeState| in its clip.
     if (isForeground && properties->overflowClip())
       propertyTreeState.setClip(properties->overflowClip());
   }
 
-  const FloatClipRect& clippedRectInRootLayerSpace =
+  FloatClipRect clippedRectInRootLayerSpace =
       m_geometryMapper->sourceToDestinationClipRect(
           propertyTreeState, destinationPropertyTreeState);
-  output.setRect(clippedRectInRootLayerSpace);
+  ClipRect clipRect(LayoutRect(clippedRectInRootLayerSpace.rect()));
+  if (clippedRectInRootLayerSpace.hasRadius())
+    clipRect.setHasRadius(true);
 
-  output.moveBy(-context.rootLayer->layoutObject().paintOffset());
+  clipRect.moveBy(-context.rootLayer->layoutObject().paintOffset());
+  return clipRect;
 }
 
 void PaintLayerClipper::applyOverflowClipToBackgroundRectWithGeometryMapper(
     const ClipRectsContext& context,
     ClipRect& clip) const {
   const LayoutObject& layoutObject = m_layer.layoutObject();
   if (!shouldClipOverflow(context))
     return;
   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);
   mapLocalToRootWithGeometryMapper(context, layerBoundsWithVisualOverflow);
   clip.intersect(layerBoundsWithVisualOverflow);
 }
 
-void PaintLayerClipper::calculateBackgroundClipRect(
-    const ClipRectsContext& context,
-    ClipRect& output) const {
+ClipRect PaintLayerClipper::backgroundClipRect(
+    const ClipRectsContext& context) const {
   if (m_geometryMapper) {
     // TODO(chrishtr): fix the underlying bug that causes this situation.
-    if (!m_layer.layoutObject().paintProperties()) {
-      output.setRect(FloatClipRect());
-      return;
-    }
+    if (!m_layer.layoutObject().paintProperties())
+      return ClipRect(LayoutRect(LayoutRect::infiniteIntRect()));
 
-    calculateClipRectWithGeometryMapper(context, false, output);
+    ClipRect backgroundClipRect = clipRectWithGeometryMapper(context, false);
 #ifdef CHECK_CLIP_RECTS
     ClipRect testBackgroundClipRect =
         PaintLayerClipper(m_layer, nullptr).backgroundClipRect(context);
-    CHECK_RECTS_EQ(testBackgroundClipRect, output);
+    CHECK_RECTS_EQ(testBackgroundClipRect, backgroundClipRect);
 #endif
-    return;
+    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 {
     PaintLayerClipper(*m_layer.parent(), m_geometryMapper)
         .getOrCalculateClipRects(context, *parentClipRects);
   }
 
-  output = backgroundClipRectForPosition(
+  ClipRect result = backgroundClipRectForPosition(
       *parentClipRects, m_layer.layoutObject().styleRef().position());
 
   // Note: infinite clipRects should not be scrolled here, otherwise they will
   // accidentally no longer be considered infinite.
   if (parentClipRects->fixed() &&
       &context.rootLayer->layoutObject() == layoutView &&
-      output != LayoutRect(LayoutRect::infiniteIntRect()))
-    output.move(LayoutSize(layoutView->frameView()->getScrollOffset()));
+      result != LayoutRect(LayoutRect::infiniteIntRect()))
+    result.move(LayoutSize(layoutView->frameView()->getScrollOffset()));
+
+  return result;
 }
 
 void PaintLayerClipper::getOrCalculateClipRects(const ClipRectsContext& context,
                                                 ClipRects& clipRects) const {
   DCHECK(!m_geometryMapper);
 
   if (context.usesCache())
     clipRects = getClipRects(context);
   else
     calculateClipRects(context, clipRects);
@@ skipping 32 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