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

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

 // Copyright 2015 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/PrePaintTreeWalk.h"
 
 #include "core/dom/DocumentLifecycle.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutMultiColumnSpannerPlaceholder.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/PaintLayer.h"
 
 namespace blink {
 
 struct PrePaintTreeWalkContext {
   PrePaintTreeWalkContext(GeometryMapper& geometryMapper)
       : treeBuilderContext(
             WTF::wrapUnique(new PaintPropertyTreeBuilderContext)),
-        paintInvalidatorContext(*treeBuilderContext, geometryMapper),
+        paintInvalidatorContext(treeBuilderContext.get(), geometryMapper),
         ancestorOverflowPaintLayer(nullptr),
         ancestorTransformedOrRootPaintLayer(nullptr) {}
-  PrePaintTreeWalkContext(const PrePaintTreeWalkContext& parentContext)
-      : treeBuilderContext(WTF::wrapUnique(new PaintPropertyTreeBuilderContext(
-            *parentContext.treeBuilderContext))),
-        paintInvalidatorContext(*treeBuilderContext,
+
+  PrePaintTreeWalkContext(const PrePaintTreeWalkContext& parentContext,
+                          bool needsTreeBuilderContext)
+      : treeBuilderContext(
+            WTF::wrapUnique(needsTreeBuilderContext || DCHECK_IS_ON()
+                                ? new PaintPropertyTreeBuilderContext(
+                                      *parentContext.treeBuilderContext)
+                                : nullptr)),
+        paintInvalidatorContext(treeBuilderContext.get(),
                                 parentContext.paintInvalidatorContext),
         ancestorOverflowPaintLayer(parentContext.ancestorOverflowPaintLayer),
         ancestorTransformedOrRootPaintLayer(
-            parentContext.ancestorTransformedOrRootPaintLayer) {}
+            parentContext.ancestorTransformedOrRootPaintLayer) {
+#if DCHECK_IS_ON()
+    if (needsTreeBuilderContext)
+      DCHECK(parentContext.treeBuilderContext->isActuallyNeeded);
+    treeBuilderContext->isActuallyNeeded = needsTreeBuilderContext;
+#endif
+  }
 
   // PaintPropertyTreeBuilderContext is large and can lead to stack overflows
   // when recursion is deep so this context object is allocated on the heap.
   // See: https://crbug.com/698653.
   std::unique_ptr<PaintPropertyTreeBuilderContext> treeBuilderContext;
 
   PaintInvalidatorContext paintInvalidatorContext;
 
   // The ancestor in the PaintLayer tree which has overflow clip, or
   // is the root layer. Note that it is tree ancestor, not containing
   // block or stacking ancestor.
   PaintLayer* ancestorOverflowPaintLayer;
   PaintLayer* ancestorTransformedOrRootPaintLayer;
 };
 
 void PrePaintTreeWalk::walk(FrameView& rootFrame) {
   DCHECK(rootFrame.frame().document()->lifecycle().state() ==
          DocumentLifecycle::InPrePaint);
 
   PrePaintTreeWalkContext initialContext(m_geometryMapper);
   initialContext.ancestorTransformedOrRootPaintLayer =
       rootFrame.layoutView()->layer();
 
   // GeometryMapper depends on paint properties.
-  if (rootFrame.needsPaintPropertyUpdate() ||
-      (rootFrame.layoutView() &&
-       !shouldEndWalkBefore(*rootFrame.layoutView(), initialContext)))
+  if (needsTreeBuilderContextUpdate(rootFrame, initialContext))
     m_geometryMapper.clearCache();
 
   walk(rootFrame, initialContext);
   m_paintInvalidator.processPendingDelayedPaintInvalidations();
 }
 
 void PrePaintTreeWalk::walk(FrameView& frameView,
                             const PrePaintTreeWalkContext& parentContext) {
   if (frameView.shouldThrottleRendering()) {
     // Skip the throttled frame. Will update it when it becomes unthrottled.
     return;
   }
 
-  PrePaintTreeWalkContext context(parentContext);
+  bool needsTreeBuilderContextUpdate =
+      this->needsTreeBuilderContextUpdate(frameView, parentContext);
+  PrePaintTreeWalkContext context(parentContext, needsTreeBuilderContextUpdate);
   // ancestorOverflowLayer does not cross frame boundaries.
   context.ancestorOverflowPaintLayer = nullptr;
-  m_propertyTreeBuilder.updateProperties(frameView,
-                                         *context.treeBuilderContext);
+  if (context.treeBuilderContext) {
+    m_propertyTreeBuilder.updateProperties(frameView,
+                                           *context.treeBuilderContext);
+  }
   m_paintInvalidator.invalidatePaintIfNeeded(frameView,
                                              context.paintInvalidatorContext);
 
   if (LayoutView* view = frameView.layoutView()) {
     walk(*view, context);
 #if DCHECK_IS_ON()
     view->assertSubtreeClearedPaintInvalidationFlags();
 #endif
   }
   frameView.clearNeedsPaintPropertyUpdate();
@@ skipping 130 matching lines @@
   ClipRects* previousClipRects = paintLayer.previousPaintingClipRects();
 
   if (!previousClipRects || *clipRects != *previousClipRects) {
     paintLayer.setNeedsRepaint();
     paintLayer.setPreviousPaintPhaseDescendantOutlinesEmpty(false);
     paintLayer.setPreviousPaintPhaseFloatEmpty(false);
     paintLayer.setPreviousPaintPhaseDescendantBlockBackgroundsEmpty(false);
     // All subsequences which are contained below this paintLayer must also
     // be checked.
     context.paintInvalidatorContext.forcedSubtreeInvalidationFlags |=
-        PaintInvalidatorContext::ForcedSubtreeInvalidationRectUpdate;
+        PaintInvalidatorContext::ForcedSubtreeVisualRectUpdate;
   }
 
   paintLayer.setPreviousPaintingClipRects(*clipRects);
 }
 
-bool PrePaintTreeWalk::shouldEndWalkBefore(
+bool PrePaintTreeWalk::needsTreeBuilderContextUpdate(
+    const FrameView& frameView,
+    const PrePaintTreeWalkContext& context) {
+  return frameView.needsPaintPropertyUpdate() ||
+         (frameView.layoutView() &&
+          needsTreeBuilderContextUpdate(*frameView.layoutView(), context));
+}
+
+bool PrePaintTreeWalk::needsTreeBuilderContextUpdate(
     const LayoutObject& object,
-    const PrePaintTreeWalkContext& context) {
-  return !object.needsPaintPropertyUpdate() &&
-         !object.descendantNeedsPaintPropertyUpdate() &&
-         !context.treeBuilderContext->forceSubtreeUpdate &&
-         !context.paintInvalidatorContext.forcedSubtreeInvalidationFlags &&
-         !object.shouldCheckForPaintInvalidation();
+    const PrePaintTreeWalkContext& parentContext) {
+  return object.needsPaintPropertyUpdate() ||
+         object.descendantNeedsPaintPropertyUpdate() ||
+         (parentContext.treeBuilderContext &&
+          parentContext.treeBuilderContext->forceSubtreeUpdate) ||
+         // If the object needs visual rect update, we should update tree
+         // builder context which is needed by visual rect update.
+         parentContext.paintInvalidatorContext.needsVisualRectUpdate(object);
 }
 
 void PrePaintTreeWalk::walk(const LayoutObject& object,
                             const PrePaintTreeWalkContext& parentContext) {
-  if (shouldEndWalkBefore(object, parentContext))
+  // Early out from the tree walk if possible.
+  bool needsTreeBuilderContextUpdate =
+      this->needsTreeBuilderContextUpdate(object, parentContext);
+  if (!needsTreeBuilderContextUpdate &&
+      !object.shouldCheckForPaintInvalidation())
     return;
 
-  PrePaintTreeWalkContext context(parentContext);
+  PrePaintTreeWalkContext context(parentContext, needsTreeBuilderContextUpdate);
 
   // This must happen before updatePropertiesForSelf, because the latter reads
   // some of the state computed here.
   updateAuxiliaryObjectProperties(object, context);
 
-  m_propertyTreeBuilder.updatePropertiesForSelf(object,
-                                                *context.treeBuilderContext);
+  if (context.treeBuilderContext) {
+    DCHECK(context.treeBuilderContext);
+    m_propertyTreeBuilder.updatePropertiesForSelf(object,
+                                                  *context.treeBuilderContext);
+  }
+
   m_paintInvalidator.invalidatePaintIfNeeded(object,
                                              context.paintInvalidatorContext);
-  m_propertyTreeBuilder.updatePropertiesForChildren(
-      object, *context.treeBuilderContext);
 
-  invalidatePaintLayerOptimizationsIfNeeded(object, context);
+  if (context.treeBuilderContext) {
+    m_propertyTreeBuilder.updatePropertiesForChildren(
+        object, *context.treeBuilderContext);
+    invalidatePaintLayerOptimizationsIfNeeded(object, context);
+  }
 
   for (const LayoutObject* child = object.slowFirstChild(); child;
        child = child->nextSibling()) {
     if (child->isLayoutMultiColumnSpannerPlaceholder()) {
       child->getMutableForPainting().clearPaintFlags();
       continue;
     }
     walk(*child, context);
   }
 
   if (object.isLayoutPart()) {
     const LayoutPart& layoutPart = toLayoutPart(object);
     FrameViewBase* frameViewBase = layoutPart.frameViewBase();
     if (frameViewBase && frameViewBase->isFrameView()) {
-      context.treeBuilderContext->current.paintOffset +=
-          layoutPart.replacedContentRect().location() -
-          frameViewBase->frameRect().location();
-      context.treeBuilderContext->current.paintOffset =
-          roundedIntPoint(context.treeBuilderContext->current.paintOffset);
+      if (context.treeBuilderContext) {
+        context.treeBuilderContext->current.paintOffset +=
+            layoutPart.replacedContentRect().location() -
+            frameViewBase->frameRect().location();
+        context.treeBuilderContext->current.paintOffset =
+            roundedIntPoint(context.treeBuilderContext->current.paintOffset);
+      }
       walk(*toFrameView(frameViewBase), context);
     }
     // TODO(pdr): Investigate RemoteFrameView (crbug.com/579281).
   }
 
   object.getMutableForPainting().clearPaintFlags();
 }
 
 }  // namespace blink