WebKit merge 40722:40785 (part 1)

third_party/WebKit/WebCore/rendering/InlineFlowBox.cpp

 /*
  * Copyright (C) 2003, 2004, 2005, 2006, 2007 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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 37 matching lines @@
         for (InlineBox* child = firstChild(); child; child = child->nextOnLine())
             child->setHasBadParent();
 }
 
 #endif
 
 int InlineFlowBox::marginLeft()
 {
     if (!includeLeftEdge())
         return 0;
-    
-    Length margin = object()->style()->marginLeft();
-    if (margin.isAuto())
-        return 0;
-    if (margin.isFixed())
-        return margin.value();
-    return renderBox()->marginLeft();
+    return boxModelObject()->marginLeft();
 }
 
 int InlineFlowBox::marginRight()
 {
     if (!includeRightEdge())
         return 0;
-    
-    Length margin = object()->style()->marginRight();
-    if (margin.isAuto())
-        return 0;
-    if (margin.isFixed())
-        return margin.value();
-    return renderBox()->marginRight();
+    return boxModelObject()->marginRight();
 }
 
 int InlineFlowBox::marginBorderPaddingLeft()
 {
     return marginLeft() + borderLeft() + paddingLeft();
 }
 
 int InlineFlowBox::marginBorderPaddingRight()
 {
     return marginRight() + borderRight() + paddingRight();
@@ skipping 235 matching lines @@
             
             int visualOverflowLeft = leftGlyphOverflow;
             int visualOverflowRight = rightGlyphOverflow;
             for (ShadowData* shadow = rt->style()->textShadow(); shadow; shadow = shadow->next) {
                 visualOverflowLeft = min(visualOverflowLeft, shadow->x - shadow->blur + leftGlyphOverflow);
                 visualOverflowRight = max(visualOverflowRight, shadow->x + shadow->blur + rightGlyphOverflow);
             }
             
             leftPosition = min(x + visualOverflowLeft, leftPosition);
             rightPosition = max(x + text->width() + visualOverflowRight, rightPosition);
-            m_maxHorizontalVisualOverflow = max(max(visualOverflowRight, -visualOverflowLeft), m_maxHorizontalVisualOverflow);
+            m_maxHorizontalVisualOverflow = max(max(visualOverflowRight, -visualOverflowLeft), (int)m_maxHorizontalVisualOverflow);
             x += text->width();
         } else {
             if (curr->object()->isPositioned()) {
                 if (curr->object()->parent()->style()->direction() == LTR)
                     curr->setXPos(x);
                 else
                     // Our offset that we cache needs to be from the edge of the right border box and
                     // not the left border box.  We have to subtract |x| from the width of the block
                     // (which can be obtained from the root line box).
                     curr->setXPos(root()->block()->width()-x);
                 continue; // The positioned object has no effect on the width.
             }
             if (curr->object()->isRenderInline()) {
                 InlineFlowBox* flow = static_cast<InlineFlowBox*>(curr);
                 x += flow->marginLeft();
                 x = flow->placeBoxesHorizontally(x, leftPosition, rightPosition, needsWordSpacing);
                 x += flow->marginRight();
             } else if (!curr->object()->isListMarker() || static_cast<RenderListMarker*>(curr->object())->isInside()) {
-                x += curr->renderBox()->marginLeft();
+                x += curr->boxModelObject()->marginLeft();
                 curr->setXPos(x);
-                leftPosition = min(x + curr->renderBox()->overflowLeft(false), leftPosition);
-                rightPosition = max(x + curr->renderBox()->overflowWidth(false), rightPosition);
-                x += curr->width() + curr->renderBox()->marginRight();
+                leftPosition = min(x + toRenderBox(curr->object())->overflowLeft(false), leftPosition);
+                rightPosition = max(x + toRenderBox(curr->object())->overflowWidth(false), rightPosition);
+                x += curr->width() + curr->boxModelObject()->marginRight();
             }
         }
     }
 
     x += borderRight() + paddingRight();
     setWidth(x - startX);
     rightPosition = max(xPos() + width() + boxShadowRight, rightPosition);
 
     return x;
 }
@@ skipping 83 matching lines @@
                 maxAscent = ascent;
             if (maxDescent < descent)
                 maxDescent = descent;
         }
     }
     
     for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
         if (curr->object()->isPositioned())
             continue; // Positioned placeholders don't affect calculations.
         
+        bool isInlineFlow = curr->isInlineFlowBox();
+
         curr->setHeight(curr->object()->lineHeight(m_firstLine));
         curr->setBaseline(curr->object()->baselinePosition(m_firstLine));
         curr->setYPos(curr->object()->verticalPositionHint(m_firstLine));
         if (curr->yPos() == PositionTop) {
             if (maxPositionTop < curr->height())
                 maxPositionTop = curr->height();
         }
         else if (curr->yPos() == PositionBottom) {
             if (maxPositionBottom < curr->height())
                 maxPositionBottom = curr->height();
         }
-        else if (curr->hasTextChildren() || curr->renderBox()->hasHorizontalBordersOrPadding() || strictMode) {
+        else if ((!isInlineFlow || static_cast<InlineFlowBox*>(curr)->hasTextChildren()) || curr->boxModelObject()->hasHorizontalBordersOrPadding() || strictMode) {
             int ascent = curr->baseline() - curr->yPos();
             int descent = curr->height() - ascent;
             if (maxAscent < ascent)
                 maxAscent = ascent;
             if (maxDescent < descent)
                 maxDescent = descent;
         }
 
         if (curr->isInlineFlowBox())
             static_cast<InlineFlowBox*>(curr)->computeLogicalBoxHeights(maxPositionTop, maxPositionBottom, maxAscent, maxDescent, strictMode);
     }
 }
 
 void InlineFlowBox::placeBoxesVertically(int y, int maxHeight, int maxAscent, bool strictMode,
                                          int& topPosition, int& bottomPosition, int& selectionTop, int& selectionBottom)
 {
     if (isRootInlineBox())
         setYPos(y + maxAscent - baseline());// Place our root box.
     
     for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
         if (curr->object()->isPositioned())
             continue; // Positioned placeholders don't affect calculations.
         
         // Adjust boxes to use their real box y/height and not the logical height (as dictated by
         // line-height).
-        if (curr->isInlineFlowBox())
+        bool isInlineFlow = curr->isInlineFlowBox();
+        if (isInlineFlow)
             static_cast<InlineFlowBox*>(curr)->placeBoxesVertically(y, maxHeight, maxAscent, strictMode, topPosition, bottomPosition, selectionTop, selectionBottom);
 
         bool childAffectsTopBottomPos = true;
         if (curr->yPos() == PositionTop)
             curr->setYPos(y);
         else if (curr->yPos() == PositionBottom)
             curr->setYPos(y + maxHeight - curr->height());
         else {
-            if (!curr->hasTextChildren() && !curr->renderBox()->hasHorizontalBordersOrPadding() && !strictMode)
+            if ((isInlineFlow && !static_cast<InlineFlowBox*>(curr)->hasTextChildren()) && !curr->boxModelObject()->hasHorizontalBordersOrPadding() && !strictMode)
                 childAffectsTopBottomPos = false;
             curr->setYPos(curr->yPos() + y + maxAscent - curr->baseline());
         }
         
         int newY = curr->yPos();
         int newHeight = curr->height();
         int newBaseline = curr->baseline();
         int overflowTop = 0;
         int overflowBottom = 0;
         if (curr->isText() || curr->isInlineFlowBox()) {
@@ skipping 10 matching lines @@
                 overflowTop = min(overflowTop, boxShadow->y - boxShadow->blur);
                 overflowBottom = max(overflowBottom, boxShadow->y + boxShadow->blur);
             }
 
             for (ShadowData* textShadow = curr->object()->style(m_firstLine)->textShadow(); textShadow; textShadow = textShadow->next) {
                 overflowTop = min(overflowTop, textShadow->y - textShadow->blur);
                 overflowBottom = max(overflowBottom, textShadow->y + textShadow->blur);
             }
 
             if (curr->object()->hasReflection()) {
-                overflowTop = min(overflowTop, curr->renderBox()->reflectionBox().y());
-                overflowBottom = max(overflowBottom, curr->renderBox()->reflectionBox().bottom());
+                RenderBox* box = toRenderBox(curr->object());
+                overflowTop = min(overflowTop, box->reflectionBox().y());
+                overflowBottom = max(overflowBottom, box->reflectionBox().bottom());
             }
 
             if (curr->isInlineFlowBox()) {
-                newHeight += curr->renderBox()->borderTop() + curr->renderBox()->paddingTop() +
-                            curr->renderBox()->borderBottom() + curr->renderBox()->paddingBottom();
-                newY -= curr->renderBox()->borderTop() + curr->renderBox()->paddingTop();
-                newBaseline += curr->renderBox()->borderTop() + curr->renderBox()->paddingTop();
+                newHeight += curr->boxModelObject()->borderTop() + curr->boxModelObject()->paddingTop() +
+                            curr->boxModelObject()->borderBottom() + curr->boxModelObject()->paddingBottom();
+                newY -= curr->boxModelObject()->borderTop() + curr->boxModelObject()->paddingTop();
+                newBaseline += curr->boxModelObject()->borderTop() + curr->boxModelObject()->paddingTop();
             }
         } else if (!curr->object()->isBR()) {
-            newY += curr->renderBox()->marginTop();
-            newHeight = curr->height() - (curr->renderBox()->marginTop() + curr->renderBox()->marginBottom());
-            overflowTop = curr->renderBox()->overflowTop(false);
-            overflowBottom = curr->renderBox()->overflowHeight(false) - newHeight;
+            RenderBox* box = toRenderBox(curr->object());
+            newY += box->marginTop();
+            newHeight = curr->height() - (box->marginTop() + box->marginBottom());
+            overflowTop = box->overflowTop(false);
+            overflowBottom = box->overflowHeight(false) - newHeight;
         }
 
         curr->setYPos(newY);
         curr->setHeight(newHeight);
         curr->setBaseline(newBaseline);
 
         if (childAffectsTopBottomPos) {
             selectionTop = min(selectionTop, newY);
             selectionBottom = max(selectionBottom, newY + newHeight);
             topPosition = min(topPosition, newY + overflowTop);
@@ skipping 18 matching lines @@
     // First shrink our kids.
     for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
         if (curr->object()->isPositioned())
             continue; // Positioned placeholders don't affect calculations.
         
         if (curr->isInlineFlowBox())
             static_cast<InlineFlowBox*>(curr)->shrinkBoxesWithNoTextChildren(topPos, bottomPos);
     }
 
     // See if we have text children. If not, then we need to shrink ourselves to fit on the line.
-    if (!hasTextChildren() && !renderBox()->hasHorizontalBordersOrPadding()) {
+    if (!hasTextChildren() && !boxModelObject()->hasHorizontalBordersOrPadding()) {
         if (yPos() < topPos)
             setYPos(topPos);
         if (yPos() + height() > bottomPos)
             setHeight(bottomPos - yPos());
         if (baseline() > height())
             setBaseline(height());
     }
 }
 
 bool InlineFlowBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, int x, int y, int tx, int ty)
@@ skipping 467 matching lines @@
         ASSERT(child->prevOnLine() == prev);
         prev = child;
     }
     ASSERT(prev == m_lastChild);
 #endif
 }
 
 #endif
 
 } // namespace WebCore