Delete a ton more dead vertical writing mode code.

sky/engine/core/rendering/RenderText.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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 303 matching lines @@
 
 void RenderText::absoluteQuads(Vector<FloatQuad>& quads, ClippingOption option) const
 {
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
         FloatRect boundaries = box->calculateBoundaries();
 
         // Shorten the width of this text box if it ends in an ellipsis.
         // FIXME: ellipsisRectForBox should switch to return FloatRect soon with the subpixellayout branch.
         IntRect ellipsisRect = (option == ClipToEllipsis) ? ellipsisRectForBox(box, 0, textLength()) : IntRect();
         if (!ellipsisRect.isEmpty()) {
-            if (style()->isHorizontalWritingMode())
-                boundaries.setWidth(ellipsisRect.maxX() - boundaries.x());
-            else
-                boundaries.setHeight(ellipsisRect.maxY() - boundaries.y());
+            boundaries.setWidth(ellipsisRect.maxX() - boundaries.x());
         }
         quads.append(localToAbsoluteQuad(boundaries, 0));
     }
 }
 
 void RenderText::absoluteQuads(Vector<FloatQuad>& quads) const
 {
     absoluteQuads(quads, NoClipping);
 }
 
@@ skipping 160 matching lines @@
     return createPositionWithAffinityForBox(box, box->caretLeftmostOffset(), shouldAffinityBeDownstream);
 }
 
 PositionWithAffinity RenderText::positionForPoint(const LayoutPoint& point)
 {
     if (!firstTextBox() || textLength() == 0)
         return createPositionWithAffinity(0, DOWNSTREAM);
 
     LayoutUnit pointLineDirection = firstTextBox()->isHorizontal() ? point.x() : point.y();
     LayoutUnit pointBlockDirection = firstTextBox()->isHorizontal() ? point.y() : point.x();
-    bool blocksAreFlipped = style()->isFlippedBlocksWritingMode();
 
     InlineTextBox* lastBox = 0;
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
         if (box->isLineBreak() && !box->prevLeafChild() && box->nextLeafChild() && !box->nextLeafChild()->isLineBreak())
             box = box->nextTextBox();
 
         RootInlineBox& rootBox = box->root();
         LayoutUnit top = std::min(rootBox.selectionTop(), rootBox.lineTop());
-        if (pointBlockDirection > top || (!blocksAreFlipped && pointBlockDirection == top)) {
+        if (pointBlockDirection > top || pointBlockDirection == top) {
             LayoutUnit bottom = rootBox.selectionBottom();
             if (rootBox.nextRootBox())
                 bottom = std::min(bottom, rootBox.nextRootBox()->lineTop());
 
-            if (pointBlockDirection < bottom || (blocksAreFlipped && pointBlockDirection == bottom)) {
+            if (pointBlockDirection < bottom) {
                 ShouldAffinityBeDownstream shouldAffinityBeDownstream;
                 if (lineDirectionPointFitsInBox(pointLineDirection, box, shouldAffinityBeDownstream))
                     return createPositionWithAffinityForBoxAfterAdjustingOffsetForBiDi(box, box->offsetForPosition(pointLineDirection.toFloat()), shouldAffinityBeDownstream);
             }
         }
         lastBox = box;
     }
 
     if (lastBox) {
         ShouldAffinityBeDownstream shouldAffinityBeDownstream;
@@ skipping 826 matching lines @@
         // Return the width of the minimal left side and the maximal right side.
         float logicalLeftSide = 0;
         float logicalRightSide = 0;
         for (InlineTextBox* curr = firstTextBox(); curr; curr = curr->nextTextBox()) {
             if (curr == firstTextBox() || curr->logicalLeft() < logicalLeftSide)
                 logicalLeftSide = curr->logicalLeft();
             if (curr == firstTextBox() || curr->logicalRight() > logicalRightSide)
                 logicalRightSide = curr->logicalRight();
         }
 
-        bool isHorizontal = style()->isHorizontalWritingMode();
-
-        float x = isHorizontal ? logicalLeftSide : firstTextBox()->x();
-        float y = isHorizontal ? firstTextBox()->y() : logicalLeftSide;
-        float width = isHorizontal ? logicalRightSide - logicalLeftSide : lastTextBox()->logicalBottom() - x;
-        float height = isHorizontal ? lastTextBox()->logicalBottom() - y : logicalRightSide - logicalLeftSide;
+        float x = logicalLeftSide;
+        float y = firstTextBox()->y();
+        float width = logicalRightSide - logicalLeftSide;
+        float height = lastTextBox()->logicalBottom() - y;
         result = enclosingIntRect(FloatRect(x, y, width, height));
     }
 
     return result;
 }
 
 LayoutRect RenderText::linesVisualOverflowBoundingBox() const
 {
     if (!firstTextBox())
         return LayoutRect();
 
     // Return the width of the minimal left side and the maximal right side.
     LayoutUnit logicalLeftSide = LayoutUnit::max();
     LayoutUnit logicalRightSide = LayoutUnit::min();
     for (InlineTextBox* curr = firstTextBox(); curr; curr = curr->nextTextBox()) {
         LayoutRect logicalVisualOverflow = curr->logicalOverflowRect();
         logicalLeftSide = std::min(logicalLeftSide, logicalVisualOverflow.x());
         logicalRightSide = std::max(logicalRightSide, logicalVisualOverflow.maxX());
     }
 
     LayoutUnit logicalTop = firstTextBox()->logicalTopVisualOverflow();
     LayoutUnit logicalWidth = logicalRightSide - logicalLeftSide;
     LayoutUnit logicalHeight = lastTextBox()->logicalBottomVisualOverflow() - logicalTop;
 
     LayoutRect rect(logicalLeftSide, logicalTop, logicalWidth, logicalHeight);
-    if (!style()->isHorizontalWritingMode())
-        rect = rect.transposedRect();
     return rect;
 }
 
 LayoutRect RenderText::clippedOverflowRectForPaintInvalidation(const RenderLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState) const
 {
     RenderObject* rendererToIssuePaintInvalidations = containingBlock();
 
     // Do not cross self-painting layer boundaries.
     RenderObject* enclosingLayerRenderer = enclosingLayer()->renderer();
     if (enclosingLayerRenderer != rendererToIssuePaintInvalidations && !rendererToIssuePaintInvalidations->isDescendantOf(enclosingLayerRenderer))
@@ skipping 268 matching lines @@
         ASSERT(child->prevTextBox() == prev);
         prev = child;
     }
     ASSERT(prev == m_lastTextBox);
 #endif
 }
 
 #endif
 
 } // namespace blink