Skip paint property update and visual rect update if no geometry change

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/FindPaintOffsetAndVisualRectNeedingUpdate.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintLayer.h"
 #include "core/paint/PaintLayerScrollableArea.h"
-#include "core/paint/PaintPropertyTreeBuilder.h"
 #include "wtf/Optional.h"
 
 namespace blink {
 
 template <typename Rect>
 static LayoutRect slowMapToVisualRectInAncestorSpace(
     const LayoutObject& object,
     const LayoutBoxModelObject& ancestor,
     const Rect& rect) {
   if (object.isSVGChild()) {
@@ skipping 71 matching lines @@
   } else {
     // For non-root SVG, the input rect is in local SVG coordinates in which
     // paint offset doesn't apply.
     if (!isSVGChild)
       rect.moveBy(Point(object.paintOffset()));
 
     const auto* containerContentsProperties =
         context.paintInvalidationContainer->paintProperties()
             ->contentsProperties();
 
-    if (context.m_treeBuilderContext.current.transform ==
+    if (context.m_treeBuilderContext->current.transform ==
             containerContentsProperties->transform() &&
-        context.m_treeBuilderContext.current.clip ==
+        context.m_treeBuilderContext->current.clip ==
             containerContentsProperties->clip()) {
       result = LayoutRect(rect);
     } else {
       // Use enclosingIntRect to ensure the final visual rect will cover the
       // rect in source coordinates no matter if the painting will use pixel
       // snapping, when transforms are applied. If there is no transform,
       // enclosingIntRect is applied in the last step of paint invalidation
       // (see CompositedLayerMapping::setContentsNeedDisplayInRect()).
-      if (!isSVGChild && context.m_treeBuilderContext.current.transform !=
+      if (!isSVGChild && context.m_treeBuilderContext->current.transform !=
                              containerContentsProperties->transform())
         rect = Rect(enclosingIntRect(rect));
 
       PropertyTreeState currentTreeState(
-          context.m_treeBuilderContext.current.transform,
-          context.m_treeBuilderContext.current.clip, nullptr);
+          context.m_treeBuilderContext->current.transform,
+          context.m_treeBuilderContext->current.clip, nullptr);
 
       FloatRect floatRect(rect);
       context.m_geometryMapper.sourceToDestinationVisualRect(
           currentTreeState, *containerContentsProperties, floatRect);
       result = LayoutRect(floatRect);
     }
 
     // Convert the result to the container's contents space.
     result.moveBy(-context.paintInvalidationContainer->paintOffset());
   }
 
   object.adjustVisualRectForRasterEffects(result);
 
   PaintLayer::mapRectInPaintInvalidationContainerToBacking(
       *context.paintInvalidationContainer, result);
 
   result.move(object.scrollAdjustmentForPaintInvalidation(
       *context.paintInvalidationContainer));
 
   return result;
 }
 
 void PaintInvalidatorContext::mapLocalRectToVisualRectInBacking(
     const LayoutObject& object,
     LayoutRect& rect) const {
+  DCHECK(needsVisualRectUpdate(object));
+  std::unique_ptr<GeometryMapper> geometryMapper = GeometryMapper::create();
   rect = PaintInvalidator::mapLocalRectToVisualRectInBacking<LayoutRect,
                                                              LayoutPoint>(
       object, rect, *this);
 }
 
 LayoutRect PaintInvalidator::computeVisualRectInBacking(
     const LayoutObject& object,
     const PaintInvalidatorContext& context) {
   if (object.isSVGChild()) {
     FloatRect localRect = SVGLayoutSupport::localVisualRect(object);
@@ skipping 12 matching lines @@
     return object.paintOffset();
 
   LayoutPoint point;
   if (object != context.paintInvalidationContainer) {
     point.moveBy(object.paintOffset());
 
     const auto* containerTransform =
         context.paintInvalidationContainer->paintProperties()
             ->contentsProperties()
             ->transform();
-    if (context.m_treeBuilderContext.current.transform != containerTransform) {
+    if (context.m_treeBuilderContext->current.transform != containerTransform) {
       FloatRect rect = FloatRect(FloatPoint(point), FloatSize());
       context.m_geometryMapper.sourceToDestinationRect(
-          context.m_treeBuilderContext.current.transform, containerTransform,
+          context.m_treeBuilderContext->current.transform, containerTransform,
           rect);
       point = LayoutPoint(rect.location());
     }
 
     // Convert the result to the container's contents space.
     point.moveBy(-context.paintInvalidationContainer->paintOffset());
   }
 
   if (context.paintInvalidationContainer->layer()->groupedMapping()) {
     FloatPoint floatPoint(point);
@@ skipping 125 matching lines @@
       context.forcedSubtreeInvalidationFlags |=
           PaintInvalidatorContext::ForcedSubtreeFullInvalidation;
   }
 
   if (object == context.paintInvalidationContainer) {
     // When we hit a new paint invalidation container, we don't need to
     // continue forcing a check for paint invalidation, since we're
     // descending into a different invalidation container. (For instance if
     // our parents were moved, the entire container will just move.)
     if (object != context.paintInvalidationContainerForStackedContents) {
-      // However, we need to keep the
-      // ForcedSubtreeFullInvalidationForStackedContents flag if the current
+      // However, we need to keep ForcedSubtreeVisualRectUpdate and
+      // ForcedSubtreeFullInvalidationForStackedContents flags if the current
       // object isn't the paint invalidation container of stacked contents.
-      context.forcedSubtreeInvalidationFlags &= PaintInvalidatorContext::
-          ForcedSubtreeFullInvalidationForStackedContents;
+      context.forcedSubtreeInvalidationFlags &=
+          (PaintInvalidatorContext::ForcedSubtreeVisualRectUpdate |
+           PaintInvalidatorContext::
+               ForcedSubtreeFullInvalidationForStackedContents);
     } else {
       context.forcedSubtreeInvalidationFlags = 0;
     }
   }
 
   DCHECK(context.paintInvalidationContainer ==
          object.containerForPaintInvalidation());
   DCHECK(context.paintingLayer == object.paintingLayer());
 }
 
+void PaintInvalidator::updateVisualRectIfNeeded(
+    const LayoutObject& object,
+    PaintInvalidatorContext& context) {
+  context.oldVisualRect = object.visualRect();
+  context.oldLocation = ObjectPaintInvalidator(object).locationInBacking();
+
+#if DCHECK_IS_ON()
+  FindObjectVisualRectNeedingUpdateScope finder(object, context);
+#endif
+
+  if (!context.needsVisualRectUpdate(object)) {
+    context.newLocation = context.oldLocation;
+    return;
+  }
+
+  updateVisualRect(object, context);
+}
+
 void PaintInvalidator::updateVisualRect(const LayoutObject& object,
                                         PaintInvalidatorContext& context) {
+  // The paint offset should already be updated through
+  // PaintPropertyTreeBuilder::updatePropertiesForSelf.
+  DCHECK(context.m_treeBuilderContext);
+  DCHECK(context.m_treeBuilderContext->current.paintOffset ==
+         object.paintOffset());
+
   Optional<ScopedUndoFrameViewContentClipAndScroll>
       undoFrameViewContentClipAndScroll;
 
   if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled() &&
       object.isLayoutView() && !object.isPaintInvalidationContainer()) {
     undoFrameViewContentClipAndScroll.emplace(*toLayoutView(object).frameView(),
-                                              context.m_treeBuilderContext);
+                                              *context.m_treeBuilderContext);
   }
 
-  // TODO(crbug.com/637313): Use GeometryMapper which now supports filter
-  // geometry effects, after skia optimizes filter's mapRect operation.
-  // TODO(crbug.com/648274): This is a workaround for multi-column contents.
-  if (object.hasFilterInducingProperty() || object.isLayoutFlowThread()) {
-    context.forcedSubtreeInvalidationFlags |=
-        PaintInvalidatorContext::ForcedSubtreeSlowPathRect;
-  }
-
-  ObjectPaintInvalidator objectPaintInvalidator(object);
-  context.oldVisualRect = object.visualRect();
-  context.oldLocation = objectPaintInvalidator.locationInBacking();
-
   LayoutRect newVisualRect = computeVisualRectInBacking(object, context);
   if (object.isBoxModelObject()) {
     context.newLocation = computeLocationInBacking(object, context);
-
     // Location of empty visual rect doesn't affect paint invalidation. Set it
     // to newLocation to avoid saving the previous location separately in
     // ObjectPaintInvalidator.
     if (newVisualRect.isEmpty())
       newVisualRect.setLocation(context.newLocation);
   } else {
     // Use visual rect location for non-LayoutBoxModelObject because it suffices
     // to check whether a visual rect changes for layout caused invalidation.
     context.newLocation = newVisualRect.location();
   }
 
   object.getMutableForPainting().setVisualRect(newVisualRect);
-  objectPaintInvalidator.setLocationInBacking(context.newLocation);
+  ObjectPaintInvalidator(object).setLocationInBacking(context.newLocation);
 }
 
 void PaintInvalidator::invalidatePaintIfNeeded(
     FrameView& frameView,
     PaintInvalidatorContext& context) {
   LayoutView* layoutView = frameView.layoutView();
   CHECK(layoutView);
 
   context.paintInvalidationContainer =
       context.paintInvalidationContainerForStackedContents =
           &layoutView->containerForPaintInvalidation();
   context.paintingLayer = layoutView->layer();
 
   if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
-    ScopedUndoFrameViewContentClipAndScroll undo(frameView,
-                                                 context.m_treeBuilderContext);
+    Optional<ScopedUndoFrameViewContentClipAndScroll> undo;
+    if (context.m_treeBuilderContext)
+      undo.emplace(frameView, *context.m_treeBuilderContext);
     frameView.invalidatePaintOfScrollControlsIfNeeded(context);
   }
 }
 
 void PaintInvalidator::invalidatePaintIfNeeded(
     const LayoutObject& object,
     PaintInvalidatorContext& context) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.invalidation"),
                "PaintInvalidator::invalidatePaintIfNeeded()", "object",
                object.debugName().ascii());
 
   object.getMutableForPainting().ensureIsReadyForPaintInvalidation();
 
-  // The paint offset should already be updated through
-  // PaintPropertyTreeBuilder::updatePropertiesForSelf.
-  DCHECK(context.m_treeBuilderContext.current.paintOffset ==
-         object.paintOffset());
-
   updatePaintingLayer(object, context);
 
   if (object.document().printing() &&
       !RuntimeEnabledFeatures::printBrowserEnabled())
     return;  // Don't invalidate paints if we're printing.
 
-  updatePaintInvalidationContainer(object, context);
-
-  bool objectShouldCheckForPaintInvalidation =
-      object.shouldCheckForPaintInvalidation();
-  if (!context.forcedSubtreeInvalidationFlags &&
-      !objectShouldCheckForPaintInvalidation) {
-#if CHECK_VISUAL_RECT_UPDATE
-    updateVisualRect(object, context);
-    DCHECK(
-        (context.oldVisualRect.isEmpty() && context.newVisualRect.isEmpty()) ||
-        enclosingIntRect(context.oldVisualRect) ==
-            enclosingIntRect(context.newVisualRect))
-        << "Visual rect changed without needing paint invalidation:"
-        << " object=" << object.debugName()
-        << " old=" << context.oldVisualRect.toString()
-        << " new=" << context.newVisualRect.toString();
-    DCHECK(object.isText() || context.oldLocation == context.newLocation)
-        << "Location changed without needing paint invalidation:"
-        << " old=" << context.oldLocation.toString()
-        << " new=" << context.newLocation.toString();
-#endif
-    return;
+  // TODO(crbug.com/637313): Use GeometryMapper which now supports filter
+  // geometry effects, after skia optimizes filter's mapRect operation.
+  // TODO(crbug.com/648274): This is a workaround for multi-column contents.
+  if (object.hasFilterInducingProperty() || object.isLayoutFlowThread()) {
+    context.forcedSubtreeInvalidationFlags |=
+        PaintInvalidatorContext::ForcedSubtreeSlowPathRect;
   }
 
-  updateVisualRect(object, context);
+  updatePaintInvalidationContainer(object, context);
+  updateVisualRectIfNeeded(object, context);
 
-  if (!objectShouldCheckForPaintInvalidation &&
-      context.forcedSubtreeInvalidationFlags ==
-          PaintInvalidatorContext::ForcedSubtreeInvalidationRectUpdate) {
-    // We are done updating the visual rect. No other paint invalidation work to
+  if (!object.shouldCheckForPaintInvalidation() &&
+      !(context.forcedSubtreeInvalidationFlags &
+        ~PaintInvalidatorContext::ForcedSubtreeVisualRectUpdate)) {
+    // We are done updating anything needed. No other paint invalidation work to
     // do for this object.
     return;
   }
 
   if (object.isSVGHiddenContainer()) {
     context.forcedSubtreeInvalidationFlags |=
         PaintInvalidatorContext::ForcedSubtreeNoRasterInvalidation;
   }
 
   PaintInvalidationReason reason = object.invalidatePaintIfNeeded(context);
@@ skipping 17 matching lines @@
 
   if (object.mayNeedPaintInvalidationSubtree()) {
     context.forcedSubtreeInvalidationFlags |=
         PaintInvalidatorContext::ForcedSubtreeInvalidationChecking;
   }
 
   if (context.oldLocation != context.newLocation) {
     context.forcedSubtreeInvalidationFlags |=
         PaintInvalidatorContext::ForcedSubtreeInvalidationChecking;
   }
+
+  if (context.forcedSubtreeInvalidationFlags &&
+      context.needsVisualRectUpdate(object)) {
+    // If any subtree flag is set, we also need to pass needsVisualRectUpdate
+    // requirement to the subtree.
+    context.forcedSubtreeInvalidationFlags |=
+        PaintInvalidatorContext::ForcedSubtreeVisualRectUpdate;
+  }
 }
 
 void PaintInvalidator::processPendingDelayedPaintInvalidations() {
-  for (auto target : m_pendingDelayedPaintInvalidations)
+  for (auto target : m_pendingDelayedPaintInvalidations) {
     target->getMutableForPainting().setShouldDoFullPaintInvalidation(
         PaintInvalidationDelayedFull);
+  }
 }
 
 }  // namespace blink