Rename RenderObject::setNeedsLayout to setNeedsLayoutAndFullRepaint

Source/core/rendering/RenderInline.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. 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
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 175 matching lines @@
         // If any descendant blocks exist then they will be in the next anonymous block and its siblings.
         RenderObject* block = containingBlock()->nextSibling();
         ASSERT(block && block->isAnonymousBlock());
         updateStyleOfAnonymousBlockContinuations(block, newStyle, oldStyle);
     }
 
     if (!m_alwaysCreateLineBoxes) {
         bool alwaysCreateLineBoxes = hasSelfPaintingLayer() || hasBoxDecorations() || newStyle->hasPadding() || newStyle->hasMargin() || hasOutline();
         if (oldStyle && alwaysCreateLineBoxes) {
             dirtyLineBoxes(false);
-            setNeedsLayout();
+            setNeedsLayoutAndFullRepaint();
         }
         m_alwaysCreateLineBoxes = alwaysCreateLineBoxes;
     }
 }
 
 void RenderInline::updateAlwaysCreateLineBoxes(bool fullLayout)
 {
     // Once we have been tainted once, just assume it will happen again. This way effects like hover highlighting that change the
     // background color will only cause a layout on the first rollover.
     if (m_alwaysCreateLineBoxes)
@@ skipping 110 matching lines @@
         newBox->setStyle(newStyle.release());
         RenderBoxModelObject* oldContinuation = continuation();
         setContinuation(newBox);
 
         splitFlow(beforeChild, newBox, newChild, oldContinuation);
         return;
     }
 
     RenderBoxModelObject::addChild(newChild, beforeChild);
 
-    newChild->setNeedsLayoutAndPrefWidthsRecalc();
+    newChild->setNeedsLayoutAndPrefWidthsRecalcAndFullRepaint();
 }
 
 RenderInline* RenderInline::clone() const
 {
     RenderInline* cloneInline = new RenderInline(node());
     cloneInline->setStyle(style());
     cloneInline->setFlowThreadState(flowThreadState());
     return cloneInline;
 }
 
@@ skipping 16 matching lines @@
             beforeChild = fullscreen->fullScreenRenderer();
     }
 
     // Now take all of the children from beforeChild to the end and remove
     // them from |this| and place them in the clone.
     RenderObject* o = beforeChild;
     while (o) {
         RenderObject* tmp = o;
         o = tmp->nextSibling();
         cloneInline->addChildIgnoringContinuation(children()->removeChildNode(this, tmp), 0);
-        tmp->setNeedsLayoutAndPrefWidthsRecalc();
+        tmp->setNeedsLayoutAndPrefWidthsRecalcAndFullRepaint();
     }
 
     // Hook |clone| up as the continuation of the middle block.
     middleBlock->setContinuation(cloneInline);
 
     // We have been reparented and are now under the fromBlock.  We need
     // to walk up our inline parent chain until we hit the containing block.
     // Once we hit the containing block we're done.
     RenderBoxModelObject* curr = toRenderBoxModelObject(parent());
     RenderBoxModelObject* currChild = this;
@@ skipping 20 matching lines @@
             inlineCurr->setContinuation(cloneInline);
             cloneInline->setContinuation(oldCont);
 
             // Now we need to take all of the children starting from the first child
             // *after* currChild and append them all to the clone.
             o = currChild->nextSibling();
             while (o) {
                 RenderObject* tmp = o;
                 o = tmp->nextSibling();
                 cloneInline->addChildIgnoringContinuation(inlineCurr->children()->removeChildNode(curr, tmp), 0);
-                tmp->setNeedsLayoutAndPrefWidthsRecalc();
+                tmp->setNeedsLayoutAndPrefWidthsRecalcAndFullRepaint();
             }
         }
 
         // Keep walking up the chain.
         currChild = curr;
         curr = toRenderBoxModelObject(curr->parent());
         splitDepth++;
     }
 
     // Now we are at the block level. We need to put the clone into the toBlock.
@@ skipping 40 matching lines @@
     block->children()->insertChildNode(block, newBlockBox, boxFirst);
     block->children()->insertChildNode(block, post, boxFirst);
     block->setChildrenInline(false);
 
     if (madeNewBeforeBlock) {
         RenderObject* o = boxFirst;
         while (o) {
             RenderObject* no = o;
             o = no->nextSibling();
             pre->children()->appendChildNode(pre, block->children()->removeChildNode(block, no));
-            no->setNeedsLayoutAndPrefWidthsRecalc();
+            no->setNeedsLayoutAndPrefWidthsRecalcAndFullRepaint();
         }
     }
 
     splitInlines(pre, post, newBlockBox, beforeChild, oldCont);
 
     // We already know the newBlockBox isn't going to contain inline kids, so avoid wasting
     // time in makeChildrenNonInline by just setting this explicitly up front.
     newBlockBox->setChildrenInline(false);
 
     newBlockBox->addChild(newChild);
 
     // Always just do a full layout in order to ensure that line boxes (especially wrappers for images)
     // get deleted properly.  Because objects moves from the pre block into the post block, we want to
     // make new line boxes instead of leaving the old line boxes around.
-    pre->setNeedsLayoutAndPrefWidthsRecalc();
-    block->setNeedsLayoutAndPrefWidthsRecalc();
-    post->setNeedsLayoutAndPrefWidthsRecalc();
+    pre->setNeedsLayoutAndPrefWidthsRecalcAndFullRepaint();
+    block->setNeedsLayoutAndPrefWidthsRecalcAndFullRepaint();
+    post->setNeedsLayoutAndPrefWidthsRecalcAndFullRepaint();
 }
 
 void RenderInline::addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild)
 {
     RenderBoxModelObject* flow = continuationBefore(beforeChild);
     ASSERT(!beforeChild || beforeChild->parent()->isRenderBlock() || beforeChild->parent()->isRenderInline());
     RenderBoxModelObject* beforeChildParent = 0;
     if (beforeChild)
         beforeChildParent = toRenderBoxModelObject(beforeChild->parent());
     else {
@@ skipping 1079 matching lines @@
         container = this;
 
     FloatPoint absPos = container->localToAbsolute();
     region.bounds.setX(absPos.x() + region.bounds.x());
     region.bounds.setY(absPos.y() + region.bounds.y());
 
     regions.append(region);
 }
 
 } // namespace WebCore