Revert the merge. Mac build is mysteriously broken.

third_party/WebKit/WebCore/rendering/RenderInline.cpp

 /*
  * This file is part of the render object implementation for KHTML.
  *
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006 Apple Computer, Inc.
  *
  * 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 77 matching lines @@
     RenderBox::destroy();
 }
 
 RenderInline* RenderInline::inlineContinuation() const
 {
     if (!m_continuation || m_continuation->isInline())
         return toRenderInline(m_continuation);
     return toRenderBlock(m_continuation)->inlineContinuation();
 }
 
-void RenderInline::updateBoxModelInfoFromStyle()
-{
-    RenderBoxModelObject::updateBoxModelInfoFromStyle();
-
-    setInline(true); // Needed for run-ins, since run-in is considered a block display type.
-
-    // FIXME: Support transforms and reflections on inline flows someday.
-    setHasTransform(false);
-    setHasReflection(false);    
-}
-
 void RenderInline::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
 {
     RenderBox::styleDidChange(diff, oldStyle);
 
+    setInline(true);
+    setHasReflection(false);
+
     // Ensure that all of the split inlines pick up the new style. We
     // only do this if we're an inline, since we don't want to propagate
     // a block's style to the other inlines.
     // e.g., <font>foo <h4>goo</h4> moo</font>.  The <font> inlines before
     // and after the block share the same style, but the block doesn't
     // need to pass its style on to anyone else.
     for (RenderInline* currCont = inlineContinuation(); currCont; currCont = currCont->inlineContinuation()) {
         RenderBox* nextCont = currCont->continuation();
         currCont->setContinuation(0);
         currCont->setStyle(style());
@@ skipping 397 matching lines @@
         }
         result.setWidth(rightSide - leftSide);
         result.setX(leftSide);
         result.setHeight(lastLineBox()->yPos() + lastLineBox()->height() - firstLineBox()->yPos());
         result.setY(firstLineBox()->yPos());
     }
 
     return result;
 }
 
-IntRect RenderInline::clippedOverflowRectForRepaint(RenderBoxModelObject* repaintContainer)
+IntRect RenderInline::clippedOverflowRectForRepaint(RenderBox* repaintContainer)
 {
     // Only run-ins are allowed in here during layout.
     ASSERT(!view() || !view()->layoutStateEnabled() || isRunIn());
 
     if (!firstLineBox() && !continuation())
         return IntRect();
 
     // Find our leftmost position.
     IntRect boundingBox(linesBoundingBox());
     int left = boundingBox.x();
@@ skipping 42 matching lines @@
 
         if (continuation() && !continuation()->isInline()) {
             IntRect contRect = continuation()->rectWithOutlineForRepaint(repaintContainer, ow);
             r.unite(contRect);
         }
     }
 
     return r;
 }
 
-IntRect RenderInline::rectWithOutlineForRepaint(RenderBoxModelObject* repaintContainer, int outlineWidth)
+IntRect RenderInline::rectWithOutlineForRepaint(RenderBox* repaintContainer, int outlineWidth)
 {
     IntRect r(RenderBox::rectWithOutlineForRepaint(repaintContainer, outlineWidth));
     for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
         if (!curr->isText())
             r.unite(curr->rectWithOutlineForRepaint(repaintContainer, outlineWidth));
     }
     return r;
 }
 
 void RenderInline::updateDragState(bool dragOn)
@@ skipping 64 matching lines @@
         if (s != style())
             return s->computedLineHeight();
     }
     
     if (m_lineHeight == -1)
         m_lineHeight = style()->computedLineHeight();
     
     return m_lineHeight;
 }
 
-IntSize RenderInline::relativePositionedInlineOffset(const RenderBox* child) const
+IntSize RenderInline::relativePositionedInlineOffset(const RenderObject* child) const
 {
     ASSERT(isRelPositioned());
     if (!isRelPositioned())
         return IntSize();
 
     // When we have an enclosing relpositioned inline, we need to add in the offset of the first line
     // box from the rest of the content, but only in the cases where we know we're positioned
     // relative to the inline itself.
 
     IntSize offset;
     int sx;
     int sy;
     if (firstLineBox()) {
         sx = firstLineBox()->xPos();
         sy = firstLineBox()->yPos();
     } else {
-        sx = layer()->staticX();
-        sy = layer()->staticY();
+        sx = staticX();
+        sy = staticY();
     }
 
-    if (!child->style()->hasStaticX())
+    if (!child->hasStaticX())
         offset.setWidth(sx);
     // This is not terribly intuitive, but we have to match other browsers.  Despite being a block display type inside
     // an inline, we still keep our x locked to the left of the relative positioned inline.  Arguably the correct
     // behavior would be to go flush left to the block that contains the inline, but that isn't what other browsers
     // do.
     else if (!child->style()->isOriginalDisplayInlineType())
         // Avoid adding in the left border/padding of the containing block twice.  Subtract it out.
         offset.setWidth(sx - (child->containingBlock()->borderLeft() + child->containingBlock()->paddingLeft()));
 
-    if (!child->style()->hasStaticY())
+    if (!child->hasStaticY())
         offset.setHeight(sy);
 
     return offset;
 }
 
 void RenderInline::addFocusRingRects(GraphicsContext* graphicsContext, int tx, int ty)
 {
     for (InlineRunBox* curr = firstLineBox(); curr; curr = curr->nextLineBox())
         graphicsContext->addFocusRingRect(IntRect(tx + curr->xPos(), ty + curr->yPos(), curr->width(), curr->height()));
 
@@ skipping 177 matching lines @@
                 region.clip.scale(pageScaleFactor);
             }
         }
 
         regions.append(region);
     }
 }
 #endif
 
 } // namespace WebCore