Optimize scroll adjustment for paint invalidation

third_party/WebKit/Source/core/layout/PaintInvalidationState.cpp

 // Copyright 2014 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/layout/PaintInvalidationState.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
@@ skipping 25 matching lines @@
 PaintInvalidationState::PaintInvalidationState(
     const LayoutView& layoutView,
     Vector<const LayoutObject*>& pendingDelayedPaintInvalidations)
     : m_currentObject(layoutView),
       m_forcedSubtreeInvalidationFlags(0),
       m_clipped(false),
       m_clippedForAbsolutePosition(false),
       m_cachedOffsetsEnabled(true),
       m_cachedOffsetsForAbsolutePositionEnabled(true),
       m_paintInvalidationContainer(&layoutView.containerForPaintInvalidation()),
+      m_scrollAdjustment(
+          m_paintInvalidationContainer->scrollAdjustmentForPaintInvalidation()),
       m_paintInvalidationContainerForStackedContents(
           m_paintInvalidationContainer),
       m_containerForAbsolutePosition(layoutView),
       m_pendingDelayedPaintInvalidations(pendingDelayedPaintInvalidations),
       m_paintingLayer(*layoutView.layer())
 #ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
       ,
       m_canCheckFastPathSlowPathEquality(layoutView ==
                                          m_paintInvalidationContainer)
 #endif
@@ skipping 22 matching lines @@
       m_clippedForAbsolutePosition(parentState.m_clippedForAbsolutePosition),
       m_clipRect(parentState.m_clipRect),
       m_clipRectForAbsolutePosition(parentState.m_clipRectForAbsolutePosition),
       m_paintOffset(parentState.m_paintOffset),
       m_paintOffsetForAbsolutePosition(
           parentState.m_paintOffsetForAbsolutePosition),
       m_cachedOffsetsEnabled(parentState.m_cachedOffsetsEnabled),
       m_cachedOffsetsForAbsolutePositionEnabled(
           parentState.m_cachedOffsetsForAbsolutePositionEnabled),
       m_paintInvalidationContainer(parentState.m_paintInvalidationContainer),
+      m_scrollAdjustment(parentState.m_scrollAdjustment),
       m_paintInvalidationContainerForStackedContents(
           parentState.m_paintInvalidationContainerForStackedContents),
       m_containerForAbsolutePosition(
           currentObject.canContainAbsolutePositionObjects()
               ? currentObject
               : parentState.m_containerForAbsolutePosition),
       m_svgTransform(parentState.m_svgTransform),
       m_pendingDelayedPaintInvalidations(
           parentState.m_pendingDelayedPaintInvalidations),
       m_paintingLayer(parentState.childPaintingLayer(currentObject))
@@ skipping 15 matching lines @@
 #if DCHECK_IS_ON()
     m_didUpdateForChildren = parentState.m_didUpdateForChildren;
 #endif
     return;
   }
 
 #if DCHECK_IS_ON()
   DCHECK(parentState.m_didUpdateForChildren);
 #endif
 
+  const auto* oldPaintInvalidationContainer = m_paintInvalidationContainer;
   if (currentObject.isPaintInvalidationContainer()) {
     m_paintInvalidationContainer = toLayoutBoxModelObject(&currentObject);
     if (currentObject.styleRef().isStackingContext())
       m_paintInvalidationContainerForStackedContents =
           toLayoutBoxModelObject(&currentObject);
   } else if (currentObject.isLayoutView()) {
     // m_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 this frame's
@@ skipping 27 matching lines @@
     //   path and enable fast path for descendants if possible; or
     // - Track offset between the two paintInvalidationContainers.
     m_cachedOffsetsEnabled = false;
     if (m_forcedSubtreeInvalidationFlags &
         PaintInvalidatorContext::
             ForcedSubtreeFullInvalidationForStackedContents)
       m_forcedSubtreeInvalidationFlags |=
           PaintInvalidatorContext::ForcedSubtreeFullInvalidation;
   }
 
+  if (m_paintInvalidationContainer != oldPaintInvalidationContainer) {
+    m_scrollAdjustment =
+        m_paintInvalidationContainer->scrollAdjustmentForPaintInvalidation();
+  } else {
+    DCHECK(
+        m_scrollAdjustment ==
+        m_paintInvalidationContainer->scrollAdjustmentForPaintInvalidation());
+  }
+
   if (!currentObject.isBoxModelObject() && !currentObject.isSVG())
     return;
 
   if (m_cachedOffsetsEnabled || currentObject == m_paintInvalidationContainer)
     m_cachedOffsetsEnabled = supportsCachedOffsets(currentObject);
 
   if (currentObject.isSVG()) {
     if (currentObject.isSVGRoot()) {
       m_svgTransform =
           toLayoutSVGRoot(currentObject).localToBorderBoxTransform();
@@ skipping 255 matching lines @@
       point += FloatPoint(m_paintOffset);
 #ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
       DCHECK(point ==
              slowLocalOriginToAncestorPoint(
                  m_currentObject, m_paintInvalidationContainer, FloatPoint()));
 #endif
     } else {
       point = slowLocalToAncestorPoint(
           m_currentObject, *m_paintInvalidationContainer, FloatPoint());
     }
+
+    point.move(m_scrollAdjustment);
   }
 
   PaintLayer::mapPointInPaintInvalidationContainerToBacking(
       *m_paintInvalidationContainer, point);
 
-  point.move(m_currentObject.scrollAdjustmentForPaintInvalidation(
-      *m_paintInvalidationContainer));
-
   return LayoutPoint(point);
 }
 
 LayoutRect PaintInvalidationState::computeVisualRectInBacking() const {
 #if DCHECK_IS_ON()
   DCHECK(!m_didUpdateForChildren);
 #endif
 
   if (m_currentObject.isSVGChild())
     return computeVisualRectInBackingForSVG();
@@ skipping 23 matching lines @@
     // and slow path (for things above the SVGRoot).
     rect = SVGLayoutSupport::visualRectInAncestorSpace(
         m_currentObject, *m_paintInvalidationContainer);
   }
 
   PaintLayer::mapRectInPaintInvalidationContainerToBacking(
       *m_paintInvalidationContainer, rect);
 
   m_currentObject.adjustVisualRectForRasterEffects(rect);
 
-  rect.move(m_currentObject.scrollAdjustmentForPaintInvalidation(
-      *m_paintInvalidationContainer));
+  if (m_currentObject != m_paintInvalidationContainer)
+    rect.move(m_scrollAdjustment);
 
   return rect;
 }
 
 static void slowMapToVisualRectInAncestorSpace(
     const LayoutObject& object,
     const LayoutBoxModelObject& ancestor,
     LayoutRect& rect) {
   // TODO(wkorman): The flip below is required because visual rects are
   // currently in "physical coordinates with flipped block-flow direction"
@@ skipping 36 matching lines @@
 
 void PaintInvalidationState::mapLocalRectToVisualRectInBacking(
     LayoutRect& rect) const {
   mapLocalRectToPaintInvalidationContainer(rect);
 
   PaintLayer::mapRectInPaintInvalidationContainerToBacking(
       *m_paintInvalidationContainer, rect);
 
   m_currentObject.adjustVisualRectForRasterEffects(rect);
 
-  rect.move(m_currentObject.scrollAdjustmentForPaintInvalidation(
-      *m_paintInvalidationContainer));
+  if (m_currentObject != m_paintInvalidationContainer)
+    rect.move(m_scrollAdjustment);
 }
 
 void PaintInvalidationState::addClipRectRelativeToPaintOffset(
     const LayoutRect& localClipRect) {
   LayoutRect clipRect = localClipRect;
   clipRect.move(m_paintOffset);
   if (m_clipped) {
     m_clipRect.intersect(clipRect);
   } else {
     m_clipRect = clipRect;
@@ skipping 80 matching lines @@
 }
 
 void PaintInvalidatorContextAdapter::mapLocalRectToVisualRectInBacking(
     const LayoutObject& object,
     LayoutRect& rect) const {
   DCHECK(&object == &m_paintInvalidationState.currentObject());
   m_paintInvalidationState.mapLocalRectToVisualRectInBacking(rect);
 }
 
 }  // namespace blink