Early-out from the prepaint tree walk

third_party/WebKit/Source/core/paint/FindPropertiesNeedingUpdate.h

 // 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.
 
 #ifndef FindPropertiesNeedingUpdate_h
 #define FindPropertiesNeedingUpdate_h
 
 #if DCHECK_IS_ON()
 namespace blink {
 
 #define DCHECK_PTR_VAL_EQ(ptrA, ptrB) \
   DCHECK((!!ptrA == !!ptrB) && ((!ptrA && !ptrB) || (*ptrA == *ptrB)));
 
 // This file contains two scope classes for catching cases where paint
 // properties need an update but where not marked as such. If paint properties
 // will change, the object must be marked as needing a paint property update
 // using {FrameView, LayoutObject}::setNeedsPaintPropertyUpdate().
 //
 // Both scope classes work by recording the paint property state of an object
 // before rebuilding properties, forcing the properties to get updated, then
 // checking that the updated properties match the original properties.
 
 class FindFrameViewPropertiesNeedingUpdateScope {
  public:
-  FindFrameViewPropertiesNeedingUpdateScope(FrameView* frameView)
+  FindFrameViewPropertiesNeedingUpdateScope(
+      FrameView* frameView,
+      PaintPropertyTreeBuilderContext& context)
       : m_frameView(frameView),
-        m_neededPaintPropertyUpdate(frameView->needsPaintPropertyUpdate()) {
+        m_neededPaintPropertyUpdate(frameView->needsPaintPropertyUpdate()),
+        m_context(context),
+        m_hadForceSubtreeUpdate(context.forceSubtreeUpdate) {

[chrishtr, 2016/12/01 02:36:35]

Can you also use this field to check that forceSubtree was set to true due to
properties being set?

[pdr., 2016/12/01 09:35:35]

This class catches underinvalidation by checking that both property pointers and
property values do not change for objects not needing an update. If forceSubtree
were set to true while this checker is in scope, it would mean that property
pointers changed which this class should already check for.

     // No need to check when already marked as needing an update.
     if (m_neededPaintPropertyUpdate)
       return;
 
     // Mark the properties as needing an update to ensure they are rebuilt.
     m_frameView->setNeedsPaintPropertyUpdate();
     if (auto* preTranslation = m_frameView->preTranslation())
       m_preTranslation = preTranslation->clone();
     if (auto* contentClip = m_frameView->contentClip())
       m_contentClip = contentClip->clone();
     if (auto* scrollTranslation = m_frameView->scrollTranslation())
       m_scrollTranslation = scrollTranslation->clone();
     if (auto* scroll = m_frameView->scroll())
       m_scroll = scroll->clone();
   }
 
   ~FindFrameViewPropertiesNeedingUpdateScope() {
     // No need to check when already marked as needing an update.
     if (m_neededPaintPropertyUpdate)
       return;
 
     // If paint properties are not marked as needing an update but still change,
     // we are missing a call to FrameView::setNeedsPaintPropertyUpdate().
     DCHECK_PTR_VAL_EQ(m_preTranslation, m_frameView->preTranslation());
     DCHECK_PTR_VAL_EQ(m_contentClip, m_frameView->contentClip());
     DCHECK_PTR_VAL_EQ(m_scrollTranslation, m_frameView->scrollTranslation());
     DCHECK_PTR_VAL_EQ(m_scroll, m_frameView->scroll());
-    // Restore original clean bit.
+    // Restore original clean bits.
     m_frameView->clearNeedsPaintPropertyUpdate();
+    m_context.forceSubtreeUpdate = m_hadForceSubtreeUpdate;
   }
 
  private:
   Persistent<FrameView> m_frameView;
   bool m_neededPaintPropertyUpdate;
+  PaintPropertyTreeBuilderContext& m_context;
+  bool m_hadForceSubtreeUpdate;
   RefPtr<TransformPaintPropertyNode> m_preTranslation;
   RefPtr<ClipPaintPropertyNode> m_contentClip;
   RefPtr<TransformPaintPropertyNode> m_scrollTranslation;
   RefPtr<ScrollPaintPropertyNode> m_scroll;
 };
 
 class FindObjectPropertiesNeedingUpdateScope {
  public:
-  FindObjectPropertiesNeedingUpdateScope(const LayoutObject& object)
+  FindObjectPropertiesNeedingUpdateScope(
+      const LayoutObject& object,
+      PaintPropertyTreeBuilderContext& context)
       : m_object(object),
-        m_neededPaintPropertyUpdate(object.needsPaintPropertyUpdate()) {
+        m_neededPaintPropertyUpdate(object.needsPaintPropertyUpdate()),
+        m_context(context),
+        m_hadForceSubtreeUpdate(context.forceSubtreeUpdate) {
     // No need to check when already marked as needing an update.
     if (m_neededPaintPropertyUpdate)
       return;
 
     // Mark the properties as needing an update to ensure they are rebuilt.
     const_cast<LayoutObject&>(m_object).setNeedsPaintPropertyUpdate();
     if (const auto* properties = m_object.paintProperties())
       m_properties = properties->clone();
   }
 
@@ skipping 38 matching lines @@
         DCHECK_EQ(borderBox->propertyTreeState.effect(),
                   objectBorderBox->propertyTreeState.effect());
         DCHECK_EQ(borderBox->propertyTreeState.scroll(),
                   objectBorderBox->propertyTreeState.scroll());
       } else {
         DCHECK_EQ(!!borderBox, !!objectBorderBox);
       }
     } else {
       DCHECK_EQ(!!m_properties, !!objectProperties);
     }
-    // Restore original clean bit.
+    // Restore original clean bits.
     const_cast<LayoutObject&>(m_object).clearNeedsPaintPropertyUpdate();
+    m_context.forceSubtreeUpdate = m_hadForceSubtreeUpdate;
   }
 
  private:
   const LayoutObject& m_object;
   bool m_neededPaintPropertyUpdate;
+  PaintPropertyTreeBuilderContext& m_context;
+  bool m_hadForceSubtreeUpdate;
   std::unique_ptr<const ObjectPaintProperties> m_properties;
 };
 
 }  // namespace blink
 #endif  // DCHECK_IS_ON()
 
 #endif  // FindPropertiesNeedingUpdate_h