First pass at removing dead vertical writing mode code.

sky/engine/core/rendering/RenderFlexibleBox.cpp

 /*
  * Copyright (C) 2011 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 156 matching lines @@
 
     if (!isColumnFlow() && hasOrthogonalFlow(baselineChild))
         return crossAxisExtentForChild(baselineChild) + baselineChild->logicalTop();
     if (isColumnFlow() && !hasOrthogonalFlow(baselineChild))
         return mainAxisExtentForChild(baselineChild) + baselineChild->logicalTop();
 
     int baseline = baselineChild->firstLineBoxBaseline();
     if (baseline == -1) {
         // FIXME: We should pass |direction| into firstLineBoxBaseline and stop bailing out if we're a writing mode root.
         // This would also fix some cases where the flexbox is orthogonal to its container.
-        LineDirectionMode direction = isHorizontalWritingMode() ? HorizontalLine : VerticalLine;
+        LineDirectionMode direction = HorizontalLine;
         return synthesizedBaselineFromContentBox(baselineChild, direction) + baselineChild->logicalTop();
     }
 
     return baseline + baselineChild->logicalTop();
 }
 
 int RenderFlexibleBox::inlineBlockBaseline(LineDirectionMode direction) const
 {
     int baseline = firstLineBoxBaseline();
     if (baseline != -1)
@@ skipping 227 matching lines @@
     // to figure out the logical height/width.
     if (isColumnFlow()) {
         // We don't have to check for "auto" here - computeContentLogicalHeight will just return -1 for that case anyway.
         if (size.isIntrinsic())
             child->layoutIfNeeded();
         return child->computeContentLogicalHeight(size, child->logicalHeight() - child->borderAndPaddingLogicalHeight()) + child->scrollbarLogicalHeight();
     }
     return child->computeLogicalWidthUsing(sizeType, size, contentLogicalWidth(), this) - child->borderAndPaddingLogicalWidth();
 }
 
-WritingMode RenderFlexibleBox::transformedWritingMode() const
-{
-    // FIXME(sky): Remove
-    return TopToBottomWritingMode;
-}
-
 LayoutUnit RenderFlexibleBox::flowAwareBorderStart() const
 {
     if (isHorizontalFlow())
         return isLeftToRightFlow() ? borderLeft() : borderRight();
     return isLeftToRightFlow() ? borderTop() : borderBottom();
 }
 
 LayoutUnit RenderFlexibleBox::flowAwareBorderEnd() const
 {
     if (isHorizontalFlow())
@@ skipping 155 matching lines @@
         }
 
         layoutAndPlaceChildren(crossAxisOffset, orderedChildren, childSizes, availableFreeSpace, relayoutChildren, lineContexts, hasInfiniteLineLength);
     }
     if (hasLineIfEmpty()) {
         // Even if computeNextFlexLine returns true, the flexbox might not have
         // a line because all our children might be out of flow positioned.
         // Instead of just checking if we have a line, make sure the flexbox
         // has at least a line's worth of height to cover this case.
         LayoutUnit minHeight = borderAndPaddingLogicalHeight()
-            + lineHeight(true, isHorizontalWritingMode() ? HorizontalLine : VerticalLine, PositionOfInteriorLineBoxes)
+            + lineHeight(true, HorizontalLine, PositionOfInteriorLineBoxes)
             + scrollbarLogicalHeight();
         if (height() < minHeight)
             setLogicalHeight(minHeight);
     }
 
     updateLogicalHeight();
     repositionLogicalHeightDependentFlexItems(lineContexts);
 }
 
 LayoutUnit RenderFlexibleBox::autoMarginOffsetInMainAxis(const OrderedFlexItemList& children, LayoutUnit& availableFreeSpace)
@@ skipping 316 matching lines @@
     child->containingBlock()->insertPositionedObject(child);
     RenderLayer* childLayer = child->layer();
     LayoutUnit inlinePosition = isColumnFlow() ? crossAxisOffset : mainAxisOffset;
     if (layoutMode == FlipForRowReverse && style()->flexDirection() == FlowRowReverse)
         inlinePosition = mainAxisExtent() - mainAxisOffset;
     childLayer->setStaticInlinePosition(inlinePosition);
 
     LayoutUnit staticBlockPosition = isColumnFlow() ? mainAxisOffset : crossAxisOffset;
     if (childLayer->staticBlockPosition() != staticBlockPosition) {
         childLayer->setStaticBlockPosition(staticBlockPosition);
-        if (child->style()->hasStaticBlockPosition(style()->isHorizontalWritingMode()))
+        if (child->style()->hasStaticBlockPosition())
             child->setChildNeedsLayout(MarkOnlyThis);
     }
 }
 
 ItemPosition RenderFlexibleBox::alignmentForChild(RenderBox* child) const
 {
     ItemPosition align = resolveAlignment(style(), child->style());
 
     if (align == ItemPositionBaseline && hasOrthogonalFlow(child))
         align = ItemPositionFlexStart;
@@ skipping 381 matching lines @@
             ASSERT(child);
             LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
             LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
             LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
             adjustAlignmentForChild(child, newOffset - originalOffset);
         }
     }
 }
 
 }