Revert the merge. Mac build is mysteriously broken.

third_party/WebKit/WebCore/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 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 755 matching lines @@
         if (node && node->hasTagName(formTag) && static_cast<HTMLFormElement*>(node)->isMalformed()) {
             // See if this form is malformed (i.e., unclosed). If so, don't give the form
             // a bottom margin.
             setMaxBottomMargins(0, 0);
         }
     }
 
     // For overflow:scroll blocks, ensure we have both scrollbars in place always.
     if (scrollsOverflow()) {
         if (style()->overflowX() == OSCROLL)
-            layer()->setHasHorizontalScrollbar(true);
+            m_layer->setHasHorizontalScrollbar(true);
         if (style()->overflowY() == OSCROLL)
-            layer()->setHasVerticalScrollbar(true);
+            m_layer->setHasVerticalScrollbar(true);
     }
 
     int repaintTop = 0;
     int repaintBottom = 0;
     int maxFloatBottom = 0;
     if (childrenInline())
         layoutInlineChildren(relayoutChildren, repaintTop, repaintBottom);
     else
         layoutBlockChildren(relayoutChildren, maxFloatBottom);
 
@@ skipping 55 matching lines @@
             m_overflowTop = min(m_overflowTop, reflectionBox().y());
             m_overflowHeight = max(m_overflowHeight, reflectionBox().bottom());
         }
     }
 
     statePusher.pop();
 
     // Update our scroll information if we're overflow:auto/scroll/hidden now that we know if
     // we overflow or not.
     if (hasOverflowClip())
-        layer()->updateScrollInfoAfterLayout();
+        m_layer->updateScrollInfoAfterLayout();
 
     // Repaint with our new bounds if they are different from our old bounds.
     bool didFullRepaint = repainter.repaintAfterLayout();
     if (!didFullRepaint && repaintTop != repaintBottom && (style()->visibility() == VISIBLE || enclosingLayer()->hasVisibleContent())) {
         IntRect repaintRect(m_overflowLeft, repaintTop, m_overflowWidth - m_overflowLeft, repaintBottom - repaintTop);
 
         // FIXME: Deal with multiple column repainting.  We have to split the repaint
         // rect up into multiple rects if it spans columns.
 
         repaintRect.inflate(maximalOutlineSize(PaintPhaseOutline));
@@ skipping 20 matching lines @@
     setNeedsLayout(false);
 }
 
 bool RenderBlock::expandsToEncloseOverhangingFloats() const
 {
     return isInlineBlockOrInlineTable() || isFloatingOrPositioned() || hasOverflowClip() || (parent() && parent()->isFlexibleBox()) || hasColumns() || isTableCell() || isFieldset();
 }
 
 void RenderBlock::adjustPositionedBlock(RenderBox* child, const MarginInfo& marginInfo)
 {
-    if (child->style()->hasStaticX()) {
+    if (child->hasStaticX()) {
         if (style()->direction() == LTR)
-            child->layer()->setStaticX(borderLeft() + paddingLeft());
+            child->setStaticX(borderLeft() + paddingLeft());
         else
-            child->layer()->setStaticX(borderRight() + paddingRight());
-    }
-
-    if (child->style()->hasStaticY()) {
+            child->setStaticX(borderRight() + paddingRight());
+    }
+
+    if (child->hasStaticY()) {
         int y = height();
         if (!marginInfo.canCollapseWithTop()) {
             child->calcVerticalMargins();
             int marginTop = child->marginTop();
             int collapsedTopPos = marginInfo.posMargin();
             int collapsedTopNeg = marginInfo.negMargin();
             if (marginTop > 0) {
                 if (marginTop > collapsedTopPos)
                     collapsedTopPos = marginTop;
             } else {
                 if (-marginTop > collapsedTopNeg)
                     collapsedTopNeg = -marginTop;
             }
             y += (collapsedTopPos - collapsedTopNeg) - marginTop;
         }
-        child->layer()->setStaticY(y);
+        child->setStaticY(y);
     }
 }
 
 void RenderBlock::adjustFloatingBlock(const MarginInfo& marginInfo)
 {
     // The float should be positioned taking into account the bottom margin
     // of the previous flow.  We add that margin into the height, get the
     // float positioned properly, and then subtract the margin out of the
     // height again.  In the case of self-collapsing blocks, we always just
     // use the top margins, since the self-collapsing block collapsed its
@@ skipping 549 matching lines @@
         if (needsLayout())
             return false;
     }
 
     // All we have to is lay out our positioned objects.
     layoutPositionedObjects(false);
 
     statePusher.pop();
 
     if (hasOverflowClip())
-        layer()->updateScrollInfoAfterLayout();
+        m_layer->updateScrollInfoAfterLayout();
 
     setNeedsLayout(false);
     return true;
 }
 
 void RenderBlock::layoutPositionedObjects(bool relayoutChildren)
 {
     if (m_positionedObjects) {
         RenderBox* r;
         Iterator end = m_positionedObjects->end();
         for (Iterator it = m_positionedObjects->begin(); it != end; ++it) {
             r = *it;
             // When a non-positioned block element moves, it may have positioned children that are implicitly positioned relative to the
             // non-positioned block.  Rather than trying to detect all of these movement cases, we just always lay out positioned
             // objects that are positioned implicitly like this.  Such objects are rare, and so in typical DHTML menu usage (where everything is
             // positioned explicitly) this should not incur a performance penalty.
-            if (relayoutChildren || (r->style()->hasStaticY() && r->parent() != this && r->parent()->isBlockFlow()))
+            if (relayoutChildren || (r->hasStaticY() && r->parent() != this && r->parent()->isBlockFlow()))
                 r->setChildNeedsLayout(true, false);
                 
             // If relayoutChildren is set and we have percentage padding, we also need to invalidate the child's pref widths.
             //if (relayoutChildren && (r->style()->paddingLeft().isPercent() || r->style()->paddingRight().isPercent()))
                 r->setPrefWidthsDirty(true, false);
             
             // We don't have to do a full layout.  We just have to update our position. Try that first. If we have shrink-to-fit width
             // and we hit the available width constraint, the layoutIfNeeded() will catch it and do a full layout.
             if (r->needsPositionedMovementLayoutOnly())
                 r->tryLayoutDoingPositionedMovementOnly();
@@ skipping 237 matching lines @@
     }
 
     // We're done.  We don't bother painting any children.
     if (paintPhase == PaintPhaseBlockBackground)
         return;
 
     // Adjust our painting position if we're inside a scrolled layer (e.g., an overflow:auto div).s
     int scrolledX = tx;
     int scrolledY = ty;
     if (hasOverflowClip())
-        layer()->subtractScrolledContentOffset(scrolledX, scrolledY);
+        m_layer->subtractScrolledContentOffset(scrolledX, scrolledY);
 
     // 2. paint contents
     if (paintPhase != PaintPhaseSelfOutline) {
         if (hasColumns())
             paintColumns(paintInfo, scrolledX, scrolledY);
         else
             paintContents(paintInfo, scrolledX, scrolledY);
     }
 
     // 3. paint selection
@@ skipping 181 matching lines @@
     
     if (view() && view()->selectionStart()) {
         Node* startElement = view()->selectionStart()->element();
         if (startElement && startElement->rootEditableElement() == element())
             return true;
     }
     
     return false;
 }
 
-GapRects RenderBlock::selectionGapRectsForRepaint(RenderBoxModelObject* /*repaintContainer*/)
+GapRects RenderBlock::selectionGapRectsForRepaint(RenderBox* /*repaintContainer*/)
 {
     ASSERT(!needsLayout());
 
     if (!shouldPaintSelectionGaps())
         return GapRects();
 
     // FIXME: this is broken with transforms and a non-null repaintContainer
     FloatPoint absContentPoint = localToAbsolute(FloatPoint());
     if (hasOverflowClip())
         absContentPoint -= layer()->scrolledContentOffset();
@@ skipping 982 matching lines @@
     RenderObject* prev = previousSibling();
     while (prev && (!prev->isBox() || !prev->isRenderBlock() || prev->avoidsFloats() || prev->isFloatingOrPositioned())) {
         if (prev->isFloating())
             parentHasFloats = true;
          prev = prev->previousSibling();
     }
 
     // First add in floats from the parent.
     int offset = y();
     if (parentHasFloats) {
-        RenderBlock* parentBlock = toRenderBlock(parent());
+        RenderBlock* parentBlock = static_cast<RenderBlock *>(parent());
         addIntrudingFloats(parentBlock, parentBlock->borderLeft() + parentBlock->paddingLeft(), offset);
     }
     
     int xoffset = 0;
     if (prev)
         offset -= toRenderBox(prev)->y();
     else if (parent()->isBox()) {
         prev = parent();
         xoffset += toRenderBox(prev)->borderLeft() + toRenderBox(prev)->paddingLeft();
     }
 
     // Add overhanging floats from the previous RenderBlock, but only if it has a float that intrudes into our space.
     if (!prev || !prev->isRenderBlock())
         return;
     
-    RenderBlock* block = toRenderBlock(prev);
+    RenderBlock* block = static_cast<RenderBlock *>(prev);
     if (block->m_floatingObjects && block->floatBottom() > offset)
         addIntrudingFloats(block, xoffset, offset);
 
     if (childrenInline()) {
         int changeTop = INT_MAX;
         int changeBottom = INT_MIN;
         if (m_floatingObjects) {
             for (FloatingObject* f = m_floatingObjects->first(); f; f = m_floatingObjects->next()) {
                 FloatingObject* oldFloatingObject = floatMap.get(f->m_renderer);
                 if (oldFloatingObject) {
@@ skipping 245 matching lines @@
         }
         return false;
     }
 
      // If we have lightweight control clipping, then we can't have any spillout. 
     if (!hasControlClip() || controlClipRect(tx, ty).contains(_x, _y)) {
         // Hit test descendants first.
         int scrolledX = tx;
         int scrolledY = ty;
         if (hasOverflowClip())
-            layer()->subtractScrolledContentOffset(scrolledX, scrolledY);
+            m_layer->subtractScrolledContentOffset(scrolledX, scrolledY);
 
         // Hit test contents if we don't have columns.
         if (!hasColumns() && hitTestContents(request, result, _x, _y, scrolledX, scrolledY, hitTestAction))
             return true;
             
         // Hit test our columns if we do have them.
         if (hasColumns() && hitTestColumns(request, result, _x, _y, scrolledX, scrolledY, hitTestAction))
             return true;
 
         // Hit test floats.
@@ skipping 235 matching lines @@
         if (contentsY >= renderer->y() && contentsY < bottom)
             return renderer->positionForCoordinates(contentsX - renderer->x(), contentsY - renderer->y());
     }
     
     return RenderBox::positionForCoordinates(x, y);
 }
 
 void RenderBlock::offsetForContents(int& tx, int& ty) const
 {
     if (hasOverflowClip())
-        layer()->addScrolledContentOffset(tx, ty);
+        m_layer->addScrolledContentOffset(tx, ty);
 
     if (hasColumns()) {
         IntPoint contentsPoint(tx, ty);
         adjustPointToColumnContents(contentsPoint);
         tx = contentsPoint.x();
         ty = contentsPoint.y();
     }
 }
 
 int RenderBlock::availableWidth() const
@@ skipping 292 matching lines @@
             calcInlinePrefWidths();
         else
             calcBlockPrefWidths();
 
         m_maxPrefWidth = max(m_minPrefWidth, m_maxPrefWidth);
 
         if (!style()->autoWrap() && childrenInline()) {
             m_minPrefWidth = m_maxPrefWidth;
             
             // A horizontal marquee with inline children has no minimum width.
-            if (layer() && layer()->marquee() && layer()->marquee()->isHorizontal())
+            if (m_layer && m_layer->marquee() && m_layer->marquee()->isHorizontal())
                 m_minPrefWidth = 0;
         }
 
         if (isTableCell()) {
             Length w = static_cast<const RenderTableCell*>(this)->styleOrColWidth();
             if (w.isFixed() && w.value() > 0)
                 m_maxPrefWidth = max(m_minPrefWidth, calcContentBoxWidth(w.value()));
         }
     }
     
@@ skipping 531 matching lines @@
         // is turned off, checkboxes/radios will still have decent baselines.
         if (style()->hasAppearance() && !theme()->isControlContainer(style()->appearance()))
             return theme()->baselinePosition(this);
             
         // CSS2.1 states that the baseline of an inline block is the baseline of the last line box in
         // the normal flow.  We make an exception for marquees, since their baselines are meaningless
         // (the content inside them moves).  This matches WinIE as well, which just bottom-aligns them.
         // We also give up on finding a baseline if we have a vertical scrollbar, or if we are scrolled
         // vertically (e.g., an overflow:hidden block that has had scrollTop moved) or if the baseline is outside
         // of our content box.
-        int baselinePos = (layer() && (layer()->marquee() || layer()->verticalScrollbar() || layer()->scrollYOffset() != 0)) ? -1 : getBaselineOfLastLineBox();
+        int baselinePos = (m_layer && (m_layer->marquee() || m_layer->verticalScrollbar() || m_layer->scrollYOffset() != 0)) ? -1 : getBaselineOfLastLineBox();
         if (baselinePos != -1 && baselinePos <= borderTop() + paddingTop() + contentHeight())
             return marginTop() + baselinePos;
         return height() + marginTop() + marginBottom();
     }
     return RenderBox::baselinePosition(b, isRootLineBox);
 }
 
 int RenderBlock::getBaselineOfFirstLineBox() const
 {
     if (!isBlockFlow())
@@ skipping 432 matching lines @@
     // shape).
     if (topLevel && inlineContinuation()) {
         FloatRect localRect(0, -collapsedMarginTop(),
                             width(), height() + collapsedMarginTop() + collapsedMarginBottom());
         quads.append(localToAbsoluteQuad(localRect));
         inlineContinuation()->absoluteQuads(quads, topLevel);
     } else
         quads.append(RenderBox::localToAbsoluteQuad(FloatRect(0, 0, width(), height())));
 }
 
-IntRect RenderBlock::rectWithOutlineForRepaint(RenderBoxModelObject* repaintContainer, int outlineWidth)
+IntRect RenderBlock::rectWithOutlineForRepaint(RenderBox* repaintContainer, int outlineWidth)
 {
     IntRect r(RenderBox::rectWithOutlineForRepaint(repaintContainer, outlineWidth));
     if (inlineContinuation())
         r.inflateY(collapsedMarginTop());
     return r;
 }
 
 RenderObject* RenderBlock::hoverAncestor() const
 {
     return inlineContinuation() ? inlineContinuation() : RenderBox::hoverAncestor();
@@ skipping 174 matching lines @@
         return "RenderBlock (generated)";
     if (isRelPositioned())
         return "RenderBlock (relative positioned)";
     if (isRunIn())
         return "RenderBlock (run-in)";
     return "RenderBlock";
 }
 
 } // namespace WebCore