Update composition underline start/end constraints.

third_party/WebKit/Source/core/paint/InlineTextBoxPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/InlineTextBoxPainter.h"
 
 #include "core/editing/CompositionUnderline.h"
 #include "core/editing/Editor.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/frame/LocalFrame.h"
@@ skipping 247 matching lines @@
     // tests for != PaintPhaseTextClip.
     if (m_inlineTextBox.getLineLayoutItem().style()->visibility() != EVisibility::Visible
         || m_inlineTextBox.truncation() == cFullTruncation
         || !m_inlineTextBox.len())
         return false;
     return true;
 }
 
 unsigned InlineTextBoxPainter::underlinePaintStart(const CompositionUnderline& underline)
 {
-    return std::max(static_cast<unsigned>(m_inlineTextBox.start()), underline.startOffset());
+    DCHECK(m_inlineTextBox.truncation() != cFullTruncation);
+    DCHECK(m_inlineTextBox.len());
+
+    // Start painting at the beginning of the text or the specified underline
+    // start offset, whichever is higher.
+    unsigned paintStart = std::max(m_inlineTextBox.start(), underline.startOffset());
+    // Cap the maximum paint start to (if no truncation) the last character,
+    // else the last character before the truncation ellipsis.
+    return std::min(paintStart, (m_inlineTextBox.truncation() == cNoTruncation) ?
+        m_inlineTextBox.end() : m_inlineTextBox.start() + m_inlineTextBox.truncation() - 1);
 }
 
 unsigned InlineTextBoxPainter::underlinePaintEnd(const CompositionUnderline& underline)
 {
+    DCHECK(m_inlineTextBox.truncation() != cFullTruncation);
+    DCHECK(m_inlineTextBox.len());
+
+    // End painting just past the end of the text or the specified underline end
+    // offset, whichever is lower.
     unsigned paintEnd = std::min(m_inlineTextBox.end() + 1, underline.endOffset()); // end() points at the last char, not past it.
-    if (m_inlineTextBox.truncation() != cNoTruncation)
-        paintEnd = std::min(paintEnd, static_cast<unsigned>(m_inlineTextBox.start() + m_inlineTextBox.truncation()));
-    return paintEnd;
+    // Cap the maximum paint end to (if no truncation) one past the last
+    // character, else one past the last character before the truncation
+    // ellipsis.
+    return std::min(paintEnd, (m_inlineTextBox.truncation() == cNoTruncation) ?
+        m_inlineTextBox.end() + 1 : m_inlineTextBox.start() + m_inlineTextBox.truncation());
 }
 
 void InlineTextBoxPainter::paintSingleCompositionBackgroundRun(GraphicsContext& context, const LayoutPoint& boxOrigin, const ComputedStyle& style, const Font& font, Color backgroundColor, int startPos, int endPos)
 {
     if (backgroundColor == Color::transparent)
         return;
 
     int sPos = std::max(startPos - static_cast<int>(m_inlineTextBox.start()), 0);
     int ePos = std::min(endPos - static_cast<int>(m_inlineTextBox.start()), static_cast<int>(m_inlineTextBox.len()));
     if (sPos >= ePos)
         return;
 
     int deltaY = (m_inlineTextBox.getLineLayoutItem().style()->isFlippedLinesWritingMode() ? m_inlineTextBox.root().selectionBottom() - m_inlineTextBox.logicalBottom() : m_inlineTextBox.logicalTop() - m_inlineTextBox.root().selectionTop()).toInt();
     int selHeight = m_inlineTextBox.root().selectionHeight().toInt();
     FloatPoint localOrigin(boxOrigin.x().toFloat(), boxOrigin.y().toFloat() - deltaY);
     context.drawHighlightForText(font, m_inlineTextBox.constructTextRun(style), localOrigin, selHeight, backgroundColor, sPos, ePos);
 }
 
 void InlineTextBoxPainter::paintDocumentMarkers(const PaintInfo& paintInfo, const LayoutPoint& boxOrigin, const ComputedStyle& style, const Font& font, DocumentMarkerPaintPhase markerPaintPhase)
 {
     if (!m_inlineTextBox.getLineLayoutItem().node())
         return;
 
+    DCHECK(m_inlineTextBox.truncation() != cFullTruncation);
+    DCHECK(m_inlineTextBox.len());
+
     DocumentMarkerVector markers = m_inlineTextBox.getLineLayoutItem().document().markers().markersFor(m_inlineTextBox.getLineLayoutItem().node());
     DocumentMarkerVector::const_iterator markerIt = markers.begin();
 
     // Give any document markers that touch this run a chance to draw before the text has been drawn.
     // Note end() points at the last char, not one past it like endOffset and ranges do.
     for ( ; markerIt != markers.end(); ++markerIt) {
         DocumentMarker* marker = *markerIt;
 
         // Paint either the background markers or the foreground markers, but not both
         switch (marker->type()) {
@@ skipping 144 matching lines @@
     unsigned start = m_inlineTextBox.start();
     int length = m_inlineTextBox.len();
     bool ltr = m_inlineTextBox.isLeftToRightDirection();
     bool flowIsLTR = m_inlineTextBox.getLineLayoutItem().style()->isLeftToRightDirection();
     if (m_inlineTextBox.truncation() != cNoTruncation) {
         start = ltr == flowIsLTR ? m_inlineTextBox.start() : m_inlineTextBox.truncation();
         length = ltr == flowIsLTR ? m_inlineTextBox.truncation() : m_inlineTextBox.len() - m_inlineTextBox.truncation();
     }
     StringView string(m_inlineTextBox.getLineLayoutItem().text(), start, static_cast<unsigned>(length));
 
-
     StringBuilder charactersWithHyphen;
     bool respectHyphen = ePos == length && m_inlineTextBox.hasHyphen();
     TextRun textRun = m_inlineTextBox.constructTextRun(style, string, m_inlineTextBox.getLineLayoutItem().textLength() - m_inlineTextBox.start(), respectHyphen ? &charactersWithHyphen : 0);
     if (respectHyphen)
         ePos = textRun.length();
 
     GraphicsContextStateSaver stateSaver(context);
 
     if (options == InlineTextBoxPainter::PaintOptions::CombinedText) {
         ASSERT(combinedText);
@@ skipping 317 matching lines @@
 void InlineTextBoxPainter::paintCompositionUnderline(GraphicsContext& context, const LayoutPoint& boxOrigin, const CompositionUnderline& underline)
 {
     if (underline.color() == Color::transparent)
         return;
 
     if (m_inlineTextBox.truncation() == cFullTruncation)
         return;
 
     unsigned paintStart = underlinePaintStart(underline);
     unsigned paintEnd = underlinePaintEnd(underline);
+    DCHECK_LT(paintStart, paintEnd);
 
     // start of line to draw
-    float start = paintStart == static_cast<unsigned>(m_inlineTextBox.start()) ? 0 :
+    float start = paintStart == m_inlineTextBox.start() ? 0 :
         m_inlineTextBox.getLineLayoutItem().width(m_inlineTextBox.start(), paintStart - m_inlineTextBox.start(), m_inlineTextBox.textPos(), m_inlineTextBox.isLeftToRightDirection() ? LTR : RTL, m_inlineTextBox.isFirstLineStyle());
     // how much line to draw
     float width;
     bool ltr = m_inlineTextBox.isLeftToRightDirection();
     bool flowIsLTR = m_inlineTextBox.getLineLayoutItem().style()->isLeftToRightDirection();
-    if (paintStart == static_cast<unsigned>(m_inlineTextBox.start()) && paintEnd == static_cast<unsigned>(m_inlineTextBox.end()) + 1) {
+    if (paintStart == m_inlineTextBox.start() && paintEnd == m_inlineTextBox.end() + 1) {
         width = m_inlineTextBox.logicalWidth().toFloat();
     } else {
-        width = m_inlineTextBox.getLineLayoutItem().width(ltr == flowIsLTR ? paintStart : paintEnd, ltr == flowIsLTR ? paintEnd - paintStart : m_inlineTextBox.len() - paintEnd, LayoutUnit(m_inlineTextBox.textPos() + start), flowIsLTR ? LTR : RTL, m_inlineTextBox.isFirstLineStyle());
+        unsigned paintFrom = ltr == flowIsLTR ? paintStart : paintEnd;
+        unsigned paintLength = ltr == flowIsLTR ? paintEnd - paintStart : m_inlineTextBox.start() + m_inlineTextBox.len() - paintEnd;
+        width = m_inlineTextBox.getLineLayoutItem().width(paintFrom, paintLength,
+            LayoutUnit(m_inlineTextBox.textPos() + start), flowIsLTR ? LTR : RTL, m_inlineTextBox.isFirstLineStyle());
     }
     // In RTL mode, start and width are computed from the right end of the text box:
     // starting at |logicalWidth| - |start| and continuing left by |width| to
     // |logicalWidth| - |start| - |width|. We will draw that line, but
     // backwards: |logicalWidth| - |start| - |width| to |logicalWidth| - |start|.
     if (!flowIsLTR)
         start = m_inlineTextBox.logicalWidth().toFloat() - width - start;
 
-
     // Thick marked text underlines are 2px thick as long as there is room for the 2px line under the baseline.
     // All other marked text underlines are 1px thick.
     // If there's not enough space the underline will touch or overlap characters.
     int lineThickness = 1;
     int baseline = m_inlineTextBox.getLineLayoutItem().style(m_inlineTextBox.isFirstLineStyle())->getFontMetrics().ascent();
     if (underline.thick() && m_inlineTextBox.logicalHeight() - baseline >= 2)
         lineThickness = 2;
 
     // We need to have some space between underlines of subsequent clauses, because some input methods do not use different underline styles for those.
     // We make each line shorter, which has a harmless side effect of shortening the first and last clauses, too.
@@ skipping 41 matching lines @@
 
     Color color = LayoutTheme::theme().platformTextSearchHighlightColor(marker->activeMatch());
     GraphicsContext& context = paintInfo.context;
     GraphicsContextStateSaver stateSaver(context);
 
     LayoutRect boxRect(boxOrigin, LayoutSize(m_inlineTextBox.logicalWidth(), m_inlineTextBox.logicalHeight()));
     context.clip(FloatRect(boxRect));
     context.drawHighlightForText(font, run, FloatPoint(boxOrigin), boxRect.height().toInt(), color, sPos, ePos);
 }
 
-
 } // namespace blink