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"
@@ skipping 31 matching lines @@
          DocumentLifecycle::InPrePaint);
 
   PrePaintTreeWalkContext initialContext;
   initialContext.treeBuilderContext =
       m_propertyTreeBuilder.setupInitialContext();
   initialContext.ancestorTransformedOrRootPaintLayer =
       rootFrame.layoutView()->layer();
 
   // GeometryMapper depends on paint properties.
   if (rootFrame.needsPaintPropertyUpdate() ||
-      (rootFrame.layoutView() &&
-       !shouldEndWalkBefore(*rootFrame.layoutView(), initialContext)))
+      (rootFrame.layoutView() && needsWalkForPaintPropertyUpdate(
+                                     *rootFrame.layoutView(), 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);
   // ancestorOverflowLayer does not cross frame boundaries.
   context.ancestorOverflowPaintLayer = nullptr;
   m_propertyTreeBuilder.updateProperties(frameView, context.treeBuilderContext);
   m_paintInvalidator.invalidatePaintIfNeeded(frameView,
                                              context.paintInvalidatorContext);
 
   if (LayoutView* view = frameView.layoutView()) {
+#if DCHECK_IS_ON()
+    context.treeBuilderContext.updatedForSelf = true;
+    context.treeBuilderContext.updatedForChildren = true;
+#endif
     walk(*view, context);
 #if DCHECK_IS_ON()
     view->assertSubtreeClearedPaintInvalidationFlags();
 #endif
   }
   frameView.clearNeedsPaintPropertyUpdate();
 }
 
 static void updateAuxiliaryObjectProperties(const LayoutObject& object,
                                             PrePaintTreeWalkContext& context) {
@@ skipping 51 matching lines @@
   rect.moveBy(-FloatPoint(ancestorPaintOffset));
   return rect;
 }
 
 void PrePaintTreeWalk::invalidatePaintLayerOptimizationsIfNeeded(
     const LayoutObject& object,
     PrePaintTreeWalkContext& context) {
   if (!object.hasLayer())
     return;
 
+#if DCHECK_IS_ON()
+  DCHECK(context.treeBuilderContext.updatedForChildren);
+#endif
+
   PaintLayer& paintLayer = *toLayoutBoxModelObject(object).layer();
   if (object.styleRef().hasTransform() ||
       &object == context.paintInvalidatorContext.paintInvalidationContainer) {
     context.ancestorTransformedOrRootPaintLayer = &paintLayer;
   }
 
   const ObjectPaintProperties& ancestorPaintProperties =
       *context.ancestorTransformedOrRootPaintLayer->layoutObject()
            .paintProperties();
   PropertyTreeState ancestorState =
@@ skipping 52 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::needsWalkForPaintPropertyUpdate(
     const LayoutObject& object,
     const PrePaintTreeWalkContext& context) {
-  return (
-      !object.needsPaintPropertyUpdate() &&
-      !object.descendantNeedsPaintPropertyUpdate() &&
-      !context.treeBuilderContext.forceSubtreeUpdate &&
-      !context.paintInvalidatorContext.forcedSubtreeInvalidationFlags &&
-      !object
-           .shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState());
+  return object.needsPaintPropertyUpdate() ||
+         object.descendantNeedsPaintPropertyUpdate() ||
+         context.treeBuilderContext.forceSubtreeUpdate ||
+         // If the object needs visual rect update, we should update paint
+         // properties which are needed by visual rect update.
+         m_paintInvalidator.needsVisualRectUpdate(
+             object, context.paintInvalidatorContext);
 }
 
 void PrePaintTreeWalk::walk(const LayoutObject& object,
                             const PrePaintTreeWalkContext& parentContext) {
-  if (shouldEndWalkBefore(object, parentContext))
+  // Early out from the treewalk if possible.
+  bool needsWalkForPaintPropertyUpdate =
+      this->needsWalkForPaintPropertyUpdate(object, parentContext);
+  if (!needsWalkForPaintPropertyUpdate &&
+      !object
+           .shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState())
     return;
 
   // PrePaintTreeWalkContext 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<PrePaintTreeWalkContext> context =
       WTF::wrapUnique(new PrePaintTreeWalkContext(parentContext));
 
   // 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 (needsWalkForPaintPropertyUpdate) {

[pdr., 2017/03/10 06:21:39]

Trying to think of ways to simplify these DCHECKS... What if we split out the
heap-allocated prepaint context into two heap-allocated objects (paint inval
context and paint prop context). If there is no paint property update, just
don't allocate the paint prop context at all. A null ptr makes the invalid
property tree context even more obvious, and this approach might save on
allocations too since the unneeded property tree context stops being allocated
at all.

[Xianzhu, 2017/03/10 17:43:05]

This looks a good idea. Will try.

[Xianzhu, 2017/03/13 19:08:09]

I tried the method, but found that we still need the flags for checking
under-invalidation of setNeedsPaintOffsetAndVisualRectUpdate().

It works as follows when DCHECK_IS_ON():

- Even if !needsWalkForPaintPropertyUpdate(), we still create
treeBuilderContext, and update paint offset, paint properties and visual rect,
for checking.

- However, the forced updates don't affect the 'updated' flags so that we can
still check for prerequisites.

Without the 'updated' flags, we either can't check for changes, or can't check
for prerequisites.

+#if DCHECK_IS_ON()
+    DCHECK(context->treeBuilderContext.parentUpdated);
+#endif
+    m_propertyTreeBuilder.updatePropertiesForSelf(object,
+                                                  context->treeBuilderContext);
+#if DCHECK_IS_ON()
+    context->treeBuilderContext.updatedForSelf = true;
+#endif
+  } else {
+#if DCHECK_IS_ON()
+    // When DCHECK_IS_ON, always update paint properties so that paint
+    // invalidator can update visual rect for checking missing flags.
+    LayoutPoint oldPaintOffset = object.paintOffset();
+    m_propertyTreeBuilder.updatePropertiesForSelf(object,
+                                                  context->treeBuilderContext);
+    DCHECK(object.paintOffset() == oldPaintOffset)
+        << "Paint offset changed without needsPaintOffsetAndVisualRectUpdate"
+        << " old=" << oldPaintOffset.toString()
+        << " new=" << object.paintOffset().toString();
+#endif
+  }
+
   m_paintInvalidator.invalidatePaintIfNeeded(object,
                                              context->paintInvalidatorContext);
-  m_propertyTreeBuilder.updatePropertiesForChildren(
-      object, context->treeBuilderContext);
 
-  invalidatePaintLayerOptimizationsIfNeeded(object, *context);
+  if (needsWalkForPaintPropertyUpdate) {
+    m_propertyTreeBuilder.updatePropertiesForChildren(
+        object, context->treeBuilderContext);
+#if DCHECK_IS_ON()
+    context->treeBuilderContext.updatedForChildren = true;
+#endif
+    invalidatePaintLayerOptimizationsIfNeeded(object, *context);
+  } else {
+#if DCHECK_IS_ON()
+    // When DCHECK_IS_ON, always update paint properties so that paint
+    // invalidator can update visual rect for checking missing flags.
+    m_propertyTreeBuilder.updatePropertiesForChildren(
+        object, context->treeBuilderContext);
+#endif
+  }
 
   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);
       walk(*toFrameView(frameViewBase), *context);
     }
     // TODO(pdr): Investigate RemoteFrameView (crbug.com/579281).
   }
 
   object.getMutableForPainting().clearPaintFlags();
 }
 
 }  // namespace blink