Extract RenderBox::invalidatePaintIfNeeded()

Source/core/rendering/RenderBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 1544 matching lines @@
     ASSERT(!needsLayout());
 
     if (!shouldCheckForPaintInvalidation())
         return;
 
     bool establishesNewPaintInvalidationContainer = isPaintInvalidationContainer();
     const RenderLayerModelObject& newPaintInvalidationContainer = *adjustCompositedContainerForSpecialAncestors(establishesNewPaintInvalidationContainer ? this : &paintInvalidationState.paintInvalidationContainer());
     // FIXME: This assert should be re-enabled when we move paint invalidation to after compositing update. crbug.com/360286
     // ASSERT(&newPaintInvalidationContainer == containerForPaintInvalidation());
 
+    invalidatePaintIfNeeded(paintInvalidationState, newPaintInvalidationContainer);
+
+    // This is for the next invalidatePaintIfNeeded so must be after invalidatePaintIfNeeded.
+    savePreviousBorderBoxSizeIfNeeded();

[dsinclair, 2014/07/21 17:10:56]

Just to verify, this is the ordering we want? It looks like previously we did
these two operations in both orders, so I'm assuming they don't have any affect
on each other.


if (doingFullRepaint()) {
  invalidateTreeIfNeeded()
  savePreviousBorderBoxSize()
  return
}

saveBorderBoxSizeIfNeeded();
invalidateTreeIfNeeded();

[Xianzhu, 2014/07/21 17:18:54]

Yes.

saveBorderBoxSizeIfNeeded() is only required to be after invalidation of the box
itself, but doesn't matter whether it is before or after invalidation of
children.

+
+    PaintInvalidationState childTreeWalkState(paintInvalidationState, *this, newPaintInvalidationContainer);
+    RenderObject::invalidateTreeIfNeeded(childTreeWalkState);
+}
+
+void RenderBox::invalidatePaintIfNeeded(const PaintInvalidationState& paintInvalidationState, const RenderLayerModelObject& newPaintInvalidationContainer)
+{
     const LayoutRect oldPaintInvalidationRect = previousPaintInvalidationRect();
     const LayoutPoint oldPositionFromPaintInvalidationContainer = previousPositionFromPaintInvalidationContainer();
     setPreviousPaintInvalidationRect(boundsRectForPaintInvalidation(&newPaintInvalidationContainer, &paintInvalidationState));
     setPreviousPositionFromPaintInvalidationContainer(RenderLayer::positionFromPaintInvalidationContainer(this, &newPaintInvalidationContainer, &paintInvalidationState));
 
     // If we are set to do a full paint invalidation that means the RenderView will be
     // issue paint invalidations. We can then skip issuing of paint invalidations for the child
     // renderers as they'll be covered by the RenderView.
-    if (view()->doingFullRepaint()) {
-        PaintInvalidationState childTreeWalkState(paintInvalidationState, *this, newPaintInvalidationContainer);
-        RenderObject::invalidateTreeIfNeeded(childTreeWalkState);
-        // For the next invalidatePaintIfNeeded.
-        savePreviousBorderBoxSizeIfNeeded();
+    if (view()->doingFullRepaint())
         return;
-    }
 
     if ((onlyNeededPositionedMovementLayout() && compositingState() != PaintsIntoOwnBacking)
         || (shouldDoFullPaintInvalidationIfSelfPaintingLayer()
             && hasLayer()
             && layer()->isSelfPaintingLayer())) {
         setShouldDoFullPaintInvalidation(true);
     }
 
-    if (!invalidatePaintIfNeeded(newPaintInvalidationContainer, oldPaintInvalidationRect, oldPositionFromPaintInvalidationContainer, paintInvalidationState))
+    if (!RenderObject::invalidatePaintIfNeeded(newPaintInvalidationContainer, oldPaintInvalidationRect, oldPositionFromPaintInvalidationContainer, paintInvalidationState))
         invalidatePaintForOverflowIfNeeded();
 
-    // This is for the next invalidatePaintIfNeeded so must be after invalidatePaintIfNeeded.
-    savePreviousBorderBoxSizeIfNeeded();
-
     // Issue paint invalidations for any scrollbars if there is a scrollable area for this renderer.
     if (enclosingLayer()) {
         if (RenderLayerScrollableArea* area = enclosingLayer()->scrollableArea()) {
             if (area->hasVerticalBarDamage())
                 invalidatePaintRectangle(area->verticalBarDamage());
             if (area->hasHorizontalBarDamage())
                 invalidatePaintRectangle(area->horizontalBarDamage());
             area->resetScrollbarDamage();
         }
     }
-
-    PaintInvalidationState childTreeWalkState(paintInvalidationState, *this, newPaintInvalidationContainer);
-    RenderObject::invalidateTreeIfNeeded(childTreeWalkState);
 }
 
 bool RenderBox::pushContentsClip(PaintInfo& paintInfo, const LayoutPoint& accumulatedOffset, ContentsClipBehavior contentsClipBehavior)
 {
     if (paintInfo.phase == PaintPhaseBlockBackground || paintInfo.phase == PaintPhaseSelfOutline || paintInfo.phase == PaintPhaseMask)
         return false;
 
     bool isControlClip = hasControlClip();
     bool isOverflowClip = hasOverflowClip() && !layer()->isSelfPaintingLayer();
 
@@ skipping 3050 matching lines @@
 
         // We need the old border box size only when the box has background or box decorations.
         if (!style()->hasBackground() && !style()->hasBoxDecorations())
             return;
     }
 
     ensureRareData().m_previousBorderBoxSize = size();
 }
 
 } // namespace WebCore