Remove writing mode code from the linebox tree.

sky/engine/core/rendering/InlineTextBox.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 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 83 matching lines @@
         gTextBoxesWithOverflow = new InlineTextBoxOverflowMap;
     gTextBoxesWithOverflow->add(this, rect);
 }
 
 int InlineTextBox::baselinePosition(FontBaseline baselineType) const
 {
     if (!isText() || !parent())
         return 0;
     if (parent()->renderer() == renderer().parent())
         return parent()->baselinePosition(baselineType);
-    return toRenderBoxModelObject(renderer().parent())->baselinePosition(baselineType, isFirstLineStyle(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOnContainingLine);
+    return toRenderBoxModelObject(renderer().parent())->baselinePosition(baselineType, isFirstLineStyle(), HorizontalLine, PositionOnContainingLine);
 }
 
 LayoutUnit InlineTextBox::lineHeight() const
 {
     if (!isText() || !renderer().parent())
         return 0;
     if (parent()->renderer() == renderer().parent())
         return parent()->lineHeight();
-    return toRenderBoxModelObject(renderer().parent())->lineHeight(isFirstLineStyle(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOnContainingLine);
+    return toRenderBoxModelObject(renderer().parent())->lineHeight(isFirstLineStyle(), HorizontalLine, PositionOnContainingLine);
 }
 
 LayoutUnit InlineTextBox::selectionTop()
 {
     return root().selectionTop();
 }
 
 LayoutUnit InlineTextBox::selectionBottom()
 {
     return root().selectionBottom();
@@ skipping 84 matching lines @@
         r = enclosingIntRect(font.selectionRectForText(textRun, startingPoint, selHeight, sPos, ePos));
     else // Avoid computing the font width when the entire line box is selected as an optimization.
         r = enclosingIntRect(FloatRect(startingPoint, FloatSize(m_logicalWidth, selHeight.toFloat())));
 
     LayoutUnit logicalWidth = r.width();
     if (r.x() > logicalRight())
         logicalWidth  = 0;
     else if (r.maxX() > logicalRight())
         logicalWidth = logicalRight() - r.x();
 
-    LayoutPoint topPoint = isHorizontal() ? LayoutPoint(r.x(), selTop) : LayoutPoint(selTop, r.x());
-    LayoutUnit width = isHorizontal() ? logicalWidth : selHeight;
-    LayoutUnit height = isHorizontal() ? selHeight : logicalWidth;
-
-    return LayoutRect(topPoint, LayoutSize(width, height));
+    LayoutPoint topPoint = LayoutPoint(r.x(), selTop);
+    return LayoutRect(topPoint, LayoutSize(logicalWidth, selHeight));
 }
 
 void InlineTextBox::deleteLine()
 {
     renderer().removeTextBox(this);
     destroy();
 }
 
 void InlineTextBox::extractLine()
 {
@@ skipping 172 matching lines @@
     if (haveSelection) {
         if (!forceBlackText) {
             selectionStyle.fillColor = renderer.selectionForegroundColor();
             selectionStyle.emphasisMarkColor = renderer.selectionEmphasisMarkColor();
         }
     }
 
     return selectionStyle;
 }
 
-void updateGraphicsContext(GraphicsContext* context, const TextPaintingStyle& textStyle, bool horizontal, GraphicsContextStateSaver& stateSaver)
+void updateGraphicsContext(GraphicsContext* context, const TextPaintingStyle& textStyle, GraphicsContextStateSaver& stateSaver)
 {
     TextDrawingModeFlags mode = context->textDrawingMode();
     if (textStyle.strokeWidth > 0) {
         TextDrawingModeFlags newMode = mode | TextModeStroke;
         if (mode != newMode) {
             if (!stateSaver.saved())
                 stateSaver.save();
             context->setTextDrawingMode(newMode);
             mode = newMode;
         }
     }
 
     if (mode & TextModeFill && textStyle.fillColor != context->fillColor())
         context->setFillColor(textStyle.fillColor);
 
     if (mode & TextModeStroke) {
         if (textStyle.strokeColor != context->strokeColor())
             context->setStrokeColor(textStyle.strokeColor);
         if (textStyle.strokeWidth != context->strokeThickness())
             context->setStrokeThickness(textStyle.strokeWidth);
     }
 
     if (textStyle.shadow) {
         if (!stateSaver.saved())
             stateSaver.save();
-        context->setDrawLooper(textStyle.shadow->createDrawLooper(DrawLooperBuilder::ShadowIgnoresAlpha, horizontal));
+        context->setDrawLooper(textStyle.shadow->createDrawLooper(DrawLooperBuilder::ShadowIgnoresAlpha));
     }
 }
 
 void paintText(GraphicsContext* context,
     const Font& font, const TextRun& textRun,
     const AtomicString& emphasisMark, int emphasisMarkOffset,
     int startOffset, int endOffset, int truncationPoint,
     const FloatPoint& textOrigin, const FloatRect& boxRect)
 {
     TextRunPaintInfo textRunPaintInfo(textRun);
@@ skipping 31 matching lines @@
     const Font& font, const TextRun& textRun,
     const FloatPoint& textOrigin, const FloatRect& boxRect)
 {
     ASSERT(!emphasisMark.isEmpty());
     paintText(context, font, textRun, emphasisMark, emphasisMarkOffset, startOffset, endOffset, paintRunLength, textOrigin, boxRect);
 }
 
 void paintTextWithEmphasisMark(
     GraphicsContext* context, const Font& font, const TextPaintingStyle& textStyle, const TextRun& textRun,
     const AtomicString& emphasisMark, int emphasisMarkOffset, int startOffset, int endOffset, int length,
-    const FloatPoint& textOrigin, const FloatRect& boxRect, bool horizontal)
+    const FloatPoint& textOrigin, const FloatRect& boxRect)
 {
     GraphicsContextStateSaver stateSaver(*context, false);
-    updateGraphicsContext(context, textStyle, horizontal, stateSaver);
+    updateGraphicsContext(context, textStyle, stateSaver);
     paintText(context, font, textRun, nullAtom, 0, startOffset, endOffset, length, textOrigin, boxRect);
 
     if (!emphasisMark.isEmpty()) {
         if (textStyle.emphasisMarkColor != textStyle.fillColor)
             context->setFillColor(textStyle.emphasisMarkColor);
         paintEmphasisMark(context, emphasisMark, emphasisMarkOffset, startOffset, endOffset, length, font, textRun, textOrigin, boxRect);
     }
 }
 
 } // namespace
 
 void InlineTextBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit /*lineTop*/, LayoutUnit /*lineBottom*/)
 {
     if (isLineBreak() || !paintInfo.shouldPaintWithinRoot(&renderer())
         || m_truncation == cFullTruncation || paintInfo.phase == PaintPhaseOutline || !m_len)
         return;
 
     ASSERT(paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines);
 
     LayoutRect logicalVisualOverflow = logicalOverflowRect();
-    LayoutUnit logicalStart = logicalVisualOverflow.x() + (isHorizontal() ? paintOffset.x() : paintOffset.y());
+    LayoutUnit logicalStart = logicalVisualOverflow.x() + paintOffset.x();
     LayoutUnit logicalExtent = logicalVisualOverflow.width();
 
-    LayoutUnit paintEnd = isHorizontal() ? paintInfo.rect.maxX() : paintInfo.rect.maxY();
-    LayoutUnit paintStart = isHorizontal() ? paintInfo.rect.x() : paintInfo.rect.y();
+    LayoutUnit paintEnd = paintInfo.rect.maxX();
+    LayoutUnit paintStart = paintInfo.rect.x();
 
     // When subpixel font scaling is enabled text runs are positioned at
     // subpixel boundaries on the x-axis and thus there is no reason to
     // snap the x value. We still round the y-axis to ensure consistent
     // line heights.
     LayoutPoint adjustedPaintOffset = RuntimeEnabledFeatures::subpixelFontScalingEnabled()
         ? LayoutPoint(paintOffset.x(), paintOffset.y().round())
         : roundedIntPoint(paintOffset);
 
     if (logicalStart >= paintEnd || logicalStart + logicalExtent <= paintStart)
@@ skipping 12 matching lines @@
             // e.g. In the case of LTR text truncated in an RTL Context, the correct behavior is:
             // |Hello|CBA| -> |...He|CBA|
             // In order to draw the fragment "He" aligned to the right edge of it's box, we need to start drawing
             // farther to the right.
             // NOTE: WebKit's behavior differs from that of IE which appears to just overlay the ellipsis on top of the
             // truncated string i.e.  |Hello|CBA| -> |...lo|CBA|
             LayoutUnit widthOfVisibleText = renderer().width(m_start, m_truncation, textPos(), isLeftToRightDirection() ? LTR : RTL, isFirstLineStyle());
             LayoutUnit widthOfHiddenText = m_logicalWidth - widthOfVisibleText;
             // FIXME: The hit testing logic also needs to take this translation into account.
             LayoutSize truncationOffset(isLeftToRightDirection() ? widthOfHiddenText : -widthOfHiddenText, 0);
-            adjustedPaintOffset.move(isHorizontal() ? truncationOffset : truncationOffset.transposedSize());
+            adjustedPaintOffset.move(truncationOffset);
         }
     }
 
     GraphicsContext* context = paintInfo.context;
     RenderStyle* styleToUse = renderer().style(isFirstLineStyle());
 
     FloatPoint boxOrigin = locationIncludingFlipping();
     boxOrigin.move(adjustedPaintOffset.x().toFloat(), adjustedPaintOffset.y().toFloat());
     FloatRect boxRect(boxOrigin, LayoutSize(logicalWidth(), logicalHeight()));
 
-    bool shouldRotate = !isHorizontal();
-    if (shouldRotate)
-        context->concatCTM(rotation(boxRect, Clockwise));
-
     // Determine whether or not we have composition underlines to draw.
     bool containsComposition = renderer().node() && renderer().frame()->inputMethodController().compositionNode() == renderer().node();
     bool useCustomUnderlines = containsComposition && renderer().frame()->inputMethodController().compositionUsesCustomUnderlines();
 
     // Determine text colors.
     TextPaintingStyle textStyle = textPaintingStyle(renderer(), styleToUse, paintInfo.forceBlackText());
     TextPaintingStyle selectionStyle = selectionPaintingStyle(renderer(), haveSelection, paintInfo.forceBlackText(), textStyle);
     bool paintSelectedTextOnly = (paintInfo.phase == PaintPhaseSelection);
     bool paintSelectedTextSeparately = !paintSelectedTextOnly && textStyle != selectionStyle;
 
@@ skipping 51 matching lines @@
         emphasisMarkOffset = emphasisMarkPosition == TextEmphasisPositionOver ? -font.fontMetrics().ascent() - font.emphasisMarkDescent(emphasisMark) : font.fontMetrics().descent() + font.emphasisMarkAscent(emphasisMark);
 
     if (!paintSelectedTextOnly) {
         // FIXME: Truncate right-to-left text correctly.
         int startOffset = 0;
         int endOffset = length;
         if (paintSelectedTextSeparately && ePos > sPos) {
             startOffset = ePos;
             endOffset = sPos;
         }
-        paintTextWithEmphasisMark(context, font, textStyle, textRun, emphasisMark, emphasisMarkOffset, startOffset, endOffset, length, textOrigin, boxRect, isHorizontal());
+        paintTextWithEmphasisMark(context, font, textStyle, textRun, emphasisMark, emphasisMarkOffset, startOffset, endOffset, length, textOrigin, boxRect);
     }
 
     if ((paintSelectedTextOnly || paintSelectedTextSeparately) && sPos < ePos) {
         // paint only the text that is selected
-        paintTextWithEmphasisMark(context, font, selectionStyle, textRun, emphasisMark, emphasisMarkOffset, sPos, ePos, length, textOrigin, boxRect, isHorizontal());
+        paintTextWithEmphasisMark(context, font, selectionStyle, textRun, emphasisMark, emphasisMarkOffset, sPos, ePos, length, textOrigin, boxRect);
     }
 
     // Paint decorations
     TextDecoration textDecorations = styleToUse->textDecorationsInEffect();
     if (textDecorations != TextDecorationNone && !paintSelectedTextOnly) {
         GraphicsContextStateSaver stateSaver(*context, false);
-        updateGraphicsContext(context, textStyle, isHorizontal(), stateSaver);
+        updateGraphicsContext(context, textStyle, stateSaver);
         paintDecoration(context, boxOrigin, textDecorations);
     }
 
     if (paintInfo.phase == PaintPhaseForeground) {
         paintDocumentMarkers(context, boxOrigin, styleToUse, font, false);
 
         // Paint custom underlines for compositions.
         if (useCustomUnderlines) {
             const Vector<CompositionUnderline>& underlines = renderer().frame()->inputMethodController().customCompositionUnderlines();
             CompositionUnderlineRangeFilter filter(underlines, start(), end());
             for (CompositionUnderlineRangeFilter::ConstIterator it = filter.begin(); it != filter.end(); ++it) {
                 if (it->color == Color::transparent)
                     continue;
                 paintCompositionUnderline(context, boxOrigin, *it);
             }
         }
     }
-
-    if (shouldRotate)
-        context->concatCTM(rotation(boxRect, Counterclockwise));
 }
 
 void InlineTextBox::selectionStartEnd(int& sPos, int& ePos)
 {
     int startPos, endPos;
     if (renderer().selectionState() == RenderObject::SelectionInside) {
         startPos = 0;
         endPos = renderer().textLength();
     } else {
         renderer().selectionStartEnd(startPos, endPos);
@@ skipping 712 matching lines @@
     printedCharacters = fprintf(stderr, "\t%s %p", obj.renderName(), &obj);
     const int rendererCharacterOffset = 24;
     for (; printedCharacters < rendererCharacterOffset; printedCharacters++)
         fputc(' ', stderr);
     fprintf(stderr, "(%d,%d) \"%s\"\n", start(), start() + len(), value.utf8().data());
 }
 
 #endif
 
 } // namespace blink