Divorce PaintInvalidationState from LayoutState

Source/core/rendering/RenderBlock.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. 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
  * License as published by the Free Software Foundation; either
@@ skipping 342 matching lines @@
     // If the style has unloaded images, want to notify the ResourceLoadPriorityOptimizer so that
     // network priorities can be set.
     Vector<ImageResource*> images;
     appendImagesFromStyle(images, *newStyle);
     if (images.isEmpty())
         ResourceLoadPriorityOptimizer::resourceLoadPriorityOptimizer()->removeRenderObject(this);
     else
         ResourceLoadPriorityOptimizer::resourceLoadPriorityOptimizer()->addRenderObject(this);
 }
 
-void RenderBlock::invalidateTreeAfterLayout(const RenderLayerModelObject& invalidationContainer)
+void RenderBlock::invalidateTreeAfterLayout(const InvalidationTreeWalkState& invalidationTreeWalkState)
 {
     // Note, we don't want to early out here using shouldCheckForInvalidationAfterLayout as
     // we have to make sure we go through any positioned objects as they won't be seen in
     // the normal tree walk.
 
     if (shouldCheckForPaintInvalidationAfterLayout())
-        RenderBox::invalidateTreeAfterLayout(invalidationContainer);
+        RenderBox::invalidateTreeAfterLayout(invalidationTreeWalkState);
 
-    // Take care of positioned objects. This is required as LayoutState keeps a single clip rect.
+    // Take care of positioned objects. This is required as InvalidationTreeWalkState keeps a single clip rect.
     if (TrackedRendererListHashSet* positionedObjects = this->positionedObjects()) {
         TrackedRendererListHashSet::iterator end = positionedObjects->end();
-        LayoutState state(*this, isTableRow() ? LayoutSize() : locationOffset());
+        bool establishesNewPaintInvalidationContainer = isPaintInvalidationContainer();
+        const RenderLayerModelObject& newPaintInvalidationContainer = *adjustCompositedContainerForSpecialAncestors(establishesNewPaintInvalidationContainer ? this : &invalidationTreeWalkState.paintInvalidationContainer());
+        InvalidationTreeWalkState childInvalidationTreeWalkState(invalidationTreeWalkState, *this, newPaintInvalidationContainer);
         for (TrackedRendererListHashSet::iterator it = positionedObjects->begin(); it != end; ++it) {
             RenderBox* box = *it;
 
             // One of the renderers we're skipping over here may be the child's repaint container,
             // so we can't pass our own repaint container along.
             const RenderLayerModelObject& repaintContainerForChild = *box->containerForPaintInvalidation();
 
+            // If it's a new repaint container, we won't have properly accumulated the offset into the
+            // InvalidationTreeWalkState.
+            // FIXME: Teach InvalidationTreeWalkState to handle this case.

[Julien - ping for review, 2014/07/02 00:27:28]

Link to the existing bug for LayoutState.

+            if (&repaintContainerForChild != newPaintInvalidationContainer) {
+                ForceHorriblySlowRectMapping slowRectMapping(&childInvalidationTreeWalkState);
+                InvalidationTreeWalkState disabledTreeWalkState(childInvalidationTreeWalkState, *this, repaintContainerForChild);
+                box->invalidateTreeAfterLayout(childInvalidationTreeWalkState);
+                continue;
+            }
+
             // If the positioned renderer is absolutely positioned and it is inside
             // a relatively positioend inline element, we need to account for
-            // the inline elements position in LayoutState.
+            // the inline elements position in InvalidationTreeWalkState.
             if (box->style()->position() == AbsolutePosition) {
                 RenderObject* container = box->container(&repaintContainerForChild, 0);
                 if (container->isRelPositioned() && container->isRenderInline()) {
-                    // FIXME: We should be able to use layout-state for this.
-                    // Currently, we will place absolutly positioned elements inside
+                    // FIXME: We should be able to use InvalidationTreeWalkState for this.
+                    // Currently, we will place absolutely positioned elements inside
                     // relatively positioned inline blocks in the wrong location. crbug.com/371485
-                    ForceHorriblySlowRectMapping slowRectMapping(*this);
-                    box->invalidateTreeAfterLayout(repaintContainerForChild);
+                    ForceHorriblySlowRectMapping slowRectMapping(&childInvalidationTreeWalkState);
+                    InvalidationTreeWalkState disabledTreeWalkState(childInvalidationTreeWalkState, *this, repaintContainerForChild);

[Julien - ping for review, 2014/07/02 00:27:28]

|disabledTreeWalkState| is unused.

+                    box->invalidateTreeAfterLayout(childInvalidationTreeWalkState);
                     continue;
                 }
             }
 
-            box->invalidateTreeAfterLayout(repaintContainerForChild);
+            box->invalidateTreeAfterLayout(childInvalidationTreeWalkState);
         }
     }
 }
 
 RenderBlock* RenderBlock::continuationBefore(RenderObject* beforeChild)
 {
     if (beforeChild && beforeChild->parent() == this)
         return this;
 
     RenderBlock* curr = toRenderBlock(continuation());
@@ skipping 3585 matching lines @@
     return 0;
 }
 
 void RenderBlock::updateFirstLetterStyle(RenderObject* firstLetterBlock, RenderObject* currentChild)
 {
     RenderObject* firstLetter = currentChild->parent();
     RenderObject* firstLetterContainer = firstLetter->parent();
     RenderStyle* pseudoStyle = styleForFirstLetter(firstLetterBlock, firstLetterContainer);
     ASSERT(firstLetter->isFloating() || firstLetter->isInline());
 
-    ForceHorriblySlowRectMapping slowRectMapping(*this);
-
     if (RenderStyle::stylePropagationDiff(firstLetter->style(), pseudoStyle) == Reattach) {
         // The first-letter renderer needs to be replaced. Create a new renderer of the right type.
         RenderBoxModelObject* newFirstLetter;
         if (pseudoStyle->display() == INLINE)
             newFirstLetter = RenderInline::createAnonymous(&document());
         else
             newFirstLetter = RenderBlockFlow::createAnonymous(&document());
         newFirstLetter->setStyle(pseudoStyle);
 
         // Move the first letter into the new renderer.
@@ skipping 160 matching lines @@
     if (currChild->parent()->style()->styleType() == FIRST_LETTER) {
         updateFirstLetterStyle(firstLetterBlock, currChild);
         return;
     }
 
     // FIXME: This black-list of disallowed RenderText subclasses is fragile.
     // Should counter be on this list? What about RenderTextFragment?
     if (!currChild->isText() || currChild->isBR() || toRenderText(currChild)->isWordBreak())
         return;
 
-    // Our layout state is not valid for the repaints we are going to trigger by
-    // adding and removing children of firstLetterContainer.
-    ForceHorriblySlowRectMapping slowRectMapping(*this);
-
     createFirstLetterRenderer(firstLetterBlock, currChild, length);
 }
 
 // Helper methods for obtaining the last line, computing line counts and heights for line counts
 // (crawling into blocks).
 static bool shouldCheckLines(RenderObject* obj)
 {
     return !obj->isFloatingOrOutOfFlowPositioned()
         && obj->isRenderBlock() && obj->style()->height().isAuto()
         && (!obj->isDeprecatedFlexibleBox() || obj->style()->boxOrient() == VERTICAL);
@@ skipping 238 matching lines @@
         // https://bugs.webkit.org/show_bug.cgi?id=46781
         FloatRect localRect(0, -collapsedMarginBefore().toFloat(),
             width().toFloat(), (height() + collapsedMarginBefore() + collapsedMarginAfter()).toFloat());
         quads.append(localToAbsoluteQuad(localRect, 0 /* mode */, wasFixed));
         continuation()->absoluteQuads(quads, wasFixed);
     } else {
         quads.append(RenderBox::localToAbsoluteQuad(FloatRect(0, 0, width().toFloat(), height().toFloat()), 0 /* mode */, wasFixed));
     }
 }
 
-LayoutRect RenderBlock::rectWithOutlineForPaintInvalidation(const RenderLayerModelObject* paintInvalidationContainer, LayoutUnit outlineWidth) const
+LayoutRect RenderBlock::rectWithOutlineForPaintInvalidation(const RenderLayerModelObject* paintInvalidationContainer, LayoutUnit outlineWidth, const InvalidationTreeWalkState* invalidationTreeWalkState) const
 {
-    LayoutRect r(RenderBox::rectWithOutlineForPaintInvalidation(paintInvalidationContainer, outlineWidth));
+    LayoutRect r(RenderBox::rectWithOutlineForPaintInvalidation(paintInvalidationContainer, outlineWidth, invalidationTreeWalkState));
     if (isAnonymousBlockContinuation())
         r.inflateY(collapsedMarginBefore()); // FIXME: This is wrong for block-flows that are horizontal.
     return r;
 }
 
 RenderObject* RenderBlock::hoverAncestor() const
 {
     return isAnonymousBlockContinuation() ? continuation() : RenderBox::hoverAncestor();
 }
 
@@ skipping 576 matching lines @@
 void RenderBlock::showLineTreeAndMark(const InlineBox* markedBox1, const char* markedLabel1, const InlineBox* markedBox2, const char* markedLabel2, const RenderObject* obj) const
 {
     showRenderObject();
     for (const RootInlineBox* root = firstRootBox(); root; root = root->nextRootBox())
         root->showLineTreeAndMark(markedBox1, markedLabel1, markedBox2, markedLabel2, obj, 1);
 }
 
 #endif
 
 } // namespace WebCore