Use enclosingLayoutRect instead of enclosingIntRect in SVGLayoutSupport::transformPaintInvalidation…

third_party/WebKit/Source/core/paint/PaintInvalidator.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/PaintInvalidator.h"
 
 #include "core/editing/FrameSelection.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTable.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/svg/SVGLayoutSupport.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintLayer.h"
 #include "core/paint/PaintLayerScrollableArea.h"
 #include "core/paint/PaintPropertyTreeBuilder.h"
 
 namespace blink {
 
+// TODO(wangxianzhu): Avoid using function when possible. For example, we can
+// avoid it by avoiding unnecessary conversions between LayoutRects and
+// FloatRects.
+static LayoutRect enclosingLayoutRectIfNotEmpty(const FloatRect& floatRect) {
+  return floatRect.isEmpty() ? LayoutRect(floatRect)
+                             : enclosingLayoutRect(floatRect);
+}
+
 static LayoutRect slowMapToVisualRectInAncestorSpace(
     const LayoutObject& object,
     const LayoutBoxModelObject& ancestor,
     const FloatRect& rect) {
   if (object.isSVG() && !object.isSVGRoot()) {
     LayoutRect result;
     SVGLayoutSupport::mapToVisualRectInAncestorSpace(object, &ancestor, rect,
                                                      result);
     return result;
   }
 
-  LayoutRect result(rect);
+  LayoutRect result = enclosingLayoutRectIfNotEmpty(rect);
   if (object.isLayoutView())
     toLayoutView(object).mapToVisualRectInAncestorSpace(
         &ancestor, result, InputIsInFrameCoordinates, DefaultVisualRectFlags);
   else
     object.mapToVisualRectInAncestorSpace(&ancestor, result);
   return result;
 }
 
-// TODO(wangxianzhu): Combine this into PaintInvalidator::mapLocalRectToPaintInvalidationBacking() when removing PaintInvalidationState.
+// TODO(wangxianzhu): Combine this into
+// PaintInvalidator::mapLocalRectToPaintInvalidationBacking() when removing
+// PaintInvalidationState.
 static LayoutRect mapLocalRectToPaintInvalidationBacking(
     GeometryMapper& geometryMapper,
     const LayoutObject& object,
     const FloatRect& localRect,
     const PaintInvalidatorContext& context) {
   // TODO(wkorman): The flip below is required because visual rects are
   // currently in "physical coordinates with flipped block-flow direction"
   // (see LayoutBoxModelObject.h) but we need them to be in physical
   // coordinates.
   FloatRect rect = localRect;
   // Writing-mode flipping doesn't apply to non-root SVG.
   if (!object.isSVG() || object.isSVGRoot()) {
     if (object.isBox()) {
       toLayoutBox(object).flipForWritingMode(rect);
     } else if (!(context.forcedSubtreeInvalidationFlags &
                  PaintInvalidatorContext::ForcedSubtreeSlowPathRect)) {
       // For SPv2 and the GeometryMapper path, we also need to convert the rect
       // for non-boxes into physical coordinates before applying paint offset.
       // (Otherwise we'll call mapToVisualrectInAncestorSpace() which requires
       // physical coordinates for boxes, but "physical coordinates with flipped
       // block-flow direction" for non-boxes for which we don't need to flip.)
       // TODO(wangxianzhu): Avoid containingBlock().
       object.containingBlock()->flipForWritingMode(rect);
     }
   }
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     // In SPv2, visual rects are in the space of their local transform node.
     rect.moveBy(FloatPoint(context.treeBuilderContext.current.paintOffset));
-    return LayoutRect(rect);
+    return enclosingLayoutRectIfNotEmpty(rect);
   }
 
   LayoutRect result;
   if (context.forcedSubtreeInvalidationFlags &
       PaintInvalidatorContext::ForcedSubtreeSlowPathRect) {
     result = slowMapToVisualRectInAncestorSpace(
         object, *context.paintInvalidationContainer, rect);
   } else if (object == context.paintInvalidationContainer) {
-    result = LayoutRect(rect);
+    result = enclosingLayoutRectIfNotEmpty(rect);
   } else {
     rect.moveBy(FloatPoint(context.treeBuilderContext.current.paintOffset));
 
     PropertyTreeState currentTreeState(
         context.treeBuilderContext.current.transform,
         context.treeBuilderContext.current.clip,
         context.treeBuilderContext.currentEffect,
         context.treeBuilderContext.current.scroll);
     const ObjectPaintProperties* containerPaintProperties =
         context.paintInvalidationContainer->objectPaintProperties();
     auto containerContentsProperties =
         containerPaintProperties->contentsProperties();
 
     bool success = false;
-    result = LayoutRect(geometryMapper.mapToVisualRectInDestinationSpace(
-        rect, currentTreeState, containerContentsProperties.propertyTreeState,
-        success));
+    result = enclosingLayoutRectIfNotEmpty(
+        geometryMapper.mapToVisualRectInDestinationSpace(
+            rect, currentTreeState,
+            containerContentsProperties.propertyTreeState, success));
     DCHECK(success);
 
     // Convert the result to the container's contents space.
     result.moveBy(-containerContentsProperties.paintOffset);
   }
 
   if (context.paintInvalidationContainer->layer()->groupedMapping())
     PaintLayer::mapRectInPaintInvalidationContainerToBacking(
         *context.paintInvalidationContainer, result);
   return result;
@@ skipping 318 matching lines @@
   object.getMutableForPainting().clearPaintInvalidationFlags();
 }
 
 void PaintInvalidator::processPendingDelayedPaintInvalidations() {
   for (auto target : m_pendingDelayedPaintInvalidations)
     target->getMutableForPainting().setShouldDoFullPaintInvalidation(
         PaintInvalidationDelayedFull);
 }
 
 }  // namespace blink