Don't paint underline or selections over ellipsis in mixed-flow contexts

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 541 matching lines @@
   int selectionEnd = 0;
   if (paintSelectedTextOnly || paintSelectedTextSeparately)
     m_inlineTextBox.selectionStartEnd(selectionStart, selectionEnd);
 
   bool respectHyphen =
       selectionEnd == static_cast<int>(m_inlineTextBox.len()) &&
       m_inlineTextBox.hasHyphen();
   if (respectHyphen)
     selectionEnd = textRun.length();
 
+  bool ltr = m_inlineTextBox.isLeftToRightDirection();
+  bool flowIsLTR =
+      m_inlineTextBox.getLineLayoutItem().style()->isLeftToRightDirection();
   if (m_inlineTextBox.truncation() != cNoTruncation) {
+    // In a mixed-direction flow the ellipsis is at the start of the text
+    // rather than at the end of it.
     selectionStart =
-        std::min<int>(selectionStart, m_inlineTextBox.truncation());
-    selectionEnd = std::min<int>(selectionEnd, m_inlineTextBox.truncation());
-    length = m_inlineTextBox.truncation();
+        ltr == flowIsLTR
+            ? std::min<int>(selectionStart, m_inlineTextBox.truncation())
+            : std::max<int>(selectionStart, m_inlineTextBox.truncation());
+    selectionEnd =
+        ltr == flowIsLTR
+            ? std::min<int>(selectionEnd, m_inlineTextBox.truncation())
+            : std::max<int>(selectionEnd, m_inlineTextBox.truncation());
+    length = ltr == flowIsLTR ? m_inlineTextBox.truncation() : textRun.length();
   }
 
   TextPainter textPainter(context, font, textRun, textOrigin, boxRect,
                           m_inlineTextBox.isHorizontal());
   TextEmphasisPosition emphasisMarkPosition;
   bool hasTextEmphasis =
       m_inlineTextBox.getEmphasisMarkPosition(styleToUse, emphasisMarkPosition);
   if (hasTextEmphasis)
     textPainter.setEmphasisMark(styleToUse.textEmphasisMarkString(),
                                 emphasisMarkPosition);
   if (combinedText)
     textPainter.setCombinedText(combinedText);
+  if (m_inlineTextBox.truncation() != cNoTruncation && ltr != flowIsLTR)
+    textPainter.setEllipsisOffset(m_inlineTextBox.truncation());
 
   if (!paintSelectedTextOnly) {
     int startOffset = 0;
     int endOffset = length;
+    // Where the text and its flow have opposite directions then our offset into
+    // the text given by |truncation| is at the start of the part that will be
+    // visible.
+    if (m_inlineTextBox.truncation() != cNoTruncation && ltr != flowIsLTR) {
+      startOffset = m_inlineTextBox.truncation();
+      endOffset = textRun.length();
+    }
+
     if (paintSelectedTextSeparately && selectionStart < selectionEnd) {
       startOffset = selectionEnd;
       endOffset = selectionStart;
     }
-    // Where the text and its flow have opposite directions then our offset into
-    // the text given by |truncation| is at the start of the part that will be
-    // visible.
-    if (m_inlineTextBox.truncation() != cNoTruncation &&
-        m_inlineTextBox.getLineLayoutItem()
-                .containingBlock()
-                .style()
-                ->isLeftToRightDirection() !=
-            m_inlineTextBox.isLeftToRightDirection()) {
-      startOffset = m_inlineTextBox.truncation();
-      endOffset = textRun.length();
-    }
 
     // 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 = startOffset == 0 && endOffset == length;
     TextBlobPtr* cachedTextBlob = 0;
     if (textBlobIsCacheable)
       cachedTextBlob = addToTextBlobCache(m_inlineTextBox);
     textPainter.paint(startOffset, endOffset, length, textStyle,
                       cachedTextBlob);
@@ skipping 329 matching lines @@
     c = Color(0xff - c.red(), 0xff - c.green(), 0xff - c.blue());
 
   // If the text is truncated, let the thing being painted in the truncation
   // draw its own highlight.
   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();
+    // In a mixed-direction flow the ellipsis is at the start of the text
+    // so we need to start after it. Otherwise we just need to make sure
+    // the end of the text is where the ellipsis starts.
+    if (ltr != flowIsLTR)
+      sPos = std::max<int>(sPos, m_inlineTextBox.truncation());
+    else
+      length = 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);
@@ skipping 18 matching lines @@
   int deltaY = roundToInt(
       m_inlineTextBox.getLineLayoutItem().style()->isFlippedLinesWritingMode()
           ? selectionBottom - m_inlineTextBox.logicalBottom()
           : m_inlineTextBox.logicalTop() - selectionTop);
   int selHeight = std::max(0, roundToInt(selectionBottom - selectionTop));
 
   FloatPoint localOrigin(boxRect.x().toFloat(),
                          (boxRect.y() - deltaY).toFloat());
   LayoutRect selectionRect = LayoutRect(
       font.selectionRectForText(textRun, localOrigin, selHeight, sPos, ePos));
-  if (m_inlineTextBox.hasWrappedSelectionNewline()
-      // For line breaks, just painting a selection where the line break itself
-      // is rendered is sufficient.
-      && !m_inlineTextBox.isLineBreak())
+  // For line breaks, just painting a selection where the line break itself
+  // is rendered is sufficient. Don't select it if there's an ellipsis
+  // there.
+  if (m_inlineTextBox.hasWrappedSelectionNewline() &&
+      m_inlineTextBox.truncation() == cNoTruncation &&
+      !m_inlineTextBox.isLineBreak())
     expandToIncludeNewlineForSelection(selectionRect);
 
   // Line breaks report themselves as having zero width for layout purposes,
   // and so will end up positioned at (0, 0), even though we paint their
   // selection highlight with character width. For RTL then, we have to
   // explicitly shift the selection rect over to paint in the right location.
   if (!m_inlineTextBox.isLeftToRightDirection() &&
       m_inlineTextBox.isLineBreak())
     selectionRect.move(-selectionRect.width(), LayoutUnit());
-  if (!flowIsLTR && m_inlineTextBox.truncation() != cNoTruncation)
+  if (!flowIsLTR && !ltr && m_inlineTextBox.truncation() != cNoTruncation)
     selectionRect.move(m_inlineTextBox.logicalWidth() - selectionRect.width(),
                        LayoutUnit());
 
   context.fillRect(FloatRect(selectionRect), c);
 }
 
 void InlineTextBoxPainter::expandToIncludeNewlineForSelection(
     LayoutRect& rect) {
   FloatRectOutsets outsets = FloatRectOutsets();
   float spaceWidth = m_inlineTextBox.newlineSpaceWidth();
@@ skipping 16 matching lines @@
   GraphicsContextStateSaver stateSaver(context);
 
   LayoutPoint localOrigin(boxOrigin);
 
   LayoutUnit width = m_inlineTextBox.logicalWidth();
   if (m_inlineTextBox.truncation() != cNoTruncation) {
     bool ltr = m_inlineTextBox.isLeftToRightDirection();
     bool flowIsLTR =
         m_inlineTextBox.getLineLayoutItem().style()->isLeftToRightDirection();
     width = LayoutUnit(m_inlineTextBox.getLineLayoutItem().width(
-        ltr == flowIsLTR ? m_inlineTextBox.start()
-                         : m_inlineTextBox.truncation(),
+        ltr == flowIsLTR
+            ? m_inlineTextBox.start()
+            : m_inlineTextBox.start() + m_inlineTextBox.truncation(),
         ltr == flowIsLTR ? m_inlineTextBox.truncation()
                          : m_inlineTextBox.len() - m_inlineTextBox.truncation(),
         m_inlineTextBox.textPos(),
         flowIsLTR ? TextDirection::Ltr : TextDirection::Rtl,
         m_inlineTextBox.isFirstLineStyle()));
     if (!flowIsLTR)
       localOrigin.move(m_inlineTextBox.logicalWidth() - width, LayoutUnit());
   }
 
   LayoutObject& textBoxLayoutObject = inlineLayoutObject();
@@ skipping 223 matching lines @@
 
   LayoutRect boxRect(boxOrigin, LayoutSize(m_inlineTextBox.logicalWidth(),
                                            m_inlineTextBox.logicalHeight()));
   context.clip(FloatRect(boxRect));
   context.drawHighlightForText(font, run, FloatPoint(boxOrigin),
                                boxRect.height().toInt(), color,
                                paintOffsets.first, paintOffsets.second);
 }
 
 }  // namespace blink