Changeset 21093 in webkit

Timestamp:

Apr 25, 2007 12:10:24 PM (17 years ago)

Author:

hyatt

Message:

Rearchitect calcPrefWidths. The calculation is now done lazily only when minPrefWidth
or maxPrefWidth are asked for. The result of the calculation is cached.

The new invalidation scheme for pref width invalidation follows the
containing block hierarchy and knows to halt at positioned objects, since
they cannot influence the size of their containers.

Reviewed by darin

• css/cssstyleselector.cpp: (WebCore::CSSStyleSelector::init): (WebCore::CSSStyleSelector::initForStyleResolve):
• page/FrameView.cpp: (WebCore::FrameView::layout):
• rendering/RenderApplet.cpp: (WebCore::RenderApplet::layout):
• rendering/RenderBlock.cpp: (WebCore::RenderBlock::makeChildrenNonInline): (WebCore::RenderBlock::removeChild): (WebCore::RenderBlock::layout): (WebCore::RenderBlock::layoutBlock): (WebCore::RenderBlock::calcPrefWidths): (WebCore::InlineMinMaxIterator::endOfInline): (WebCore::shouldGrowTableCellForImage): (WebCore::RenderBlock::calcInlinePrefWidths): (WebCore::RenderBlock::calcBlockPrefWidths):
• rendering/RenderBlock.h:
• rendering/RenderBox.cpp: (WebCore::RenderBox::setStyle): (WebCore::RenderBox::minPrefWidth): (WebCore::RenderBox::maxPrefWidth): (WebCore::RenderBox::calcWidth): (WebCore::RenderBox::calcWidthUsing): (WebCore::RenderBox::calcAbsoluteHorizontal): (WebCore::RenderBox::calcAbsoluteHorizontalValues):
• rendering/RenderBox.h:
• rendering/RenderContainer.cpp: (WebCore::RenderContainer::removeChildNode): (WebCore::RenderContainer::appendChildNode): (WebCore::RenderContainer::insertChildNode): (WebCore::RenderContainer::layout):
• rendering/RenderContainer.h: (WebCore::RenderContainer::moveChildNode):
• rendering/RenderCounter.cpp: (WebCore::RenderCounter::dirtyLineBoxes): (WebCore::RenderCounter::calcPrefWidths):
• rendering/RenderCounter.h:
• rendering/RenderFileUploadControl.cpp: (WebCore::RenderFileUploadControl::calcPrefWidths):
• rendering/RenderFlexibleBox.cpp: (WebCore::RenderFlexibleBox::calcHorizontalPrefWidths): (WebCore::RenderFlexibleBox::calcVerticalPrefWidths): (WebCore::RenderFlexibleBox::calcPrefWidths): (WebCore::RenderFlexibleBox::layoutBlock):
• rendering/RenderForeignObject.cpp: (WebCore::RenderForeignObject::layout):
• rendering/RenderFrameSet.cpp: (WebCore::RenderFrameSet::layout):
• rendering/RenderHTMLCanvas.cpp: (WebCore::RenderHTMLCanvas::layout):
• rendering/RenderImage.cpp: (WebCore::RenderImage::layout):
• rendering/RenderInline.cpp:
• rendering/RenderInline.h:
• rendering/RenderListBox.cpp: (WebCore::RenderListBox::updateFromElement): (WebCore::RenderListBox::calcPrefWidths):
• rendering/RenderListItem.cpp: (WebCore::firstNonMarkerChild): (WebCore::RenderListItem::updateMarkerLocation): (WebCore::RenderListItem::calcPrefWidths): (WebCore::RenderListItem::layout):
• rendering/RenderListMarker.cpp: (WebCore::RenderListMarker::layout): (WebCore::RenderListMarker::calcPrefWidths): (WebCore::RenderListMarker::updateMargins):
• rendering/RenderListMarker.h:
• rendering/RenderObject.cpp: (WebCore::RenderObject::RenderObject): (WebCore::RenderObject::removeChildNode): (WebCore::RenderObject::moveChildNode): (WebCore::RenderObject::appendChildNode): (WebCore::RenderObject::insertChildNode): (WebCore::RenderObject::setPrefWidthsDirty): (WebCore::RenderObject::invalidateContainingBlockPrefWidths): (WebCore::RenderObject::information): (WebCore::RenderObject::setStyle):
• rendering/RenderObject.h: (WebCore::RenderObject::layer): (WebCore::RenderObject::hasLayer): (WebCore::RenderObject::prefWidthsDirty): (WebCore::RenderObject::setNeedsLayoutAndPrefWidthsRecalc): (WebCore::RenderObject::setHasLayer):
• rendering/RenderPartObject.cpp: (WebCore::RenderPartObject::layout):
• rendering/RenderSVGContainer.cpp: (WebCore::RenderSVGContainer::layout):
• rendering/RenderSVGContainer.h:
• rendering/RenderSVGHiddenContainer.cpp:
• rendering/RenderSVGHiddenContainer.h:
• rendering/RenderSVGText.cpp: (WebCore::RenderSVGText::layout):
• rendering/RenderTable.cpp: (WebCore::RenderTable::calcWidth): (WebCore::RenderTable::layout): (WebCore::RenderTable::removeChildNode):
• rendering/RenderTable.h:
• rendering/RenderTableRow.cpp: (WebCore::RenderTableRow::layout):
• rendering/RenderTableSection.cpp: (WebCore::RenderTableSection::removeChildNode):
• rendering/RenderTableSection.h:
• rendering/RenderText.cpp: (WebCore::RenderText::trimmedPrefWidths): (WebCore::isSpaceAccordingToStyle): (WebCore::RenderText::minPrefWidth): (WebCore::RenderText::maxPrefWidth): (WebCore::RenderText::calcPrefWidths): (WebCore::RenderText::width):
• rendering/RenderText.h:
• rendering/RenderView.cpp: (WebCore::RenderView::RenderView): (WebCore::RenderView::calcPrefWidths): (WebCore::RenderView::layout):
• rendering/RenderWidget.cpp: (WebCore::RenderWidget::layout):

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (2 diffs)
• css/cssstyleselector.cpp (modified) (2 diffs)
• page/FrameView.cpp (modified) (1 diff)
• rendering/RenderApplet.cpp (modified) (1 diff)
• rendering/RenderBlock.cpp (modified) (12 diffs)
• rendering/RenderBox.cpp (modified) (9 diffs)
• rendering/RenderBox.h (modified) (2 diffs)
• rendering/RenderContainer.cpp (modified) (8 diffs)
• rendering/RenderContainer.h (modified) (1 diff)
• rendering/RenderCounter.cpp (modified) (1 diff)
• rendering/RenderCounter.h (modified) (1 diff)
• rendering/RenderFileUploadControl.cpp (modified) (1 diff)
• rendering/RenderFlexibleBox.cpp (modified) (4 diffs)
• rendering/RenderForeignObject.cpp (modified) (1 diff)
• rendering/RenderFrameSet.cpp (modified) (1 diff)
• rendering/RenderHTMLCanvas.cpp (modified) (1 diff)
• rendering/RenderImage.cpp (modified) (1 diff)
• rendering/RenderInline.cpp (modified) (1 diff)
• rendering/RenderInline.h (modified) (1 diff)
• rendering/RenderListBox.cpp (modified) (2 diffs)
• rendering/RenderListItem.cpp (modified) (3 diffs)
• rendering/RenderListMarker.cpp (modified) (6 diffs)
• rendering/RenderListMarker.h (modified) (2 diffs)
• rendering/RenderObject.cpp (modified) (8 diffs)
• rendering/RenderObject.h (modified) (10 diffs)
• rendering/RenderPartObject.cpp (modified) (1 diff)
• rendering/RenderSVGContainer.cpp (modified) (1 diff)
• rendering/RenderSVGContainer.h (modified) (1 diff)
• rendering/RenderSVGHiddenContainer.cpp (modified) (1 diff)
• rendering/RenderSVGHiddenContainer.h (modified) (1 diff)
• rendering/RenderSVGText.cpp (modified) (1 diff)
• rendering/RenderTable.cpp (modified) (5 diffs)
• rendering/RenderTable.h (modified) (1 diff)
• rendering/RenderTableRow.cpp (modified) (1 diff)
• rendering/RenderTableSection.cpp (modified) (1 diff)
• rendering/RenderTableSection.h (modified) (1 diff)
• rendering/RenderText.cpp (modified) (4 diffs)
• rendering/RenderText.h (modified) (3 diffs)
• rendering/RenderView.cpp (modified) (4 diffs)
• rendering/RenderWidget.cpp (modified) (1 diff)

trunk/WebCore/ChangeLog

@@ +1 @@
+2007-04-25  David Hyatt  <hyatt@apple.com>
+
+        Rearchitect calcPrefWidths.  The calculation is now done lazily only when minPrefWidth
+        or maxPrefWidth are asked for.  The result of the calculation is cached.
+
+        The new invalidation scheme for pref width invalidation follows the
+        containing block hierarchy and knows to halt at positioned objects, since
+        they cannot influence the size of their containers.
+
+        Reviewed by darin
+
+        * css/cssstyleselector.cpp:
+        (WebCore::CSSStyleSelector::init):
+        (WebCore::CSSStyleSelector::initForStyleResolve):
+        * page/FrameView.cpp:
+        (WebCore::FrameView::layout):
+        * rendering/RenderApplet.cpp:
+        (WebCore::RenderApplet::layout):
+        * rendering/RenderBlock.cpp:
+        (WebCore::RenderBlock::makeChildrenNonInline):
+        (WebCore::RenderBlock::removeChild):
+        (WebCore::RenderBlock::layout):
+        (WebCore::RenderBlock::layoutBlock):
+        (WebCore::RenderBlock::calcPrefWidths):
+        (WebCore::InlineMinMaxIterator::endOfInline):
+        (WebCore::shouldGrowTableCellForImage):
+        (WebCore::RenderBlock::calcInlinePrefWidths):
+        (WebCore::RenderBlock::calcBlockPrefWidths):
+        * rendering/RenderBlock.h:
+        * rendering/RenderBox.cpp:
+        (WebCore::RenderBox::setStyle):
+        (WebCore::RenderBox::minPrefWidth):
+        (WebCore::RenderBox::maxPrefWidth):
+        (WebCore::RenderBox::calcWidth):
+        (WebCore::RenderBox::calcWidthUsing):
+        (WebCore::RenderBox::calcAbsoluteHorizontal):
+        (WebCore::RenderBox::calcAbsoluteHorizontalValues):
+        * rendering/RenderBox.h:
+        * rendering/RenderContainer.cpp:
+        (WebCore::RenderContainer::removeChildNode):
+        (WebCore::RenderContainer::appendChildNode):
+        (WebCore::RenderContainer::insertChildNode):
+        (WebCore::RenderContainer::layout):
+        * rendering/RenderContainer.h:
+        (WebCore::RenderContainer::moveChildNode):
+        * rendering/RenderCounter.cpp:
+        (WebCore::RenderCounter::dirtyLineBoxes):
+        (WebCore::RenderCounter::calcPrefWidths):
+        * rendering/RenderCounter.h:
+        * rendering/RenderFileUploadControl.cpp:
+        (WebCore::RenderFileUploadControl::calcPrefWidths):
+        * rendering/RenderFlexibleBox.cpp:
+        (WebCore::RenderFlexibleBox::calcHorizontalPrefWidths):
+        (WebCore::RenderFlexibleBox::calcVerticalPrefWidths):
+        (WebCore::RenderFlexibleBox::calcPrefWidths):
+        (WebCore::RenderFlexibleBox::layoutBlock):
+        * rendering/RenderForeignObject.cpp:
+        (WebCore::RenderForeignObject::layout):
+        * rendering/RenderFrameSet.cpp:
+        (WebCore::RenderFrameSet::layout):
+        * rendering/RenderHTMLCanvas.cpp:
+        (WebCore::RenderHTMLCanvas::layout):
+        * rendering/RenderImage.cpp:
+        (WebCore::RenderImage::layout):
+        * rendering/RenderInline.cpp:
+        * rendering/RenderInline.h:
+        * rendering/RenderListBox.cpp:
+        (WebCore::RenderListBox::updateFromElement):
+        (WebCore::RenderListBox::calcPrefWidths):
+        * rendering/RenderListItem.cpp:
+        (WebCore::firstNonMarkerChild):
+        (WebCore::RenderListItem::updateMarkerLocation):
+        (WebCore::RenderListItem::calcPrefWidths):
+        (WebCore::RenderListItem::layout):
+        * rendering/RenderListMarker.cpp:
+        (WebCore::RenderListMarker::layout):
+        (WebCore::RenderListMarker::calcPrefWidths):
+        (WebCore::RenderListMarker::updateMargins):
+        * rendering/RenderListMarker.h:
+        * rendering/RenderObject.cpp:
+        (WebCore::RenderObject::RenderObject):
+        (WebCore::RenderObject::removeChildNode):
+        (WebCore::RenderObject::moveChildNode):
+        (WebCore::RenderObject::appendChildNode):
+        (WebCore::RenderObject::insertChildNode):
+        (WebCore::RenderObject::setPrefWidthsDirty):
+        (WebCore::RenderObject::invalidateContainingBlockPrefWidths):
+        (WebCore::RenderObject::information):
+        (WebCore::RenderObject::setStyle):
+        * rendering/RenderObject.h:
+        (WebCore::RenderObject::layer):
+        (WebCore::RenderObject::hasLayer):
+        (WebCore::RenderObject::prefWidthsDirty):
+        (WebCore::RenderObject::setNeedsLayoutAndPrefWidthsRecalc):
+        (WebCore::RenderObject::setHasLayer):
+        * rendering/RenderPartObject.cpp:
+        (WebCore::RenderPartObject::layout):
+        * rendering/RenderSVGContainer.cpp:
+        (WebCore::RenderSVGContainer::layout):
+        * rendering/RenderSVGContainer.h:
+        * rendering/RenderSVGHiddenContainer.cpp:
+        * rendering/RenderSVGHiddenContainer.h:
+        * rendering/RenderSVGText.cpp:
+        (WebCore::RenderSVGText::layout):
+        * rendering/RenderTable.cpp:
+        (WebCore::RenderTable::calcWidth):
+        (WebCore::RenderTable::layout):
+        (WebCore::RenderTable::removeChildNode):
+        * rendering/RenderTable.h:
+        * rendering/RenderTableRow.cpp:
+        (WebCore::RenderTableRow::layout):
+        * rendering/RenderTableSection.cpp:
+        (WebCore::RenderTableSection::removeChildNode):
+        * rendering/RenderTableSection.h:
+        * rendering/RenderText.cpp:
+        (WebCore::RenderText::trimmedPrefWidths):
+        (WebCore::isSpaceAccordingToStyle):
+        (WebCore::RenderText::minPrefWidth):
+        (WebCore::RenderText::maxPrefWidth):
+        (WebCore::RenderText::calcPrefWidths):
+        (WebCore::RenderText::width):
+        * rendering/RenderText.h:
+        * rendering/RenderView.cpp:
+        (WebCore::RenderView::RenderView):
+        (WebCore::RenderView::calcPrefWidths):
+        (WebCore::RenderView::layout):
+        * rendering/RenderWidget.cpp:
+        (WebCore::RenderWidget::layout):
+
 2007-04-25  Steve Falkenburg  <sfalken@apple.com>
 
@@ -494 +623 @@
         <rdar://problem/4966982> 64-bit: In a unordered list, TYPE=DISC and TYPE=CIRCLE attribute values are ignored
 
-        We need to draw our full-circle arcs counter-clockwise, since a clockwise arc from 0 to 2π is no arc at all!
+        We need to draw our full-circle arcs counter-clockwise, since a clockwise arc from 0 to 2π is no arc at all!
         This only worked on 32-bit due to a rounding error in CoreGraphics, causing it to draw a full circle anyway.
 

trunk/WebCore/css/cssstyleselector.cpp

@@ -302 +302 @@
     element = 0;
     settings = 0;
-    m_matchedRules.clear();
     m_matchedDecls.clear();
     m_ruleList = 0;
@@ -565 +564 @@
     style = 0;
     
-    m_matchedRules.clear();
     m_matchedDecls.clear();
 

trunk/WebCore/page/FrameView.cpp

@@ -411 +411 @@
     }
 
-    if (subtree) {
-        if (root->recalcMinMax())
-            root->recalcMinMaxWidths();
-    }
     pauseScheduledEvents();
     root->layout();

trunk/WebCore/rendering/RenderApplet.cpp

@@ -96 +96 @@
 {
     ASSERT(needsLayout());
-    ASSERT(!prefWidthsDirty());
 
     calcWidth();

trunk/WebCore/rendering/RenderBlock.cpp

@@ -326 +326 @@
             RenderObject* no = o;
             o = no->nextSibling();
-            box->appendChildNode(removeChildNode(no));
-        }
-        box->appendChildNode(removeChildNode(inlineRunEnd));
+            box->moveChildNode(no);
+        }
+        box->moveChildNode(inlineRunEnd);
     }
 
@@ -356 +356 @@
             RenderObject* no = o;
             o = no->nextSibling();
-            prev->appendChildNode(next->removeChildNode(no));
-            no->setNeedsLayoutAndPrefWidthsRecalc();
+            prev->moveChildNode(no);
         }
  
@@ -381 +380 @@
             RenderObject* no = o;
             o = no->nextSibling();
-            appendChildNode(anonBlock->removeChildNode(no));
-            no->setNeedsLayoutAndPrefWidthsRecalc();
+            moveChildNode(no);
         }
 
@@ -465 +463 @@
 void RenderBlock::layout()
 {
+    // Update our first letter info now.
+    updateFirstLetter();
+
     // Table cells call layoutBlock directly, so don't add any logic here.  Put code into
     // layoutBlock().
@@ -482 +483 @@
 {
     ASSERT(needsLayout());
-    ASSERT(!prefWidthsDirty());
 
     if (isInline() && !isInlineBlockOrInlineTable()) // Inline <form>s inside various table elements can
@@ -3252 +3252 @@
     ASSERT(prefWidthsDirty());
 
+    updateFirstLetter();
+
     if (!isTableCell() && style()->width().isFixed() && style()->width().value() > 0)
         m_minPrefWidth = m_maxPrefWidth = calcContentBoxWidth(style()->width().value());
@@ -3274 +3276 @@
 
         if (isTableCell()) {
-            Length w = static_cast<RenderTableCell*>(this)->styleOrColWidth();
+            Length w = static_cast<const RenderTableCell*>(this)->styleOrColWidth();
             if (w.isFixed() && w.value() > 0)
                 m_maxPrefWidth = max(m_minPrefWidth, calcContentBoxWidth(w.value()));
@@ -3313 +3315 @@
     bool endOfInline;
 
-    InlineMinMaxIterator(RenderObject* p, RenderObject* o, bool end = false)
-        :parent(p), current(o), endOfInline(end) {}
+    InlineMinMaxIterator(RenderObject* p, bool end = false)
+        :parent(p), current(p), endOfInline(end) {}
 
     RenderObject* next();
@@ -3404 +3406 @@
 // very specific cirucumstances. Not supporting the quirk has caused us to
 // mis-render some real sites. (See Bugzilla 10517.) 
-static bool shouldGrowTableCellForImage(RenderBlock* containingBlock, RenderObject* image, RenderObject* adjacentLeaf)
+static bool shouldGrowTableCellForImage(const RenderBlock* containingBlock, const RenderObject* image, const RenderObject* adjacentLeaf)
 {
     if (!containingBlock->style()->htmlHacks())
@@ -3439 +3441 @@
     autoWrap = oldAutoWrap = style()->autoWrap();
 
-    InlineMinMaxIterator childIterator(this, this);
+    InlineMinMaxIterator childIterator(this);
     bool addedTextIndent = false; // Only gets added in once.
     RenderObject* prevFloat = 0;
     RenderObject* previousLeaf = 0;
-    while (RenderObject* child = childIterator.next())
-    {
+    while (RenderObject* child = childIterator.next()) {
         InlineMinMaxIterator leafIterator = childIterator;
         RenderObject* nextLeaf = leafIterator.next();
@@ -3510 +3511 @@
                     Length leftMargin = cstyle->marginLeft();
                     Length rightMargin = cstyle->marginRight();
-                    bool useCalculatedWidths = child->isListMarker();
-                    if (leftMargin.isPercent() || rightMargin.isPercent() || useCalculatedWidths)
-                        child->calcWidth();
-                    if (useCalculatedWidths || leftMargin.isPercent())
-                        margins += child->marginLeft();
-                    else if (leftMargin.isFixed())
+                    if (leftMargin.isFixed())
                         margins += leftMargin.value();
-                    if (useCalculatedWidths || rightMargin.isPercent())
-                        margins += child->marginRight();
-                    else if (rightMargin.isFixed())
+                    if (rightMargin.isFixed())
                         margins += rightMargin.value();
                     childMin += margins;
@@ -3710 +3704 @@
         }
 
+        // A margin basically has three types: fixed, percentage, and auto (variable).
+        // Auto and percentage margins simply become 0 when computing min/max width.
+        // Fixed margins can be added in as is.
         Length ml = child->style()->marginLeft();
         Length mr = child->style()->marginRight();
-
-        // Call calcWidth on the child to ensure that our margins are
-        // up to date.  This method can be called before the child has actually
-        // calculated its margins (which are computed inside calcWidth).
-        if (ml.isPercent() || mr.isPercent())
-            calcWidth();
-
-        // A margin basically has three types: fixed, percentage, and auto (variable).
-        // Auto margins simply become 0 when computing min/max width.
-        // Fixed margins can be added in as is.
-        // Percentage margins are computed as a percentage of the width we calculated in
-        // the calcWidth call above.  In this case we use the actual cached margin values on
-        // the RenderObject itself.
         int margin = 0, marginLeft = 0, marginRight = 0;
         if (ml.isFixed())
             marginLeft += ml.value();
-        else if (ml.isPercent())
-            marginLeft += child->marginLeft();
         if (mr.isFixed())
             marginRight += mr.value();
-        else if (mr.isPercent())
-            marginRight += child->marginRight();
         margin = marginLeft + marginRight;
 

trunk/WebCore/rendering/RenderBox.cpp

@@ -117 +117 @@
                 setChildNeedsLayout(true);
             m_layer = new (renderArena()) RenderLayer(this);
+            setHasLayer(true);
             m_layer->insertOnlyThisLayer();
             if (parent() && !needsLayout() && containingBlock())
@@ -125 +126 @@
         RenderLayer* layer = m_layer;
         m_layer = 0;
+        setHasLayer(false);
         layer->removeOnlyThisLayer();
         if (wasFloating && isFloating())
@@ -165 +167 @@
     if (layer)
         layer->destroy(arena);
+}
+
+int RenderBox::minPrefWidth() const
+{
+    if (prefWidthsDirty())
+        const_cast<RenderBox*>(this)->calcPrefWidths();
+        
+    return m_minPrefWidth;
+}
+
+int RenderBox::maxPrefWidth() const
+{
+    if (prefWidthsDirty())
+        const_cast<RenderBox*>(this)->calcPrefWidths();
+        
+    return m_maxPrefWidth;
 }
 
@@ -1058 +1076 @@
         m_marginRight = marginRight.calcMinValue(containerWidth);
         if (treatAsReplaced)
-            m_width = max(width.value() + borderLeft() + borderRight() + paddingLeft() + paddingRight(), m_minPrefWidth);
+            m_width = max(width.value() + borderLeft() + borderRight() + paddingLeft() + paddingRight(), minPrefWidth());
 
         return;
@@ -1087 +1105 @@
     }
 
-    if (m_width < m_minPrefWidth && stretchesToMinIntrinsicWidth()) {
-        m_width = m_minPrefWidth;
+    if (stretchesToMinIntrinsicWidth()) {
+        m_width = max(m_width, minPrefWidth());
         width = Length(m_width, Fixed);
     }
@@ -1129 +1147 @@
 
         if (sizesToIntrinsicWidth(widthType)) {
-            width = max(width, m_minPrefWidth);
-            width = min(width, m_maxPrefWidth);
+            width = max(width, minPrefWidth());
+            width = min(width, maxPrefWidth());
         }
     } else
@@ -1665 +1683 @@
     }
 
-    if (m_width < m_minPrefWidth - bordersPlusPadding && stretchesToMinIntrinsicWidth())
-        calcAbsoluteHorizontalValues(Length(m_minPrefWidth - bordersPlusPadding, Fixed), containerBlock, containerDirection,
+    if (stretchesToMinIntrinsicWidth() && m_width < minPrefWidth() - bordersPlusPadding)
+        calcAbsoluteHorizontalValues(Length(minPrefWidth() - bordersPlusPadding, Fixed), containerBlock, containerDirection,
                                      containerWidth, bordersPlusPadding,
                                      left, right, marginLeft, marginRight,
@@ -1799 +1817 @@
 
             // FIXME: would it be better to have shrink-to-fit in one step?
-            int preferredWidth = m_maxPrefWidth - bordersPlusPadding;
-            int preferredMinWidth = m_minPrefWidth - bordersPlusPadding;
+            int preferredWidth = maxPrefWidth() - bordersPlusPadding;
+            int preferredMinWidth = minPrefWidth() - bordersPlusPadding;
             int availableWidth = availableSpace - rightValue;
             widthValue = min(max(preferredMinWidth, availableWidth), preferredWidth);
@@ -1809 +1827 @@
 
             // FIXME: would it be better to have shrink-to-fit in one step?
-            int preferredWidth = m_maxPrefWidth - bordersPlusPadding;
-            int preferredMinWidth = m_minPrefWidth - bordersPlusPadding;
+            int preferredWidth = maxPrefWidth() - bordersPlusPadding;
+            int preferredMinWidth = minPrefWidth() - bordersPlusPadding;
             int availableWidth = availableSpace - leftValue;
             widthValue = min(max(preferredMinWidth, availableWidth), preferredWidth);

trunk/WebCore/rendering/RenderBox.h

@@ -43 +43 @@
     virtual void destroy();
 
-    virtual int minPrefWidth() const { return m_minPrefWidth; }
-    virtual int maxPrefWidth() const { return m_maxPrefWidth; }
+    virtual int minPrefWidth() const;
+    virtual int maxPrefWidth() const;
 
     virtual int overrideSize() const;
@@ -183 +183 @@
     void calcAbsoluteHorizontalReplaced();
 
+    // This function calculates the minimum and maximum preferred widths for an object.
+    // These values are used in shrink-to-fit layout systems.
+    // These include tables, positioned objects, floats and flexible boxes.
+    virtual void calcPrefWidths() = 0;
+
 protected:
     // The width/height of the contents + borders + padding.

trunk/WebCore/rendering/RenderContainer.cpp

@@ -157 +157 @@
 }
 
-RenderObject* RenderContainer::removeChildNode(RenderObject* oldChild)
+RenderObject* RenderContainer::removeChildNode(RenderObject* oldChild, bool fullRemove)
 {
     ASSERT(oldChild->parent() == this);
@@ -164 +164 @@
     // that a positioned child got yanked).  We also repaint, so that the area exposed when the child
     // disappears gets repainted properly.
-    if (!documentBeingDestroyed()) {
+    if (!documentBeingDestroyed() && fullRemove) {
         oldChild->setNeedsLayoutAndPrefWidthsRecalc();
         oldChild->repaint();
@@ -172 +172 @@
     oldChild->deleteLineBoxWrapper();
 
-    if (!documentBeingDestroyed()) {
+    if (!documentBeingDestroyed() && fullRemove) {
         // if we remove visible child from an invisible parent, we don't know the layer visibility any more
         RenderLayer* layer = 0;
@@ -376 +376 @@
 
 
-void RenderContainer::appendChildNode(RenderObject* newChild)
+void RenderContainer::appendChildNode(RenderObject* newChild, bool fullAppend)
 {
     ASSERT(newChild->parent() == 0);
@@ -392 +392 @@
     m_lastChild = newChild;
     
-    // Keep our layer hierarchy updated.  Optimize for the common case where we don't have any children
-    // and don't have a layer attached to ourselves.
-    RenderLayer* layer = 0;
-    if (newChild->firstChild() || newChild->hasLayer()) {
-        layer = enclosingLayer();
-        newChild->addLayers(layer, newChild);
-    }
-
-    // if the new child is visible but this object was not, tell the layer it has some visible content
-    // that needs to be drawn and layer visibility optimization can't be used
-    if (style()->visibility() != VISIBLE && newChild->style()->visibility() == VISIBLE && !newChild->hasLayer()) {
-        if (!layer)
+    if (fullAppend) {
+        // Keep our layer hierarchy updated.  Optimize for the common case where we don't have any children
+        // and don't have a layer attached to ourselves.
+        RenderLayer* layer = 0;
+        if (newChild->firstChild() || newChild->hasLayer()) {
             layer = enclosingLayer();
-        if (layer)
-            layer->setHasVisibleContent(true);
-    }
-    
+            newChild->addLayers(layer, newChild);
+        }
+
+        // if the new child is visible but this object was not, tell the layer it has some visible content
+        // that needs to be drawn and layer visibility optimization can't be used
+        if (style()->visibility() != VISIBLE && newChild->style()->visibility() == VISIBLE && !newChild->hasLayer()) {
+            if (!layer)
+                layer = enclosingLayer();
+            if (layer)
+                layer->setHasVisibleContent(true);
+        }
+        
+        if (!newChild->isFloatingOrPositioned() && childrenInline())
+            dirtyLinesFromChangedChild(newChild);
+    }
+
     newChild->setNeedsLayoutAndPrefWidthsRecalc(); // Goes up the containing block hierarchy.
     if (!normalChildNeedsLayout())
         setChildNeedsLayout(true); // We may supply the static position for an absolute positioned child.
     
-    if (!newChild->isFloatingOrPositioned() && childrenInline())
-        dirtyLinesFromChangedChild(newChild);
-    
     if (AXObjectCache::accessibilityEnabled())
         document()->axObjectCache()->childrenChanged(this);
 }
 
-void RenderContainer::insertChildNode(RenderObject* child, RenderObject* beforeChild)
+void RenderContainer::insertChildNode(RenderObject* child, RenderObject* beforeChild, bool fullInsert)
 {
     if (!beforeChild) {
@@ -445 +447 @@
     child->setParent(this);
     
-    // Keep our layer hierarchy updated.  Optimize for the common case where we don't have any children
-    // and don't have a layer attached to ourselves.
-    RenderLayer* layer = 0;
-    if (child->firstChild() || child->hasLayer()) {
-        layer = enclosingLayer();
-        child->addLayers(layer, child);
-    }
-
-    // if the new child is visible but this object was not, tell the layer it has some visible content
-    // that needs to be drawn and layer visibility optimization can't be used
-    if (style()->visibility() != VISIBLE && child->style()->visibility() == VISIBLE && !child->hasLayer()) {
-        if (!layer)
+    if (fullInsert) {
+        // Keep our layer hierarchy updated.  Optimize for the common case where we don't have any children
+        // and don't have a layer attached to ourselves.
+        RenderLayer* layer = 0;
+        if (child->firstChild() || child->hasLayer()) {
             layer = enclosingLayer();
-        if (layer)
-            layer->setHasVisibleContent(true);
+            child->addLayers(layer, child);
+        }
+
+        // if the new child is visible but this object was not, tell the layer it has some visible content
+        // that needs to be drawn and layer visibility optimization can't be used
+        if (style()->visibility() != VISIBLE && child->style()->visibility() == VISIBLE && !child->hasLayer()) {
+            if (!layer)
+                layer = enclosingLayer();
+            if (layer)
+                layer->setHasVisibleContent(true);
+        }
+
+        
+        if (!child->isFloating() && childrenInline())
+            dirtyLinesFromChangedChild(child);
     }
 
@@ -466 +474 @@
         setChildNeedsLayout(true); // We may supply the static position for an absolute positioned child.
     
-    if (!child->isFloating() && childrenInline())
-        dirtyLinesFromChangedChild(child);
-    
     if (AXObjectCache::accessibilityEnabled())
         document()->axObjectCache()->childrenChanged(this);
@@ -476 +481 @@
 {
     ASSERT(needsLayout());
-    ASSERT(!prefWidthsDirty());
 
     RenderObject* child = m_firstChild;

trunk/WebCore/rendering/RenderContainer.h

@@ -42 +42 @@
     void destroyLeftoverChildren();
 
-    virtual RenderObject* removeChildNode(RenderObject*);
-    virtual void appendChildNode(RenderObject*);
-    virtual void insertChildNode(RenderObject* child, RenderObject* before);
-
+    virtual RenderObject* removeChildNode(RenderObject*, bool fullRemove = true);
+    virtual void appendChildNode(RenderObject*, bool fullAppend = true);
+    virtual void insertChildNode(RenderObject* child, RenderObject* before, bool fullInsert = true);
+    
+    // Designed for speed.  Don't waste time doing a bunch of work like layer updating and repainting when we know that our
+    // change in parentage is not going to affect anything.
+    virtual void moveChildNode(RenderObject* child) { appendChildNode(child->parent()->removeChildNode(child, false), false); }
+    
     virtual void layout();
     virtual void calcPrefWidths() { setPrefWidthsDirty(false); }

trunk/WebCore/rendering/RenderCounter.cpp

@@ -245 +245 @@
 }
 
-void RenderCounter::calcPrefWidths()
+void RenderCounter::dirtyLineBoxes(bool fullLayout, bool dummy)
+{
+    if (prefWidthsDirty())
+        calcPrefWidths(0);
+    RenderText::dirtyLineBoxes(fullLayout, dummy);
+}
+
+void RenderCounter::calcPrefWidths(int lead)
 {
     setTextInternal(originalText());
-    RenderText::calcPrefWidths();
+    RenderText::calcPrefWidths(lead);
 }
 

trunk/WebCore/rendering/RenderCounter.h

@@ -36 +36 @@
     virtual bool isRenderCounter() const;
     virtual PassRefPtr<StringImpl> originalText() const;
-    virtual void calcPrefWidths();
+    
+    virtual void dirtyLineBoxes(bool, bool);
+    virtual void calcPrefWidths(int leadWidth);
 
     static void destroyCounterNodes(RenderObject*);

trunk/WebCore/rendering/RenderFileUploadControl.cpp

@@ -232 +232 @@
 void RenderFileUploadControl::calcPrefWidths()
 {
+    ASSERT(prefWidthsDirty());
+
     m_minPrefWidth = 0;
     m_maxPrefWidth = 0;

trunk/WebCore/rendering/RenderFlexibleBox.cpp

@@ -120 +120 @@
         }
 
-        int margin=0;
-        //  auto margins don't affect minwidth
-
+        // A margin basically has three types: fixed, percentage, and auto (variable).
+        // Auto and percentage margins simply become 0 when computing min/max width.
+        // Fixed margins can be added in as is.
         Length ml = child->style()->marginLeft();
         Length mr = child->style()->marginRight();
-
-        // Call calcWidth on the child to ensure that our margins are
-        // up to date.  This method can be called before the child has actually
-        // calculated its margins (which are computed inside calcWidth).
-        child->calcWidth();
-
-        if (!ml.isAuto() && !mr.isAuto()) {
-            if (!child->style()->width().isAuto()) {
-                if (child->style()->direction()==LTR)
-                    margin = child->marginLeft();
-                else
-                    margin = child->marginRight();
-            } else
-                margin = child->marginLeft()+child->marginRight();
-        } else if (!ml.isAuto())
-            margin = child->marginLeft();
-        else if (!mr.isAuto())
-            margin = child->marginRight();
-
-        margin = max(margin, 0);
+        int margin = 0, marginLeft = 0, marginRight = 0;
+        if (ml.isFixed())
+            marginLeft += ml.value();
+        if (mr.isFixed())
+            marginRight += mr.value();
+        margin = marginLeft + marginRight;
 
         m_minPrefWidth += child->minPrefWidth() + margin;
@@ -164 +150 @@
         }
 
+        // A margin basically has three types: fixed, percentage, and auto (variable).
+        // Auto/percentage margins simply become 0 when computing min/max width.
+        // Fixed margins can be added in as is.
         Length ml = child->style()->marginLeft();
         Length mr = child->style()->marginRight();
-
-        // Call calcWidth on the child to ensure that our margins are
-        // up to date.  This method can be called before the child has actually
-        // calculated its margins (which are computed inside calcWidth).
-        if (ml.isPercent() || mr.isPercent())
-            calcWidth();
-
-        // A margin basically has three types: fixed, percentage, and auto (variable).
-        // Auto margins simply become 0 when computing min/max width.
-        // Fixed margins can be added in as is.
-        // Percentage margins are computed as a percentage of the width we calculated in
-        // the calcWidth call above.  In this case we use the actual cached margin values on
-        // the RenderObject itself.
         int margin = 0;
         if (ml.isFixed())
             margin += ml.value();
-        else if (ml.isPercent())
-            margin += child->marginLeft();
-
         if (mr.isFixed())
             margin += mr.value();
-        else if (mr.isAuto())
-            margin += child->marginRight();
-
-        margin = max(margin, 0);
         
         int w = child->minPrefWidth() + margin;
@@ -206 +175 @@
     ASSERT(prefWidthsDirty());
 
-    m_minPrefWidth = 0;
-    m_maxPrefWidth = 0;
-
-    if (hasMultipleLines() || isVertical())
-        calcVerticalPrefWidths();
-    else
-        calcHorizontalPrefWidths();
-
-    m_maxPrefWidth = max(m_maxPrefWidth, m_minPrefWidth);
-
     if (style()->width().isFixed() && style()->width().value() > 0)
         m_minPrefWidth = m_maxPrefWidth = calcContentBoxWidth(style()->width().value());
-   
+    else {
+        m_minPrefWidth = m_maxPrefWidth = 0;
+
+        if (hasMultipleLines() || isVertical())
+            calcVerticalPrefWidths();
+        else
+            calcHorizontalPrefWidths();
+
+        m_maxPrefWidth = max(m_minPrefWidth, m_maxPrefWidth);
+    }
+
     if (style()->minWidth().isFixed() && style()->minWidth().value() > 0) {
         m_maxPrefWidth = max(m_maxPrefWidth, calcContentBoxWidth(style()->minWidth().value()));
@@ -239 +208 @@
 {
     ASSERT(needsLayout());
-    ASSERT(!prefWidthsDirty());
 
     if (!relayoutChildren && posChildNeedsLayout() && !normalChildNeedsLayout() && !selfNeedsLayout()) {

trunk/WebCore/rendering/RenderForeignObject.cpp

@@ -86 +86 @@
 {
     ASSERT(needsLayout());
-    ASSERT(!prefWidthsDirty());
 
     IntRect oldBounds;

trunk/WebCore/rendering/RenderFrameSet.cpp

@@ -454 +454 @@
 {
     ASSERT(needsLayout());
-    ASSERT(!prefWidthsDirty());
 
     if (!parent()->isFrameSet()) {

trunk/WebCore/rendering/RenderHTMLCanvas.cpp

@@ -80 +80 @@
 {
     ASSERT(needsLayout());
-    ASSERT(!prefWidthsDirty());
 
     IntRect oldBounds;

trunk/WebCore/rendering/RenderImage.cpp

@@ -304 +304 @@
 {
     ASSERT(needsLayout());
-    ASSERT(!prefWidthsDirty());
 
     IntRect oldBounds;

trunk/WebCore/rendering/RenderInline.cpp

@@ -293 +293 @@
 }
 
-void RenderInline::calcPrefWidths()
-{
-    ASSERT(prefWidthsDirty());
-
-    // Irrelevant, since some enclosing block will actually measure us and our children.
-    m_minPrefWidth = 0;
-    m_maxPrefWidth = 0;
-
-    setPrefWidthsDirty(false);
-}
-
 bool RenderInline::requiresLayer()
 {

trunk/WebCore/rendering/RenderInline.h

@@ -59 +59 @@
     virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, int x, int y, int tx, int ty, HitTestAction);
 
-    virtual void calcPrefWidths();
-
     // overrides RenderObject
     virtual bool requiresLayer();

trunk/WebCore/rendering/RenderListBox.cpp

@@ -119 +119 @@
         m_optionsWidth = static_cast<int>(ceilf(width));
         m_optionsChanged = false;
+        
+        if (!m_vBar && Scrollbar::hasPlatformScrollbars())
+            if (FrameView* view = node()->document()->view()) {
+                RefPtr<PlatformScrollbar> widget = new PlatformScrollbar(this, VerticalScrollbar, SmallScrollbar);
+                view->addChild(widget.get());
+                m_vBar = widget.release();
+            }
+        
         setNeedsLayoutAndPrefWidthsRecalc();
     }
@@ -154 +162 @@
 void RenderListBox::calcPrefWidths()
 {
-    if (!m_vBar && Scrollbar::hasPlatformScrollbars())
-        if (FrameView* view = node()->document()->view()) {
-            RefPtr<PlatformScrollbar> widget = new PlatformScrollbar(this, VerticalScrollbar, SmallScrollbar);
-            view->addChild(widget.get());
-            m_vBar = widget.release();
-        }
-
-    if (m_optionsChanged)
-        updateFromElement();
+    ASSERT(!m_optionsChanged);
 
     m_minPrefWidth = 0;

trunk/WebCore/rendering/RenderListItem.cpp

@@ -175 +175 @@
 }
 
+static RenderObject* firstNonMarkerChild(RenderObject* parent)
+{
+    RenderObject* result = parent->firstChild();
+    while (result && result->isListMarker())
+        result = result->nextSibling();
+    return result;
+}
+
 void RenderListItem::updateMarkerLocation()
 {
@@ -193 +201 @@
 
         if (markerPar != lineBoxParent || m_marker->prefWidthsDirty()) {
+            updateFirstLetter();
             m_marker->remove();
             if (!lineBoxParent)
                 lineBoxParent = this;
-            lineBoxParent->addChild(m_marker, lineBoxParent->firstChild());
+            lineBoxParent->addChild(m_marker, firstNonMarkerChild(lineBoxParent));
             if (m_marker->prefWidthsDirty())
                 m_marker->calcPrefWidths();
-            recalcMinMaxWidths();
         }
     }
@@ -206 +214 @@
 void RenderListItem::calcPrefWidths()
 {
-    // Make sure our marker is in the correct location.
+    ASSERT(prefWidthsDirty());
+    
     updateMarkerLocation();
-    if (prefWidthsDirty())
-        RenderBlock::calcPrefWidths();
+
+    RenderBlock::calcPrefWidths();
 }
 
 void RenderListItem::layout()
 {
-    ASSERT(needsLayout());
-    ASSERT(!prefWidthsDirty());
-    
+    ASSERT(needsLayout()); 
+
     updateMarkerLocation();    
     RenderBlock::layout();

trunk/WebCore/rendering/RenderListMarker.cpp

@@ -627 +627 @@
 {
     ASSERT(needsLayout());
-    if (prefWidthsDirty())
-        calcPrefWidths();
+    ASSERT(!prefWidthsDirty());
+
+    if (isImage()) {
+        m_width = m_image->image()->width();
+        m_height = m_image->image()->height();
+    } else {
+        m_width = minPrefWidth();
+        m_height = style()->font().height();
+    }
+
+    m_marginLeft = m_marginRight = 0;
+
+    Length leftMargin = style()->marginLeft();
+    Length rightMargin = style()->marginRight();
+    if (leftMargin.isFixed())
+        m_marginLeft = leftMargin.value();
+    if (rightMargin.isFixed())
+        m_marginRight = rightMargin.value();
+
     setNeedsLayout(false);
 }
@@ -651 +668 @@
 
     if (isImage()) {
-        m_width = m_image->image()->width();
-        m_height = m_image->image()->height();
-        m_minPrefWidth = m_maxPrefWidth = m_width;
+        m_minPrefWidth = m_maxPrefWidth = m_image->image()->width();
         setPrefWidthsDirty(false);
+        updateMargins();
         return;
     }
@@ -700 +716 @@
     }
 
-    m_width = width;
     m_minPrefWidth = width;
     m_maxPrefWidth = width;
 
-    // FIXME: A little strange to set the height in calcPrefWidths.
-    m_height = font.height();
-
     setPrefWidthsDirty(false);
-}
-
-void RenderListMarker::calcWidth()
-{
-    // m_width is set in calcPrefWidths()
+    
+    updateMargins();
+}
+
+void RenderListMarker::updateMargins()
+{
     const Font& font = style()->font();
+
+    int marginLeft = 0;
+    int marginRight = 0;
 
     if (isInside()) {
         if (isImage()) {
-            if (style()->direction() == LTR) {
-                m_marginLeft = 0;
-                m_marginRight = cMarkerPadding;
-            } else {
-                m_marginLeft = cMarkerPadding;
-                m_marginRight = 0;
-            }
+            if (style()->direction() == LTR)
+                marginRight = cMarkerPadding;
+            else
+                marginLeft = cMarkerPadding;
         } else switch (style()->listStyleType()) {
             case DISC:
@@ -729 +742 @@
             case SQUARE:
                 if (style()->direction() == LTR) {
-                    m_marginLeft = -1;
-                    m_marginRight = font.ascent() - m_width + 1;
+                    marginLeft = -1;
+                    marginRight = font.ascent() - minPrefWidth() + 1;
                 } else {
-                    m_marginLeft = font.ascent() - m_width + 1;
-                    m_marginRight = -1;
+                    marginLeft = font.ascent() - minPrefWidth() + 1;
+                    marginRight = -1;
                 }
                 break;
             default:
-                m_marginLeft = 0;
-                m_marginRight = 0;
+                break;
         }
     } else {
         if (style()->direction() == LTR) {
             if (isImage())
-                m_marginLeft = -m_width - cMarkerPadding;
+                marginLeft = -minPrefWidth() - cMarkerPadding;
             else {
                 int offset = font.ascent() * 2 / 3;
@@ -750 +762 @@
                     case CIRCLE:
                     case SQUARE:
-                        m_marginLeft = -offset - cMarkerPadding - 1;
+                        marginLeft = -offset - cMarkerPadding - 1;
                         break;
                     case LNONE:
-                        m_marginLeft = 0;
                         break;
                     default:
-                        m_marginLeft = m_text.isEmpty() ? 0 : -m_width - offset / 2;
+                        marginLeft = m_text.isEmpty() ? 0 : -minPrefWidth() - offset / 2;
                 }
             }
         } else {
             if (isImage())
-                m_marginLeft = cMarkerPadding;
+                marginLeft = cMarkerPadding;
             else {
                 int offset = font.ascent() * 2 / 3;
@@ -768 +779 @@
                     case CIRCLE:
                     case SQUARE:
-                        m_marginLeft = offset + cMarkerPadding + 1 - m_width;
+                        marginLeft = offset + cMarkerPadding + 1 - minPrefWidth();
                         break;
                     case LNONE:
-                        m_marginLeft = 0;
                         break;
                     default:
-                        m_marginLeft = m_text.isEmpty() ? 0 : offset / 2;
+                        marginLeft = m_text.isEmpty() ? 0 : offset / 2;
                 }
             }
         }
-        m_marginRight = -m_marginLeft - m_width;
-    }
+        marginRight = -marginLeft - minPrefWidth();
+    }
+
+    style()->setMarginLeft(Length(marginLeft, Fixed));
+    style()->setMarginRight(Length(marginRight, Fixed));
 }
 

trunk/WebCore/rendering/RenderListMarker.h

@@ -52 +52 @@
     virtual void imageChanged(CachedImage*);
 
-    virtual void calcWidth();
-
     virtual InlineBox* createInlineBox(bool, bool, bool);
 
@@ -70 +68 @@
     virtual bool canBeSelectionLeaf() const { return true; }
 
+    void updateMargins();
+
 private:
     IntRect getRelativeMarkerRect();
 
-    String m_text;
     CachedImage* m_image;
     RenderListItem* m_listItem;

trunk/WebCore/rendering/RenderObject.cpp

@@ -177 +177 @@
     , m_normalChildNeedsLayout(false)
     , m_posChildNeedsLayout(false)
-    , m_prefWidthsDirty(true)
+    , m_prefWidthsDirty(false)
     , m_floating(false)
     , m_positioned(false)
@@ -183 +183 @@
     , m_paintBackground(false)
     , m_isAnonymous(node == node->document())
-    , m_recalcMinMax(false)
     , m_isText(false)
     , m_inline(true)
     , m_replaced(false)
     , m_isDragging(false)
+    , m_hasLayer(false)
     , m_hasOverflowClip(false)
     , m_hasOverrideSize(false)
@@ -253 +253 @@
 }
 
-RenderObject* RenderObject::removeChildNode(RenderObject*)
+RenderObject* RenderObject::removeChildNode(RenderObject*, bool)
 {
     ASSERT_NOT_REACHED();
@@ -264 +264 @@
 }
 
-void RenderObject::appendChildNode(RenderObject*)
+void RenderObject::moveChildNode(RenderObject*)
 {
     ASSERT_NOT_REACHED();
 }
 
-void RenderObject::insertChildNode(RenderObject*, RenderObject*)
+void RenderObject::appendChildNode(RenderObject*, bool)
+{
+    ASSERT_NOT_REACHED();
+}
+
+void RenderObject::insertChildNode(RenderObject*, RenderObject*, bool)
 {
     ASSERT_NOT_REACHED();
@@ -498 +503 @@
 {
     return 0;
-}
-
-void RenderObject::updateFirstLetter()
-{
 }
 
@@ -653 +654 @@
 void RenderObject::markAllDescendantsWithFloatsForLayout(RenderObject*)
 {
+}
+
+void RenderObject::setPrefWidthsDirty(bool b, bool markParents)
+{
+    bool alreadyDirty = m_prefWidthsDirty;
+    m_prefWidthsDirty = b;
+    if (b && !alreadyDirty && markParents && (style()->position() != FixedPosition && style()->position() != AbsolutePosition))
+        invalidateContainingBlockPrefWidths();
+}
+
+void RenderObject::invalidateContainingBlockPrefWidths()
+{
+    RenderObject* o = containingBlock();
+    while (o && !o->m_prefWidthsDirty) {
+        o->m_prefWidthsDirty = true;
+        if (o->style()->position() == FixedPosition || o->style()->position() == AbsolutePosition)
+            // A positioned object has no effect on the min/max width of its containing block ever.
+            // We can optimize this case and not go up any further.
+            break;
+        o = o->containingBlock();
+    }
 }
 
@@ -1918 +1940 @@
     if (needsLayout())
         ts << "nl ";
-    if (m_recalcMinMax)
-        ts << "rmm ";
     if (style() && style()->zIndex())
         ts << "zI: " << style()->zIndex();
@@ -2707 +2727 @@
 }
 
-void RenderObject::recalcMinMaxWidths()
-{
-    ASSERT(m_recalcMinMax);
-
-    m_recalcMinMax = false;
-    updateFirstLetter();
-
-    RenderObject* child = firstChild();
-    while (child) {
-        int cmin = 0;
-        int cmax = 0;
-        bool test = false;
-        if ((!m_prefWidthsDirty && child->m_recalcMinMax) || child->m_prefWidthsDirty) {
-            cmin = child->minPrefWidth();
-            cmax = child->maxPrefWidth();
-            test = true;
-        }
-        if (child->m_recalcMinMax)
-            child->recalcMinMaxWidths();
-        if (child->m_prefWidthsDirty)
-            child->calcPrefWidths();
-        if (!m_prefWidthsDirty && test && (cmin != child->minPrefWidth() || cmax != child->maxPrefWidth()))
-            m_prefWidthsDirty = true;
-        child = child->nextSibling();
-    }
-
-    // we need to recalculate, if the contains inline children, as the change could have
-    // happened somewhere deep inside the child tree. Also do this for blocks or tables that
-    // are inline (i.e., inline-block and inline-table).
-    if ((!isInline() || isInlineBlockOrInlineTable()) && childrenInline())
-        m_prefWidthsDirty = true;
-
-    if (m_prefWidthsDirty)
-        calcPrefWidths();
-}
-
 void RenderObject::scheduleRelayout()
 {

trunk/WebCore/rendering/RenderObject.h

@@ -154 +154 @@
 
     virtual RenderLayer* layer() const { return 0; }
-    bool hasLayer() const { return !!layer(); }
     RenderLayer* enclosingLayer() const;
     void addLayers(RenderLayer* parentLayer, RenderObject* newObject);
@@ -178 +177 @@
     // children.
     virtual RenderBlock* firstLineBlock() const;
-    virtual void updateFirstLetter();
 
     // Called when an object that was floating or positioned becomes a normal flow object
@@ -207 +205 @@
 
     // raw tree manipulation
-    virtual RenderObject* removeChildNode(RenderObject*);
-    virtual void appendChildNode(RenderObject*);
-    virtual void insertChildNode(RenderObject* child, RenderObject* before);
+    virtual RenderObject* removeChildNode(RenderObject*, bool fullRemove = true);
+    virtual void appendChildNode(RenderObject*, bool fullAppend = true);
+    virtual void insertChildNode(RenderObject* child, RenderObject* before, bool fullInsert = true);
+    // Designed for speed.  Don't waste time doing a bunch of work like layer updating and repainting when we know that our
+    // change in parentage is not going to affect anything.
+    virtual void moveChildNode(RenderObject*);
     //////////////////////////////////////////
 
@@ -311 +312 @@
     bool isDragging() const { return m_isDragging; }
     bool isReplaced() const { return m_replaced; } // a "replaced" element (see CSS)
-
+    
+    bool hasLayer() const { return m_hasLayer; }
+    
     bool hasBoxDecorations() const { return m_paintBackground; }
     bool mustRepaintBackgroundOrBorder() const;
@@ -321 +324 @@
 
     bool prefWidthsDirty() const { return m_prefWidthsDirty; }
-    bool recalcMinMax() const { return m_recalcMinMax; }
 
     bool isSelectionBorder() const;
@@ -370 +372 @@
     void setChildNeedsLayout(bool b, bool markParents = true);
 
-    void setPrefWidthsDirty(bool b)
-    {
-        m_prefWidthsDirty = b;
-        if (b) {
-            RenderObject* o = this;
-            RenderObject* root = this;
-            while(o) { // FIXME: && !o->m_recalcMinMax ) {
-                o->m_recalcMinMax = true;
-                root = o;
-                o = o->m_parent;
-            }
-        }
-    }
-
+    void setPrefWidthsDirty(bool, bool markParents = true);
+    void invalidateContainingBlockPrefWidths();
+    
     void setNeedsLayoutAndPrefWidthsRecalc()
     {
+        setNeedsLayout(true);
         setPrefWidthsDirty(true);
-        setNeedsLayout(true);
     }
 
@@ -398 +389 @@
     void setReplaced(bool b = true) { m_replaced = b; }
     void setHasOverflowClip(bool b = true) { m_hasOverflowClip = b; }
+    void setHasLayer(bool b = true) { m_hasLayer = b; }
 
     void scheduleRelayout();
@@ -460 +452 @@
                                          bool includeLeftEdge = true, bool includeRightEdge = true) { }
 
-    /*
-     * This function calculates the minimum & maximum width that the object
-     * can be set to.
-     *
-     * when the Element calls setPrefWidthsDirty(false), calcPrefWidths() will
-     * be no longer called.
-     *
-     * when a element has a fixed size, m_minPrefWidth and m_maxPrefWidth should be
-     * set to the same value. This has the special meaning that m_width,
-     * contains the actual value.
-     *
-     * assumes calcPrefWidths has already been called for all children.
-     */
-    virtual void calcPrefWidths() { }
-
-    /*
-     * Does the min max width recalculations after changes.
-     */
-    void recalcMinMaxWidths();
-
+    
     /*
      * Calculates the actual width of the object (only for non inline
@@ -923 +896 @@
 
     bool m_isAnonymous               : 1;
-    bool m_recalcMinMax              : 1;
     bool m_isText                    : 1;
     bool m_inline                    : 1;
@@ -929 +901 @@
     bool m_isDragging                : 1;
 
+    bool m_hasLayer                  : 1;
     bool m_hasOverflowClip           : 1;
 

trunk/WebCore/rendering/RenderPartObject.cpp

@@ -246 +246 @@
 {
     ASSERT(needsLayout());
-    ASSERT(!prefWidthsDirty());
 
     calcWidth();

trunk/WebCore/rendering/RenderSVGContainer.cpp

@@ -86 +86 @@
 }
 
-void RenderSVGContainer::calcPrefWidths()
-{
-    ASSERT(prefWidthsDirty());
-    m_minPrefWidth = m_maxPrefWidth = 0;
-    setPrefWidthsDirty(false);
-}
-
 void RenderSVGContainer::layout()
 {
     ASSERT(needsLayout());
-    ASSERT(!prefWidthsDirty());
 
     calcViewport();

trunk/WebCore/rendering/RenderSVGContainer.h

@@ -64 +64 @@
     virtual short baselinePosition(bool b, bool isRootLineBox = false) const;
     
-    virtual void calcPrefWidths();
     virtual void layout();
     virtual void paint(PaintInfo&, int parentX, int parentY);

trunk/WebCore/rendering/RenderSVGHiddenContainer.cpp

@@ -55 +55 @@
 }
 
-void RenderSVGHiddenContainer::calcPrefWidths()
-{
-    ASSERT(prefWidthsDirty());
-    m_minPrefWidth = m_maxPrefWidth = 0;
-    setPrefWidthsDirty(false);
-}
-
 void RenderSVGHiddenContainer::layout()
 {

trunk/WebCore/rendering/RenderSVGHiddenContainer.h

@@ -47 +47 @@
         virtual short baselinePosition(bool b, bool isRootLineBox = false) const;
         
-        virtual void calcPrefWidths();
         virtual void layout();
         virtual void paint(PaintInfo&, int parentX, int parentY);

trunk/WebCore/rendering/RenderSVGText.cpp

@@ -59 +59 @@
 {
     ASSERT(needsLayout());
-    ASSERT(!prefWidthsDirty());
 
     IntRect oldBounds;

trunk/WebCore/rendering/RenderTable.cpp

@@ -234 +234 @@
         // Percent or fixed table
         m_width = style()->width().calcMinValue(availableWidth);
-        m_width = max(m_minPrefWidth, m_width);
+        m_width = max(minPrefWidth(), m_width);
     } else {
         // An auto width table should shrink to fit within the line width if necessary in order to 
@@ -251 +251 @@
         
         // Ensure we aren't bigger than our max width or smaller than our min width.
-        m_width = min(availContentWidth, m_maxPrefWidth);
+        m_width = min(availContentWidth, maxPrefWidth());
     }
     
-    m_width = max(m_width, m_minPrefWidth);
+    m_width = max(m_width, minPrefWidth());
 
     // Finally, with our true width determined, compute our margins for real.
@@ -265 +265 @@
 {
     ASSERT(needsLayout());
-    ASSERT(!prefWidthsDirty());
-    ASSERT(!m_needsSectionRecalc);
 
     if (posChildNeedsLayout() && !normalChildNeedsLayout() && !selfNeedsLayout()) {
@@ -275 +273 @@
     }
 
+    recalcSectionsIfNeeded();
+        
     IntRect oldBounds;
     IntRect oldOutlineBox;
@@ -686 +686 @@
 }
 
-RenderObject* RenderTable::removeChildNode(RenderObject* child)
+RenderObject* RenderTable::removeChildNode(RenderObject* child, bool fullRemove)
 {
     setNeedsSectionRecalc();
-    return RenderContainer::removeChildNode(child);
+    return RenderContainer::removeChildNode(child, fullRemove);
 }
 

trunk/WebCore/rendering/RenderTable.h

@@ -166 +166 @@
     void setNeedsSectionRecalc() { m_needsSectionRecalc = true; }
 
-    virtual RenderObject* removeChildNode(RenderObject*);
+    virtual RenderObject* removeChildNode(RenderObject*, bool fullRemove = true);
 
     RenderTableSection* sectionAbove(const RenderTableSection*, bool skipEmptySections = false) const;

trunk/WebCore/rendering/RenderTableRow.cpp

@@ -113 +113 @@
 {
     ASSERT(needsLayout());
-    ASSERT(!prefWidthsDirty());
 
     for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {

trunk/WebCore/rendering/RenderTableSection.cpp

@@ -1005 +1005 @@
 }
 
-RenderObject* RenderTableSection::removeChildNode(RenderObject* child)
+RenderObject* RenderTableSection::removeChildNode(RenderObject* child, bool fullRemove)
 {
     setNeedsCellRecalc();
-    return RenderContainer::removeChildNode(child);
+    return RenderContainer::removeChildNode(child, fullRemove);
 }
 

trunk/WebCore/rendering/RenderTableSection.h

@@ -122 +122 @@
     int getBaseline(int row) { return m_grid[row].baseLine; }
 
-    virtual RenderObject* removeChildNode(RenderObject*);
+    virtual RenderObject* removeChildNode(RenderObject*, bool fullRemove = true);
 
     virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, int x, int y, int tx, int ty, HitTestAction);

trunk/WebCore/rendering/RenderText.cpp

@@ -436 +436 @@
     }
 
-    if (m_hasTab)
-        calcPrefWidthsInternal(leadWidth);
+    if (m_hasTab || prefWidthsDirty())
+        calcPrefWidths(leadWidth);
 
     minW = m_minWidth;
@@ -495 +495 @@
 }
 
-void RenderText::calcPrefWidths()
-{
-    // Use 0 for the leadWidth. If the text contains a variable width tab, the real width
-    // will get measured when trimmedMinMaxWidth calls again with the real leadWidth.
-    ASSERT(prefWidthsDirty());
-    calcPrefWidthsInternal(0);
-}
-
 inline bool isSpaceAccordingToStyle(UChar c, RenderStyle* style)
 {
@@ -508 +500 @@
 }
 
-void RenderText::calcPrefWidthsInternal(int leadWidth)
-{
+int RenderText::minPrefWidth() const
+{
+    if (prefWidthsDirty())
+        const_cast<RenderText*>(this)->calcPrefWidths(0);
+        
+    return m_minWidth;
+}
+
+int RenderText::maxPrefWidth() const
+{
+    if (prefWidthsDirty())
+        const_cast<RenderText*>(this)->calcPrefWidths(0);
+        
+    return m_maxWidth;
+}
+
+void RenderText::calcPrefWidths(int leadWidth)
+{
+    ASSERT(m_hasTab || prefWidthsDirty());
+
     m_minWidth = 0;
     m_beginMinWidth = 0;
@@ -992 +1002 @@
     if (&f == &style()->font()) {
         if (!style()->preserveNewline() && !from && len == textLength())
-            w = m_maxWidth;
+            w = maxPrefWidth();
         else
             w = widthFromCache(f, from, len, xPos);

trunk/WebCore/rendering/RenderText.h

@@ -76 +76 @@
     virtual short lineHeight(bool firstLine, bool isRootLineBox = false) const;
 
-    virtual void calcPrefWidths();
-    virtual int minPrefWidth() const { return m_minWidth; }
-    virtual int maxPrefWidth() const { return m_maxWidth; }
+    virtual int minPrefWidth() const;
+    virtual int maxPrefWidth() const;
 
     void trimmedPrefWidths(int leadWidth,
@@ -130 +129 @@
 protected:
     void setTextInternal(PassRefPtr<StringImpl>);
+    virtual void calcPrefWidths(int leadWidth);
 
 private:
@@ -139 +139 @@
     void deleteTextBoxes();
     bool containsOnlyWhitespace(unsigned from, unsigned len) const;
-    void calcPrefWidthsInternal(int leadWidth);
-
     int widthFromCache(const Font&, int start, int len, int xPos) const;
     bool isAllASCII() const { return m_isAllASCII; }

trunk/WebCore/rendering/RenderView.cpp

@@ -55 +55 @@
     m_maxPrefWidth = 0;
 
-    setPrefWidthsDirty(true);
+    setPrefWidthsDirty(true, false);
     
     setPositioned(true); // to 0,0 :)
@@ -61 +61 @@
     // Create a new root layer for our layer hierarchy.
     m_layer = new (node->document()->renderArena()) RenderLayer(this);
+    setHasLayer(true);
 }
 
@@ -88 +89 @@
 
     m_maxPrefWidth = m_minPrefWidth;
-
-    setPrefWidthsDirty(false);
 }
 
@@ -95 +94 @@
 {
     if (printing())
-        m_minPrefWidth = m_width;
+        m_minPrefWidth = m_maxPrefWidth = m_width;
 
     bool relayoutChildren = !printing() && (!m_frameView || m_width != m_frameView->visibleWidth() || m_height != m_frameView->visibleHeight());
     if (relayoutChildren)
         setChildNeedsLayout(true, false);
-
-    if (recalcMinMax())
-        recalcMinMaxWidths();
     
     if (needsLayout())

trunk/WebCore/rendering/RenderWidget.cpp

@@ -151 +151 @@
 {
     ASSERT(needsLayout());
-    ASSERT(!prefWidthsDirty());
 
     setNeedsLayout(false);