Invalidate paint properties on paint offset changes

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 46 matching lines @@
 #endif
     // If descendants were not fully updated, do not clear flags. During the
     // next PrePaintTreeWalk, these flags will be used again.
     frameView.clearNeedsPaintPropertyUpdate();
   }
   return descendantsFullyUpdated;
 }
 
 bool PrePaintTreeWalk::walk(const LayoutObject& object,
                             const PrePaintTreeWalkContext& context) {
-  // Early out from the treewalk if possible.
-  if (!object.needsPaintPropertyUpdate() &&
-      !object.descendantNeedsPaintPropertyUpdate() &&
-      !context.treeBuilderContext.forceSubtreeUpdate &&
-      !context.paintInvalidatorContext.forcedSubtreeInvalidationFlags &&
-      !object
-           .shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState()) {
-    // Even though the subtree was not walked, we know that a walk will not
-    // change anything and can return true as if the subtree was fully updated.
-    return true;
-  }
-
   PrePaintTreeWalkContext localContext(context);
 
-  // TODO(pdr): These should be removable once paint offset changes mark an
-  // object as needing a paint property update. Below, we temporarily re-use
-  // paint invalidation flags to detect paint offset changes.
-  if (localContext.paintInvalidatorContext.forcedSubtreeInvalidationFlags) {
-    // forcedSubtreeInvalidationFlags will be true if locations have changed
-    // which will affect paint properties (e.g., PaintOffset).
-    localContext.treeBuilderContext.forceSubtreeUpdate = true;
-  } else if (object.shouldDoFullPaintInvalidation()) {
-    // shouldDoFullPaintInvalidation will be true when locations or overflow
-    // changes which will affect paint properties (e.g., PaintOffset, scroll).
-    object.getMutableForPainting().setNeedsPaintPropertyUpdate();
-  } else if (object.mayNeedPaintInvalidation()) {
-    // mayNeedpaintInvalidation will be true when locations change which will
-    // affect paint properties (e.g., PaintOffset).
-    object.getMutableForPainting().setNeedsPaintPropertyUpdate();
-  }
-
   // TODO(pdr): Ensure multi column works with incremental property tree
   // construction.
   if (object.isLayoutMultiColumnSpannerPlaceholder()) {
     // Walk multi-column spanner as if it replaces the placeholder.
     // Set the flag so that the tree builder can specially handle out-of-flow
     // positioned descendants if their containers are between the multi-column
     // container and the spanner. See PaintPropertyTreeBuilder for details.
     localContext.treeBuilderContext.isUnderMultiColumnSpanner = true;
+    const auto& placeholder = toLayoutMultiColumnSpannerPlaceholder(object);
     bool descendantsFullyUpdated =
-        walk(*toLayoutMultiColumnSpannerPlaceholder(object)
-                  .layoutObjectInFlowThread(),
-             localContext);
+        walk(*placeholder.layoutObjectInFlowThread(), localContext);
     if (descendantsFullyUpdated) {
       // If descendants were not fully updated, do not clear flags. During the
       // next PrePaintTreeWalk, these flags will be used again.
       object.getMutableForPainting().clearPaintInvalidationFlags();
       object.getMutableForPainting().clearNeedsPaintPropertyUpdate();
       object.getMutableForPainting().clearDescendantNeedsPaintPropertyUpdate();
     }
     return descendantsFullyUpdated;
   }
 
+  // Ensure the current context takes into account the box position. This can
+  // change the current context's paint offset so it must proceed the paint
+  // offset property update check.
+  m_propertyTreeBuilder.updateContextForBoxPosition(
+      object, localContext.treeBuilderContext);
+  // Many paint properties depend on paint offset so we force an update of
+  // properties if the paint offset changes.
+  if (object.previousPaintOffset() !=
+      localContext.treeBuilderContext.current.paintOffset) {
+    object.getMutableForPainting().setNeedsPaintPropertyUpdate();
+  }
+
+  // Early out from the treewalk if possible.
+  if (!object.needsPaintPropertyUpdate() &&
+      !object.descendantNeedsPaintPropertyUpdate() &&
+      !localContext.treeBuilderContext.forceSubtreeUpdate &&
+      !localContext.paintInvalidatorContext.forcedSubtreeInvalidationFlags &&
+      !object
+           .shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState()) {
+    // Even though the subtree was not walked, we know that a walk will not
+    // change anything and can return true as if the subtree was fully updated.
+    return true;
+  }
+
   m_propertyTreeBuilder.updatePropertiesForSelf(
       object, localContext.treeBuilderContext);
   m_paintInvalidator.invalidatePaintIfNeeded(
       object, localContext.paintInvalidatorContext);
   m_propertyTreeBuilder.updatePropertiesForChildren(
       object, localContext.treeBuilderContext);
 
   bool descendantsFullyUpdated = true;
   for (const LayoutObject* child = object.slowFirstChild(); child;
        child = child->nextSibling()) {
@@ skipping 25 matching lines @@
     // If descendants were not updated, do not clear flags. During the next
     // PrePaintTreeWalk, these flags will be used again.
     object.getMutableForPainting().clearPaintInvalidationFlags();
     object.getMutableForPainting().clearNeedsPaintPropertyUpdate();
     object.getMutableForPainting().clearDescendantNeedsPaintPropertyUpdate();
   }
   return descendantsFullyUpdated;
 }
 
 }  // namespace blink