Optimize scroll adjustment for paint invalidation

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

 // 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.
 
 #include "core/paint/PaintInvalidator.h"
 
 #include "core/editing/FrameSelection.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
@@ skipping 119 matching lines @@
           context.treeBuilderContext.current.clip, nullptr);
 
       FloatRect floatRect(rect);
       geometryMapper.sourceToDestinationVisualRect(
           currentTreeState, *containerContentsProperties, floatRect);
       result = LayoutRect(floatRect);
     }
 
     // Convert the result to the container's contents space.
     result.moveBy(-context.paintInvalidationContainer->paintOffset());
+    result.move(context.scrollAdjustment);
   }
 
   object.adjustVisualRectForRasterEffects(result);
 
   PaintLayer::mapRectInPaintInvalidationContainerToBacking(
       *context.paintInvalidationContainer, result);
 
-  result.move(object.scrollAdjustmentForPaintInvalidation(
-      *context.paintInvalidationContainer));
-
   return result;
 }
 
 void PaintInvalidatorContext::mapLocalRectToVisualRectInBacking(
     const LayoutObject& object,
     LayoutRect& rect) const {
   std::unique_ptr<GeometryMapper> geometryMapper = GeometryMapper::create();
   rect = blink::mapLocalRectToVisualRectInBacking<LayoutRect, LayoutPoint>(
       object, rect, *this, *geometryMapper);
 }
@@ skipping 28 matching lines @@
     if (context.treeBuilderContext.current.transform != containerTransform) {
       FloatRect rect = FloatRect(FloatPoint(point), FloatSize());
       m_geometryMapper.sourceToDestinationRect(
           context.treeBuilderContext.current.transform, containerTransform,
           rect);
       point = LayoutPoint(rect.location());
     }
 
     // Convert the result to the container's contents space.
     point.moveBy(-context.paintInvalidationContainer->paintOffset());
+    point.move(context.scrollAdjustment);
   }
 
   if (context.paintInvalidationContainer->layer()->groupedMapping()) {
     FloatPoint floatPoint(point);
     PaintLayer::mapPointInPaintInvalidationContainerToBacking(
         *context.paintInvalidationContainer, floatPoint);
     point = LayoutPoint(floatPoint);
   }
 
-  point.move(object.scrollAdjustmentForPaintInvalidation(
-      *context.paintInvalidationContainer));
-
   return point;
 }
 
 void PaintInvalidator::updatePaintingLayer(const LayoutObject& object,
                                            PaintInvalidatorContext& context) {
   if (object.hasLayer() &&
       toLayoutBoxModelObject(object).hasSelfPaintingLayer()) {
     context.paintingLayer = toLayoutBoxModelObject(object).layer();
   } else if (object.isColumnSpanAll() ||
              object.isFloatingWithNonContainingBlockParent()) {
@@ skipping 63 matching lines @@
  private:
   PaintPropertyTreeBuilderContext& m_treeBuilderContext;
   PaintPropertyTreeBuilderContext::ContainingBlockContext m_savedContext;
 };
 
 }  // namespace
 
 void PaintInvalidator::updatePaintInvalidationContainer(
     const LayoutObject& object,
     PaintInvalidatorContext& context) {
+  const auto* oldPaintInvalidationContainer =
+      context.paintInvalidationContainer;
   if (object.isPaintInvalidationContainer()) {
     context.paintInvalidationContainer = toLayoutBoxModelObject(&object);
     if (object.styleRef().isStackingContext())
       context.paintInvalidationContainerForStackedContents =
           toLayoutBoxModelObject(&object);
   } else if (object.isLayoutView()) {
     // paintInvalidationContainerForStackedContents is only for stacked
     // descendants in its own frame, because it doesn't establish stacking
     // context for stacked contents in sub-frames.
     // Contents stacked in the root stacking context in this frame should use
@@ skipping 33 matching lines @@
       // However, we need to keep the
       // ForcedSubtreeFullInvalidationForStackedContents flag if the current
       // object isn't the paint invalidation container of stacked contents.
       context.forcedSubtreeInvalidationFlags &= PaintInvalidatorContext::
           ForcedSubtreeFullInvalidationForStackedContents;
     } else {
       context.forcedSubtreeInvalidationFlags = 0;
     }
   }
 
+  if (context.paintInvalidationContainer != oldPaintInvalidationContainer) {
+    context.scrollAdjustment = context.paintInvalidationContainer
+                                   ->scrollAdjustmentForPaintInvalidation();
+  } else {
+    DCHECK(context.scrollAdjustment ==
+           context.paintInvalidationContainer
+               ->scrollAdjustmentForPaintInvalidation());
+  }
+
   DCHECK(context.paintInvalidationContainer ==
          object.containerForPaintInvalidation());
   DCHECK(context.paintingLayer == object.paintingLayer());
 }
 
 void PaintInvalidator::updateVisualRect(const LayoutObject& object,
                                         PaintInvalidatorContext& context) {
   Optional<ScopedUndoFrameViewContentClipAndScroll>
       undoFrameViewContentClipAndScroll;
 
@@ skipping 36 matching lines @@
 
 void PaintInvalidator::invalidatePaintIfNeeded(
     FrameView& frameView,
     PaintInvalidatorContext& context) {
   LayoutView* layoutView = frameView.layoutView();
   CHECK(layoutView);
 
   context.paintInvalidationContainer =
       context.paintInvalidationContainerForStackedContents =
           &layoutView->containerForPaintInvalidation();
+  context.scrollAdjustment = context.paintInvalidationContainer
+                                 ->scrollAdjustmentForPaintInvalidation();
   context.paintingLayer = layoutView->layer();
 
   if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
     ScopedUndoFrameViewContentClipAndScroll undo(frameView, context);
     frameView.invalidatePaintOfScrollControlsIfNeeded(context);
   }
 }
 
 void PaintInvalidator::invalidatePaintIfNeeded(
     const LayoutObject& object,
@@ skipping 79 matching lines @@
   }
 }
 
 void PaintInvalidator::processPendingDelayedPaintInvalidations() {
   for (auto target : m_pendingDelayedPaintInvalidations)
     target->getMutableForPainting().setShouldDoFullPaintInvalidation(
         PaintInvalidationDelayedFull);
 }
 
 }  // namespace blink