Remove force-update when visual rects 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()
       : paintInvalidatorContext(treeBuilderContext),
-        ancestorOverflowPaintLayer(nullptr) {}
+        ancestorOverflowPaintLayer(nullptr),
+        ancestorTransformedOrRootPaintLayer(nullptr) {}
   PrePaintTreeWalkContext(const PrePaintTreeWalkContext& parentContext)
       : treeBuilderContext(parentContext.treeBuilderContext),
         paintInvalidatorContext(treeBuilderContext,
                                 parentContext.paintInvalidatorContext),
         ancestorOverflowPaintLayer(parentContext.ancestorOverflowPaintLayer),
         ancestorTransformedOrRootPaintLayer(
             parentContext.ancestorTransformedOrRootPaintLayer) {}
 
   PaintPropertyTreeBuilderContext treeBuilderContext;
   PaintInvalidatorContext paintInvalidatorContext;
@@ skipping 92 matching lines @@
 
   FloatClipRect rect(
       m_geometryMapper.sourceToDestinationClipRect(localState, ancestorState));
 
   rect.moveBy(-FloatPoint(ancestorPaintOffset));
   return rect;
 }
 
 void PrePaintTreeWalk::invalidatePaintLayerOptimizationsIfNeeded(
     const LayoutObject& object,
-    const PaintLayer& ancestorTransformedOrRootPaintLayer,
-    PaintPropertyTreeBuilderContext& context) {
+    PrePaintTreeWalkContext& context) {
   if (!object.hasLayer())
     return;
 
   PaintLayer& paintLayer = *toLayoutBoxModelObject(object).layer();
+  if (object.styleRef().hasTransform() ||
+      &object == context.paintInvalidatorContext.paintInvalidationContainer) {
+    context.ancestorTransformedOrRootPaintLayer = &paintLayer;
+  }
+
   const ObjectPaintProperties& ancestorPaintProperties =
-      *ancestorTransformedOrRootPaintLayer.layoutObject().paintProperties();
+      *context.ancestorTransformedOrRootPaintLayer->layoutObject()
+           .paintProperties();
   PropertyTreeState ancestorState =
       *ancestorPaintProperties.localBorderBoxProperties();
+  const EffectPaintPropertyNode* effect =
+      context.treeBuilderContext.currentEffect;
 
 #ifdef CHECK_CLIP_RECTS
   ShouldRespectOverflowClipType respectOverflowClip = RespectOverflowClip;
 #endif
-  if (ancestorTransformedOrRootPaintLayer.compositingState() ==
+  if (context.ancestorTransformedOrRootPaintLayer->compositingState() ==
           PaintsIntoOwnBacking &&
       ancestorPaintProperties.overflowClip()) {
     ancestorState.setClip(ancestorPaintProperties.overflowClip());
 #ifdef CHECK_CLIP_RECTS
     respectOverflowClip = IgnoreOverflowClip;
 #endif
   }
 
 #ifdef CHECK_CLIP_RECTS
-  ClipRects& oldClipRects = paintLayer.clipper().paintingClipRects(
-      &ancestorTransformedOrRootPaintLayer, respectOverflowClip, LayoutSize());
+  ClipRects& oldClipRects =
+      paintLayer.clipper(PaintLayer::DoNotUseGeometryMapper)
+          .paintingClipRects(&ancestorTransformedOrRootPaintLayer,
+                             respectOverflowClip, LayoutSize());
 #endif
 
   bool hasClip = false;
   RefPtr<ClipRects> clipRects = ClipRects::create();
   const LayoutPoint& ancestorPaintOffset =
-      ancestorTransformedOrRootPaintLayer.layoutObject().paintOffset();
+      context.ancestorTransformedOrRootPaintLayer->layoutObject().paintOffset();
   clipRects->setOverflowClipRect(
-      clipRectForContext(context.current, context.currentEffect, ancestorState,
-                         ancestorPaintOffset, hasClip));
+      clipRectForContext(context.treeBuilderContext.current, effect,
+                         ancestorState, ancestorPaintOffset, hasClip));
 #ifdef CHECK_CLIP_RECTS
   CHECK(!hasClip ||
         clipRects->overflowClipRect() == oldClipRects.overflowClipRect())
       << "rect= " << clipRects->overflowClipRect().toString();
 #endif
 
   clipRects->setFixedClipRect(
-      clipRectForContext(context.fixedPosition, context.currentEffect,
+      clipRectForContext(context.treeBuilderContext.fixedPosition, effect,
                          ancestorState, ancestorPaintOffset, hasClip));
 #ifdef CHECK_CLIP_RECTS
   CHECK(hasClip || clipRects->fixedClipRect() == oldClipRects.fixedClipRect())
       << " fixed=" << clipRects->fixedClipRect().toString();
 #endif
 
   clipRects->setPosClipRect(
-      clipRectForContext(context.absolutePosition, context.currentEffect,
+      clipRectForContext(context.treeBuilderContext.absolutePosition, effect,
                          ancestorState, ancestorPaintOffset, hasClip));
 #ifdef CHECK_CLIP_RECTS
   CHECK(!hasClip || clipRects->posClipRect() == oldClipRects.posClipRect())
       << " abs=" << clipRects->posClipRect().toString();
 #endif
 
   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.forceSubtreeUpdate = true;
+    context.paintInvalidatorContext.forcedSubtreeInvalidationFlags |=
+        PaintInvalidatorContext::ForcedSubtreeInvalidationRectUpdate;
   }
 
   paintLayer.setPreviousPaintingClipRects(*clipRects);
 }
 
 void PrePaintTreeWalk::walk(const LayoutObject& object,
                             const PrePaintTreeWalkContext& parentContext) {
   PrePaintTreeWalkContext context(parentContext);
 
   // Early out from the treewalk if possible.
   if (!object.needsPaintPropertyUpdate() &&
       !object.descendantNeedsPaintPropertyUpdate() &&
       !context.treeBuilderContext.forceSubtreeUpdate &&
       !context.paintInvalidatorContext.forcedSubtreeInvalidationFlags &&
       !object
            .shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState())
     return;
 
   // This must happen before updatePropertiesForSelf, because the latter reads
   // some of the state computed here.
   updateAuxiliaryObjectProperties(object, context);
 
   m_propertyTreeBuilder.updatePropertiesForSelf(object,
                                                 context.treeBuilderContext);
   m_paintInvalidator.invalidatePaintIfNeeded(object,
                                              context.paintInvalidatorContext);
   m_propertyTreeBuilder.updatePropertiesForChildren(object,
                                                     context.treeBuilderContext);
 
-  if (object.isBoxModelObject() && object.hasLayer()) {
-    if (object.styleRef().hasTransform() ||
-        &object == context.paintInvalidatorContext.paintInvalidationContainer) {
-      context.ancestorTransformedOrRootPaintLayer =
-          toLayoutBoxModelObject(object).layer();
-    }
-  }
-
-  invalidatePaintLayerOptimizationsIfNeeded(
-      object, *context.ancestorTransformedOrRootPaintLayer,
-      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);
     Widget* widget = layoutPart.widget();
     if (widget && widget->isFrameView()) {
       context.treeBuilderContext.current.paintOffset +=
           layoutPart.replacedContentRect().location() -
           widget->frameRect().location();
       context.treeBuilderContext.current.paintOffset =
           roundedIntPoint(context.treeBuilderContext.current.paintOffset);
       walk(*toFrameView(widget), context);
     }
     // TODO(pdr): Investigate RemoteFrameView (crbug.com/579281).
   }
 
   object.getMutableForPainting().clearPaintFlags();
 }
 
 }  // namespace blink