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"
@@ skipping 324 matching lines @@
     } else {
       context.forcedSubtreeInvalidationFlags = 0;
     }
   }
 
   DCHECK(context.paintInvalidationContainer ==
          object.containerForPaintInvalidation());
   DCHECK(context.paintingLayer == object.paintingLayer());
 }
 
-void PaintInvalidator::updateVisualRect(const LayoutObject& object,
-                                        PaintInvalidatorContext& context) {
-  Optional<ScopedUndoFrameViewContentClipAndScroll>
-      undoFrameViewContentClipAndScroll;
-
-  if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled() &&
-      object.isLayoutView() && !object.isPaintInvalidationContainer()) {
-    undoFrameViewContentClipAndScroll.emplace(*toLayoutView(object).frameView(),
-                                              context);
-  }
-
+void PaintInvalidator::updateVisualRectIfNeeded(
+    const LayoutObject& object,
+    PaintInvalidatorContext& context) {
   // 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();
 
+  if (!needsVisualRectUpdate(object, context)) {
+#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 needsPaintOffsetAndVisualRectUpdate:"
+        << " object=" << object.debugName()
+        << " old=" << context.oldVisualRect.toString()
+        << " new=" << context.newVisualRect.toString();
+    DCHECK(object.isText() || context.oldLocation == context.newLocation)
+        << "Location changed without needsPaintOffsetAndVisualRectUpdate:"
+        << " old=" << context.oldLocation.toString()
+        << " new=" << context.newLocation.toString();
+#endif
+    context.newVisualRect = context.oldVisualRect;
+    context.newLocation = context.oldLocation;
+    return;
+  }
+
+#if DCHECK_IS_ON()
+  DCHECK(context.treeBuilderContext.updatedForSelf);
+#endif
+  updateVisualRect(object, context);
+  object.getMutableForPainting().setVisualRect(context.newVisualRect);
+  objectPaintInvalidator.setLocationInBacking(context.newLocation);
+}
+
+void PaintInvalidator::updateVisualRect(const LayoutObject& object,
+                                        PaintInvalidatorContext& context) {
+  // The paint offset should already be updated through
+  // PaintPropertyTreeBuilder::updatePropertiesForSelf.
+  DCHECK(context.treeBuilderContext.current.paintOffset ==
+         object.paintOffset());
+
+  Optional<ScopedUndoFrameViewContentClipAndScroll>
+      undoFrameViewContentClipAndScroll;
+  if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled() &&
+      object.isLayoutView() && !object.isPaintInvalidationContainer()) {
+    undoFrameViewContentClipAndScroll.emplace(*toLayoutView(object).frameView(),
+                                              context);
+  }
+
   IntSize adjustment = object.scrollAdjustmentForPaintInvalidation(
       *context.paintInvalidationContainer);
   context.newVisualRect = computeVisualRectInBacking(object, context);
   context.newVisualRect.move(adjustment);
 
   if (object.isText()) {
     // Use visual rect location for LayoutTexts because it suffices to check
     // whether a visual rect changes for layout caused invalidation.
     context.newLocation = context.newVisualRect.location();
   } else {
     context.newLocation = computeLocationInBacking(object, context);
     context.newLocation.move(adjustment);
 
     // Location of empty visual rect doesn't affect paint invalidation. Set it
     // to newLocation to avoid saving the previous location separately in
     // ObjectPaintInvalidator.
     if (context.newVisualRect.isEmpty())
       context.newVisualRect.setLocation(context.newLocation);
   }
-
-  object.getMutableForPainting().setVisualRect(context.newVisualRect);
-  objectPaintInvalidator.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);
     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.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);
+  updateVisualRectIfNeeded(object, context);
 
-  bool objectShouldCheckForPaintInvalidation =
-      object
-          .shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState();
-  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;
-  }
-
-  updateVisualRect(object, context);
-
-  if (!objectShouldCheckForPaintInvalidation &&
-      context.forcedSubtreeInvalidationFlags ==
-          PaintInvalidatorContext::ForcedSubtreeInvalidationRectUpdate) {
-    // We are done updating the visual rect. No other paint invalidation work to
+  if (!object
+           .shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState() &&
+      !(context.forcedSubtreeInvalidationFlags &
+        ~PaintInvalidatorContext::ForcedSubtreeVisualRectUpdate)) {
+    // We are done updating anything needed. No other paint invalidation work to
     // do for this object.
     return;
   }
 
   PaintInvalidationReason reason = object.invalidatePaintIfNeeded(context);
   switch (reason) {
     case PaintInvalidationDelayedFull:
       m_pendingDelayedPaintInvalidations.push_back(&object);
       break;
     case PaintInvalidationSubtree:
@@ skipping 20 matching lines @@
         PaintInvalidatorContext::ForcedSubtreeInvalidationChecking;
   }
 }
 
 void PaintInvalidator::processPendingDelayedPaintInvalidations() {
   for (auto target : m_pendingDelayedPaintInvalidations)
     target->getMutableForPainting().setShouldDoFullPaintInvalidation(
         PaintInvalidationDelayedFull);
 }
 
+bool PaintInvalidator::needsVisualRectUpdate(
+    const LayoutObject& object,
+    const PaintInvalidatorContext& context) {
+  return object.needsPaintOffsetAndVisualRectUpdate() ||
+         (context.forcedSubtreeInvalidationFlags &
+          ~PaintInvalidatorContext::ForcedSubtreeSlowPathRect);
+}
+
 }  // namespace blink