Get rid of isWritingModeRoot.

sky/engine/core/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, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. 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
@@ skipping 1065 matching lines @@
     RenderBox* positionedObject;
     TrackedRendererListHashSet::iterator end = positionedDescendants->end();
     for (TrackedRendererListHashSet::iterator it = positionedDescendants->begin(); it != end; ++it) {
         positionedObject = *it;
         addOverflowFromChild(positionedObject, LayoutSize(positionedObject->x(), positionedObject->y()));
     }
 }
 
 bool RenderBlock::createsBlockFormattingContext() const
 {
-    return isInlineBlock() || isFloatingOrOutOfFlowPositioned() || hasOverflowClip() || isFlexItemIncludingDeprecated()
-        || isWritingModeRoot() || isDocumentElement();
+    return isInlineBlock() || isFloatingOrOutOfFlowPositioned() || hasOverflowClip() || isFlexItemIncludingDeprecated() || isDocumentElement();
 }
 
 void RenderBlock::updateBlockChildDirtyBitsBeforeLayout(bool relayoutChildren, RenderBox* child)
 {
     // FIXME: Technically percentage height objects only need a relayout if their percentage isn't going to be turned into
     // an auto value. Add a method to determine this, so that we can avoid the relayout.
     if (relayoutChildren || (child->hasRelativeLogicalHeight() && !isRenderView()))
         child->setChildNeedsLayout(MarkOnlyThis);
 
     // If relayoutChildren is set and the child has percentage padding or an embedded content box, we also need to invalidate the childs pref widths.
@@ skipping 437 matching lines @@
     return selectionState() != SelectionNone && isSelectionRoot();
 }
 
 bool RenderBlock::isSelectionRoot() const
 {
     ASSERT(node() || isAnonymous());
 
     if (isDocumentElement() || hasOverflowClip()
         || isPositioned() || isFloating()
         || isInlineBlock()
-        || hasTransform() || hasMask() || isWritingModeRoot()
+        || hasTransform() || hasMask()
         || isFlexItemIncludingDeprecated())
         return true;
 
     if (view() && view()->selectionStart()) {
         Node* startElement = view()->selectionStart()->node();
         if (startElement && startElement->rootEditableElement() == node())
             return true;
     }
 
     return false;
@@ skipping 1008 matching lines @@
     // the base class.  If we're being queried as though we're the root line
     // box, then the fact that we're an inline-block is irrelevant, and we behave
     // just like a block.
     if (isInline() && linePositionMode == PositionOnContainingLine) {
         // 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).
         bool ignoreBaseline = (layer() && layer()->scrollableArea() && ((direction == HorizontalLine ? (layer()->scrollableArea()->verticalScrollbar() || layer()->scrollableArea()->scrollYOffset())
-            : (layer()->scrollableArea()->horizontalScrollbar() || layer()->scrollableArea()->scrollXOffset())))) || isWritingModeRoot();
+            : (layer()->scrollableArea()->horizontalScrollbar() || layer()->scrollableArea()->scrollXOffset()))));
 
         int baselinePos = ignoreBaseline ? -1 : inlineBlockBaseline(direction);
 
         if (baselinePos != -1)
             return beforeMarginInLineDirection(direction) + baselinePos;
 
         return RenderBox::baselinePosition(baselineType, firstLine, direction, linePositionMode);
     }
 
     // If we're not replaced, we'll only get called with PositionOfInteriorLineBoxes.
     // Note that inline-block counts as replaced here.
     ASSERT(linePositionMode == PositionOfInteriorLineBoxes);
 
     const FontMetrics& fontMetrics = style(firstLine)->fontMetrics();
     return fontMetrics.ascent(baselineType) + (lineHeight(firstLine, direction, linePositionMode) - fontMetrics.height()) / 2;
 }
 
 LayoutUnit RenderBlock::minLineHeightForReplacedRenderer(bool isFirstLine, LayoutUnit replacedHeight) const
 {
     if (!(style(isFirstLine)->lineBoxContain() & LineBoxContainBlock))
         return 0;
 
     return std::max<LayoutUnit>(replacedHeight, lineHeight(isFirstLine, HorizontalLine, PositionOfInteriorLineBoxes));
 }
 
 int RenderBlock::firstLineBoxBaseline() const
 {
-    if (isWritingModeRoot())
-        return -1;
-
     if (childrenInline()) {
         if (firstLineBox())
             return firstLineBox()->logicalTop() + style(true)->fontMetrics().ascent(firstRootBox()->baselineType());
         else
             return -1;
     }
     else {
         for (RenderBox* curr = firstChildBox(); curr; curr = curr->nextSiblingBox()) {
             if (!curr->isFloatingOrOutOfFlowPositioned()) {
                 int result = curr->firstLineBoxBaseline();
@@ skipping 11 matching lines @@
     if (!style()->isOverflowVisible()) {
         // We are not calling RenderBox::baselinePosition here because the caller should add the margin-top/margin-right, not us.
         return direction == HorizontalLine ? height() + m_marginBox.bottom() : width() + m_marginBox.left();
     }
 
     return lastLineBoxBaseline(direction);
 }
 
 int RenderBlock::lastLineBoxBaseline(LineDirectionMode lineDirection) const
 {
-    if (isWritingModeRoot())
-        return -1;
-
     if (childrenInline()) {
         if (!firstLineBox() && hasLineIfEmpty()) {
             const FontMetrics& fontMetrics = firstLineStyle()->fontMetrics();
             return fontMetrics.ascent()
                  + (lineHeight(true, lineDirection, PositionOfInteriorLineBoxes) - fontMetrics.height()) / 2
                  + (lineDirection == HorizontalLine ? borderTop() + paddingTop() : borderRight() + paddingRight());
         }
         if (lastLineBox())
             return lastLineBox()->logicalTop() + style(lastLineBox() == firstLineBox())->fontMetrics().ascent(lastRootBox()->baselineType());
         return -1;
@@ skipping 278 matching lines @@
     }
 }
 
 RenderBox* RenderBlock::createAnonymousBoxWithSameTypeAs(const RenderObject* parent) const
 {
     return createAnonymousWithParentRendererAndDisplay(parent, style()->display());
 }
 
 LayoutUnit RenderBlock::collapsedMarginBeforeForChild(const RenderBox* child) const
 {
-    // If the child has the same directionality as we do, then we can just return its
-    // collapsed margin.
-    if (!child->isWritingModeRoot())
-        return child->collapsedMarginBefore();
-    return child->collapsedMarginAfter();
+    // FIXME(sky): Remove
+    return child->collapsedMarginBefore();
 }
 
 LayoutUnit RenderBlock::collapsedMarginAfterForChild(const  RenderBox* child) const
 {
-    // If the child has the same directionality as we do, then we can just return its
-    // collapsed margin.
-    if (!child->isWritingModeRoot())
-        return child->collapsedMarginAfter();
-    return child->collapsedMarginBefore();
+    // FIXME(sky): Remove
+    return child->collapsedMarginAfter();
 }
 
 bool RenderBlock::hasMarginBeforeQuirk(const RenderBox* child) const
 {
-    // If the child has the same directionality as we do, then we can just return its
-    // margin quirk.
-    if (!child->isWritingModeRoot())
-        return child->isRenderBlock() ? toRenderBlock(child)->hasMarginBeforeQuirk() : child->style()->hasMarginBeforeQuirk();
-
-    return child->isRenderBlock() ? toRenderBlock(child)->hasMarginAfterQuirk() : child->style()->hasMarginAfterQuirk();
+    return child->isRenderBlock() ? toRenderBlock(child)->hasMarginBeforeQuirk() : child->style()->hasMarginBeforeQuirk();
 }
 
 bool RenderBlock::hasMarginAfterQuirk(const RenderBox* child) const
 {
-    // If the child has the same directionality as we do, then we can just return its
-    // margin quirk.
-    if (!child->isWritingModeRoot())
-        return child->isRenderBlock() ? toRenderBlock(child)->hasMarginAfterQuirk() : child->style()->hasMarginAfterQuirk();
-
-    return child->isRenderBlock() ? toRenderBlock(child)->hasMarginBeforeQuirk() : child->style()->hasMarginBeforeQuirk();
+    return child->isRenderBlock() ? toRenderBlock(child)->hasMarginAfterQuirk() : child->style()->hasMarginAfterQuirk();
 }
 
 const char* RenderBlock::renderName() const
 {
     if (isFloating())
         return "RenderBlock (floating)";
     if (isOutOfFlowPositioned())
         return "RenderBlock (positioned)";
     if (isAnonymousBlock())
         return "RenderBlock (anonymous)";
@@ skipping 130 matching lines @@
 void RenderBlock::showLineTreeAndMark(const InlineBox* markedBox1, const char* markedLabel1, const InlineBox* markedBox2, const char* markedLabel2, const RenderObject* obj) const
 {
     showRenderObject();
     for (const RootInlineBox* root = firstRootBox(); root; root = root->nextRootBox())
         root->showLineTreeAndMark(markedBox1, markedLabel1, markedBox2, markedLabel2, obj, 1);
 }
 
 #endif
 
 } // namespace blink