Remove PaintPhaseSelection.

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 483 matching lines @@
     // 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)
         return;
 
-    // Determine whether or not we're selected.
-    bool haveSelection = selectionState() != RenderObject::SelectionNone;
-    if (!haveSelection && paintInfo.phase == PaintPhaseSelection)
-        // When only painting the selection, don't bother to paint if there is none.
-        return;
-
     if (m_truncation != cNoTruncation) {
         if (renderer().containingBlock()->style()->isLeftToRightDirection() != isLeftToRightDirection()) {
             // Make the visible fragment of text hug the edge closest to the rest of the run by moving the origin
             // at which we start drawing text.
             // 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(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()));
 
     // 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();
 
+    bool haveSelection = selectionState() != RenderObject::SelectionNone;
+
     // Determine text colors.
     TextPaintingStyle textStyle = textPaintingStyle(renderer(), styleToUse);
     TextPaintingStyle selectionStyle = selectionPaintingStyle(renderer(), haveSelection, textStyle);
-    bool paintSelectedTextOnly = (paintInfo.phase == PaintPhaseSelection);
-    bool paintSelectedTextSeparately = !paintSelectedTextOnly && textStyle != selectionStyle;
+    bool paintSelectedTextSeparately = textStyle != selectionStyle;
 
     // Set our font.
     const Font& font = styleToUse->font();
 
     FloatPoint textOrigin = FloatPoint(boxOrigin.x(), boxOrigin.y() + font.fontMetrics().ascent());
 
     // 1. Paint backgrounds behind text if needed. Examples of such backgrounds include selection
     // and composition highlights.
-    if (paintInfo.phase != PaintPhaseSelection) {
-        if (containsComposition) {
-            paintCompositionBackgrounds(context, boxOrigin, styleToUse, font, useCustomUnderlines);
-        }
+    if (containsComposition) {
+        paintCompositionBackgrounds(context, boxOrigin, styleToUse, font, useCustomUnderlines);
+    }
 
-        paintDocumentMarkers(context, boxOrigin, styleToUse, font, true);
+    paintDocumentMarkers(context, boxOrigin, styleToUse, font, true);
 
-        if (haveSelection && !useCustomUnderlines)
-            paintSelection(context, boxOrigin, styleToUse, font, selectionStyle.fillColor);
-    }
+    if (haveSelection && !useCustomUnderlines)
+        paintSelection(context, boxOrigin, styleToUse, font, selectionStyle.fillColor);
 
     // 2. Now paint the foreground, including text and decorations like underline/overline (in quirks mode only).
     int length = m_len;
     int maximumLength;
     StringView string = renderer().text().createView();
     if (static_cast<unsigned>(length) != string.length() || m_start)
         string.narrow(m_start, length);
     maximumLength = renderer().textLength() - m_start;
 
     StringBuilder charactersWithHyphen;
     TextRun textRun = constructTextRun(styleToUse, font, string, maximumLength, hasHyphen() ? &charactersWithHyphen : 0);
     if (hasHyphen())
         length = textRun.length();
 
     int sPos = 0;
     int ePos = 0;
-    if (paintSelectedTextOnly || paintSelectedTextSeparately)
+    if (paintSelectedTextSeparately)
         selectionStartEnd(sPos, ePos);
 
     bool respectHyphen = ePos == m_len && hasHyphen();
     if (respectHyphen)
         ePos = textRun.length();
 
     if (m_truncation != cNoTruncation) {
         sPos = std::min<int>(sPos, m_truncation);
         ePos = std::min<int>(ePos, m_truncation);
         length = m_truncation;
     }
 
     int emphasisMarkOffset = 0;
     TextEmphasisPosition emphasisMarkPosition;
     bool hasTextEmphasis = getEmphasisMarkPosition(styleToUse, emphasisMarkPosition);
     const AtomicString& emphasisMark = hasTextEmphasis ? styleToUse->textEmphasisMarkString() : nullAtom;
     if (!emphasisMark.isEmpty())
         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;
-        }
-        // FIXME: This cache should probably ultimately be held somewhere else.
-        // A hashmap is convenient to avoid a memory hit when the
-        // RuntimeEnabledFeature is off.
-        bool textBlobIsCacheable = RuntimeEnabledFeatures::textBlobEnabled() && startOffset == 0 && endOffset == length;
-        TextBlobPtr* cachedTextBlob = textBlobIsCacheable ? &m_cachedTextBlob : nullptr;
-        paintTextWithEmphasisMark(context, font, textStyle, textRun, emphasisMark, emphasisMarkOffset, startOffset, endOffset, length, textOrigin, boxRect, cachedTextBlob);
+    // FIXME: Truncate right-to-left text correctly.
+    int startOffset = 0;
+    int endOffset = length;
+    if (paintSelectedTextSeparately && ePos > sPos) {
+        startOffset = ePos;
+        endOffset = sPos;
     }
+    // FIXME: This cache should probably ultimately be held somewhere else.
+    // A hashmap is convenient to avoid a memory hit when the
+    // RuntimeEnabledFeature is off.
+    bool textBlobIsCacheable = RuntimeEnabledFeatures::textBlobEnabled() && startOffset == 0 && endOffset == length;
+    TextBlobPtr* cachedTextBlob = textBlobIsCacheable ? &m_cachedTextBlob : nullptr;
+    paintTextWithEmphasisMark(context, font, textStyle, textRun, emphasisMark, emphasisMarkOffset, startOffset, endOffset, length, textOrigin, boxRect, cachedTextBlob);
 
-    if ((paintSelectedTextOnly || paintSelectedTextSeparately) && sPos < ePos) {
+    if (paintSelectedTextSeparately && sPos < ePos) {
         // paint only the text that is selected
         bool textBlobIsCacheable = RuntimeEnabledFeatures::textBlobEnabled() && sPos == 0 && ePos == length;
         TextBlobPtr* cachedTextBlob = textBlobIsCacheable ? &m_cachedTextBlob : nullptr;
         paintTextWithEmphasisMark(context, font, selectionStyle, textRun, emphasisMark, emphasisMarkOffset, sPos, ePos, length, textOrigin, boxRect, cachedTextBlob);
     }
 
     // Paint decorations
     TextDecoration textDecorations = styleToUse->textDecorationsInEffect();
-    if (textDecorations != TextDecorationNone && !paintSelectedTextOnly) {
+    if (textDecorations != TextDecorationNone) {
         GraphicsContextStateSaver stateSaver(*context, false);
         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) {
@@ 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