First pass at removing dead vertical writing mode code.

sky/engine/core/rendering/RenderBlockFlow.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 327 matching lines @@
     if (style()->textAlign() == WEBKIT_CENTER || child->style()->marginStartUsing(style()).isAuto())
         newPosition = std::max(newPosition, positionToAvoidFloats + childMarginStart);
     else if (positionToAvoidFloats > initialStartPosition)
         newPosition = std::max(newPosition, positionToAvoidFloats);
 
     setLogicalLeftForChild(child, style()->isLeftToRightDirection() ? newPosition : totalAvailableLogicalWidth - newPosition - logicalWidthForChild(child));
 }
 
 void RenderBlockFlow::setLogicalLeftForChild(RenderBox* child, LayoutUnit logicalLeft)
 {
-    if (isHorizontalWritingMode()) {
-        child->setX(logicalLeft);
-    } else {
-        child->setY(logicalLeft);
-    }
+    child->setX(logicalLeft);
 }
 
 void RenderBlockFlow::setLogicalTopForChild(RenderBox* child, LayoutUnit logicalTop)
 {
-    if (isHorizontalWritingMode()) {
-        child->setY(logicalTop);
-    } else {
-        child->setX(logicalTop);
-    }
+    child->setY(logicalTop);
 }
 
 void RenderBlockFlow::layoutBlockChild(RenderBox* child, MarginInfo& marginInfo, LayoutUnit& previousFloatLogicalBottom)
 {
     LayoutUnit oldPosMarginBefore = maxPositiveMarginBefore();
     LayoutUnit oldNegMarginBefore = maxNegativeMarginBefore();
 
     // The child is a normal flow object. Compute the margins we will use for collapsing now.
     child->computeAndSetBlockDirectionMargins(this);
 
@@ skipping 187 matching lines @@
     LayoutUnit childBeforePositive = 0;
     LayoutUnit childBeforeNegative = 0;
     LayoutUnit childAfterPositive = 0;
     LayoutUnit childAfterNegative = 0;
 
     LayoutUnit beforeMargin = 0;
     LayoutUnit afterMargin = 0;
 
     RenderBlockFlow* childRenderBlockFlow = child->isRenderBlockFlow() ? toRenderBlockFlow(child) : 0;
 
-    // If the child has the same directionality as we do, then we can just return its
-    // margins in the same direction.
-    if (!child->isWritingModeRoot()) {
-        if (childRenderBlockFlow) {
-            childBeforePositive = childRenderBlockFlow->maxPositiveMarginBefore();
-            childBeforeNegative = childRenderBlockFlow->maxNegativeMarginBefore();
-            childAfterPositive = childRenderBlockFlow->maxPositiveMarginAfter();
-            childAfterNegative = childRenderBlockFlow->maxNegativeMarginAfter();
-        } else {
-            beforeMargin = child->marginBefore();
-            afterMargin = child->marginAfter();
-        }
-    } else if (child->isHorizontalWritingMode() == isHorizontalWritingMode()) {
-        // The child has a different directionality. If the child is parallel, then it's just
-        // flipped relative to us. We can use the margins for the opposite edges.
-        if (childRenderBlockFlow) {
-            childBeforePositive = childRenderBlockFlow->maxPositiveMarginAfter();
-            childBeforeNegative = childRenderBlockFlow->maxNegativeMarginAfter();
-            childAfterPositive = childRenderBlockFlow->maxPositiveMarginBefore();
-            childAfterNegative = childRenderBlockFlow->maxNegativeMarginBefore();
-        } else {
-            beforeMargin = child->marginAfter();
-            afterMargin = child->marginBefore();
-        }
+    if (childRenderBlockFlow) {
+        childBeforePositive = childRenderBlockFlow->maxPositiveMarginBefore();
+        childBeforeNegative = childRenderBlockFlow->maxNegativeMarginBefore();
+        childAfterPositive = childRenderBlockFlow->maxPositiveMarginAfter();
+        childAfterNegative = childRenderBlockFlow->maxNegativeMarginAfter();
     } else {
-        // The child is perpendicular to us, which means its margins don't collapse but are on the
-        // "logical left/right" sides of the child box. We can just return the raw margin in this case.
-        beforeMargin = marginBeforeForChild(child);
-        afterMargin = marginAfterForChild(child);
+        beforeMargin = child->marginBefore();
+        afterMargin = child->marginAfter();
     }
 
     // Resolve uncollapsing margins into their positive/negative buckets.
     if (beforeMargin) {
         if (beforeMargin > 0)
             childBeforePositive = beforeMargin;
         else
             childBeforeNegative = -beforeMargin;
     }
     if (afterMargin) {
@@ skipping 151 matching lines @@
         bool logicalTopIntrudesIntoFloat = clearanceForSelfCollapsingBlock > 0 && logicalTop < beforeCollapseLogicalTop;
         if (logicalTopIntrudesIntoFloat && containsFloats() && !child->avoidsFloats() && lowestFloatLogicalBottom() > logicalTop)
             child->setNeedsLayoutAndFullPaintInvalidation();
     }
 
     return logicalTop;
 }
 
 void RenderBlockFlow::adjustPositionedBlock(RenderBox* child, const MarginInfo& marginInfo)
 {
-    bool isHorizontal = isHorizontalWritingMode();
-    bool hasStaticBlockPosition = child->style()->hasStaticBlockPosition(isHorizontal);
+    bool hasStaticBlockPosition = child->style()->hasStaticBlockPosition();
 
     LayoutUnit logicalTop = logicalHeight();
     updateStaticInlinePositionForChild(child, logicalTop);
 
     if (!marginInfo.canCollapseWithMarginBefore()) {
         // Positioned blocks don't collapse margins, so add the margin provided by
         // the container now. The child's own margin is added later when calculating its logical top.
         LayoutUnit collapsedBeforePos = marginInfo.positiveMargin();
         LayoutUnit collapsedBeforeNeg = marginInfo.negativeMargin();
         logicalTop += collapsedBeforePos - collapsedBeforeNeg;
@@ skipping 270 matching lines @@
 }
 
 bool RenderBlockFlow::mustDiscardMarginAfter() const
 {
     return style()->marginAfterCollapse() == MDISCARD || (m_rareData && m_rareData->m_discardMarginAfter);
 }
 
 bool RenderBlockFlow::mustDiscardMarginBeforeForChild(const RenderBox* child) const
 {
     ASSERT(!child->selfNeedsLayout());
-    if (!child->isWritingModeRoot())
-        return child->isRenderBlockFlow() ? toRenderBlockFlow(child)->mustDiscardMarginBefore() : (child->style()->marginBeforeCollapse() == MDISCARD);
-    if (child->isHorizontalWritingMode() == isHorizontalWritingMode())
-        return child->isRenderBlockFlow() ? toRenderBlockFlow(child)->mustDiscardMarginAfter() : (child->style()->marginAfterCollapse() == MDISCARD);
-
-    // FIXME: We return false here because the implementation is not geometrically complete. We have values only for before/after, not start/end.
-    // In case the boxes are perpendicular we assume the property is not specified.
-    return false;
+    return child->isRenderBlockFlow() ? toRenderBlockFlow(child)->mustDiscardMarginBefore() : (child->style()->marginBeforeCollapse() == MDISCARD);
 }
 
 bool RenderBlockFlow::mustDiscardMarginAfterForChild(const RenderBox* child) const
 {
     ASSERT(!child->selfNeedsLayout());
-    if (!child->isWritingModeRoot())
-        return child->isRenderBlockFlow() ? toRenderBlockFlow(child)->mustDiscardMarginAfter() : (child->style()->marginAfterCollapse() == MDISCARD);
-    if (child->isHorizontalWritingMode() == isHorizontalWritingMode())
-        return child->isRenderBlockFlow() ? toRenderBlockFlow(child)->mustDiscardMarginBefore() : (child->style()->marginBeforeCollapse() == MDISCARD);
-
-    // FIXME: See |mustDiscardMarginBeforeForChild| above.
-    return false;
+    return child->isRenderBlockFlow() ? toRenderBlockFlow(child)->mustDiscardMarginAfter() : (child->style()->marginAfterCollapse() == MDISCARD);
 }
 
 void RenderBlockFlow::setMaxMarginBeforeValues(LayoutUnit pos, LayoutUnit neg)
 {
     if (!m_rareData) {
         if (pos == RenderBlockFlowRareData::positiveMarginBeforeDefault(this) && neg == RenderBlockFlowRareData::negativeMarginBeforeDefault(this))
             return;
         m_rareData = adoptPtr(new RenderBlockFlowRareData(this));
     }
     m_rareData->m_margins.setPositiveMarginBefore(pos);
@@ skipping 10 matching lines @@
     m_rareData->m_margins.setPositiveMarginAfter(pos);
     m_rareData->m_margins.setNegativeMarginAfter(neg);
 }
 
 bool RenderBlockFlow::mustSeparateMarginBeforeForChild(const RenderBox* child) const
 {
     ASSERT(!child->selfNeedsLayout());
     const RenderStyle* childStyle = child->style();
     if (!child->isWritingModeRoot())
         return childStyle->marginBeforeCollapse() == MSEPARATE;
-    if (child->isHorizontalWritingMode() == isHorizontalWritingMode())
-        return childStyle->marginAfterCollapse() == MSEPARATE;
-
-    // FIXME: See |mustDiscardMarginBeforeForChild| above.
-    return false;
+    return childStyle->marginAfterCollapse() == MSEPARATE;
 }
 
 bool RenderBlockFlow::mustSeparateMarginAfterForChild(const RenderBox* child) const
 {
     ASSERT(!child->selfNeedsLayout());
     const RenderStyle* childStyle = child->style();
     if (!child->isWritingModeRoot())
         return childStyle->marginAfterCollapse() == MSEPARATE;
-    if (child->isHorizontalWritingMode() == isHorizontalWritingMode())
-        return childStyle->marginBeforeCollapse() == MSEPARATE;
-
-    // FIXME: See |mustDiscardMarginBeforeForChild| above.
-    return false;
+    return childStyle->marginBeforeCollapse() == MSEPARATE;
 }
 
 void RenderBlockFlow::addOverflowFromFloats()
 {
     // FIXME(sky): Remove this.
 }
 
 void RenderBlockFlow::computeOverflow(LayoutUnit oldClientAfterEdge, bool recomputeFloats)
 {
     RenderBlock::computeOverflow(oldClientAfterEdge, recomputeFloats);
@@ skipping 84 matching lines @@
     LayoutUnit paintInvalidationLogicalLeft = logicalLeftVisualOverflow();
     LayoutUnit paintInvalidationLogicalRight = logicalRightVisualOverflow();
     if (hasOverflowClip()) {
         // If we have clipped overflow, we should use layout overflow as well, since visual overflow from lines didn't propagate to our block's overflow.
         // Note the old code did this as well but even for overflow:visible. The addition of hasOverflowClip() at least tightens up the hack a bit.
         // layoutInlineChildren should be patched to compute the entire paint invalidation rect.
         paintInvalidationLogicalLeft = std::min(paintInvalidationLogicalLeft, logicalLeftLayoutOverflow());
         paintInvalidationLogicalRight = std::max(paintInvalidationLogicalRight, logicalRightLayoutOverflow());
     }
 
-    LayoutRect paintInvalidationRect;
-    if (isHorizontalWritingMode())
-        paintInvalidationRect = LayoutRect(paintInvalidationLogicalLeft, m_paintInvalidationLogicalTop, paintInvalidationLogicalRight - paintInvalidationLogicalLeft, m_paintInvalidationLogicalBottom - m_paintInvalidationLogicalTop);
-    else
-        paintInvalidationRect = LayoutRect(m_paintInvalidationLogicalTop, paintInvalidationLogicalLeft, m_paintInvalidationLogicalBottom - m_paintInvalidationLogicalTop, paintInvalidationLogicalRight - paintInvalidationLogicalLeft);
+    LayoutRect paintInvalidationRect = LayoutRect(paintInvalidationLogicalLeft, m_paintInvalidationLogicalTop, paintInvalidationLogicalRight - paintInvalidationLogicalLeft, m_paintInvalidationLogicalBottom - m_paintInvalidationLogicalTop);
 
     if (hasOverflowClip()) {
         // Adjust the paint invalidation rect for scroll offset
         paintInvalidationRect.move(-scrolledContentOffset());
 
         // Don't allow this rect to spill out of our overflow box.
         paintInvalidationRect.intersect(LayoutRect(LayoutPoint(), size()));
     }
 
     // Make sure the rect is still non-empty after intersecting for overflow above
@@ skipping 182 matching lines @@
     for (; curr && curr->hasSelectedChildren(); curr = curr->nextRootBox()) {
         LayoutUnit selTop =  curr->selectionTopAdjustedForPrecedingBlock();
         LayoutUnit selHeight = curr->selectionHeightAdjustedForPrecedingBlock();
 
         if (!containsStart && !lastSelectedLine && selectionState() != SelectionStart && selectionState() != SelectionBoth) {
             result.uniteCenter(blockSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock, lastLogicalTop,
                 lastLogicalLeft, lastLogicalRight, selTop, paintInfo));
         }
 
         LayoutRect logicalRect(curr->logicalLeft(), selTop, curr->logicalWidth(), selTop + selHeight);
-        logicalRect.move(isHorizontalWritingMode() ? offsetFromRootBlock : offsetFromRootBlock.transposedSize());
+        logicalRect.move(offsetFromRootBlock);
         LayoutRect physicalRect = rootBlock->logicalRectToPhysicalRect(rootBlockPhysicalPosition, logicalRect);
-        if (!paintInfo || (isHorizontalWritingMode() && physicalRect.y() < paintInfo->rect.maxY() && physicalRect.maxY() > paintInfo->rect.y())
-            || (!isHorizontalWritingMode() && physicalRect.x() < paintInfo->rect.maxX() && physicalRect.maxX() > paintInfo->rect.x()))
+        if (!paintInfo || (physicalRect.y() < paintInfo->rect.maxY() && physicalRect.maxY() > paintInfo->rect.y()))
             result.unite(curr->lineSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock, selTop, selHeight, paintInfo));
 
         lastSelectedLine = curr;
     }
 
     if (containsStart && !lastSelectedLine) {
         // VisibleSelection must start just after our last line.
         lastSelectedLine = lastRootBox();
     }
 
@@ skipping 47 matching lines @@
 RenderBlockFlow::RenderBlockFlowRareData& RenderBlockFlow::ensureRareData()
 {
     if (m_rareData)
         return *m_rareData;
 
     m_rareData = adoptPtr(new RenderBlockFlowRareData(this));
     return *m_rareData;
 }
 
 } // namespace blink