Using fullstop Unicode if horizontal ellipsis not present

Source/core/rendering/RenderBlockLineLayout.cpp

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All right reserved.
  * Copyright (C) 2010 Google 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 1919 matching lines @@
             else
                 curr->adjustLogicalPosition(-(curr->logicalLeft() - logicalLeft), 0);
         }
         firstLine = false;
     }
 }
 
 void RenderBlockFlow::checkLinesForTextOverflow()
 {
     // Determine the width of the ellipsis using the current font.
-    // FIXME: CSS3 says this is configurable, also need to use 0x002E (FULL STOP) if horizontal ellipsis is "not renderable"
     const Font& font = style()->font();
+
+    const UChar fullStopString[] = {fullstopCharacter, fullstopCharacter, fullstopCharacter};
+    DEFINE_STATIC_LOCAL(AtomicString, fullstopCharacterStr, (fullStopString, 3));
     DEFINE_STATIC_LOCAL(AtomicString, ellipsisStr, (&horizontalEllipsis, 1));
+
     const Font& firstLineFont = firstLineStyle()->font();
     // FIXME: We should probably not hard-code the direction here. https://crbug.com/333004
     TextDirection ellipsisDirection = LTR;
-    float firstLineEllipsisWidth = firstLineFont.width(constructTextRun(this, firstLineFont, &horizontalEllipsis, 1, firstLineStyle(), ellipsisDirection));
-    float ellipsisWidth = (font == firstLineFont) ? firstLineEllipsisWidth : font.width(constructTextRun(this, font, &horizontalEllipsis, 1, style(), ellipsisDirection));
+    float firstLineEllipsisWidth = 0;
+    float ellipsisWidth = 0;
+    bool useHorizontalEllipsis = true;
+
+    // As per CSS3 http://www.w3.org/TR/2003/CR-css3-text-20030514/ sequence of three
+    // Full Stops (002E) can be used.
+    if (firstLineFont.primaryFontHasGlyphForCharacter(horizontalEllipsis)) {
+        firstLineEllipsisWidth = firstLineFont.width(constructTextRun(this, firstLineFont, &horizontalEllipsis, 1, firstLineStyle(), ellipsisDirection));
+    } else {
+        useHorizontalEllipsis = false;
+        firstLineEllipsisWidth = firstLineFont.width(constructTextRun(this, firstLineFont, fullStopString, 1, firstLineStyle(), ellipsisDirection));
+    }
+    ellipsisWidth = (font == firstLineFont) ? firstLineEllipsisWidth : 0;
+
+    if (!ellipsisWidth) {
+        if (font.primaryFontHasGlyphForCharacter(horizontalEllipsis))
+            ellipsisWidth = font.width(constructTextRun(this, font, &horizontalEllipsis, 1, style(), ellipsisDirection));
+        else

[Dominik Röttsches, 2015/01/08 13:02:25]

I think you might be missing useHorizontalEllipsis = false; here - or you might
even need two variables of the kind, if the firstLineFont != font and one has an
ellipsis glyph and the other one doesn't (see below). 

But instead of introducing more booleans, it may be better to not use the
boolean but instead use one additional AtomicString& reference to denote the
string that gets used - more similar to your first approach but without
overriding a static local.

+            ellipsisWidth = font.width(constructTextRun(this, font, fullStopString, 1, style(), ellipsisDirection));
+    }
 
     // For LTR text truncation, we want to get the right edge of our padding box, and then we want to see
     // if the right edge of a line box exceeds that.  For RTL, we use the left edge of the padding box and
     // check the left edge of the line box to see if it is less
     // Include the scrollbar for overflow blocks, which means we want to use "contentWidth()"
     bool ltr = style()->isLeftToRightDirection();
     ETextAlign textAlign = style()->textAlign();
     bool firstLine = true;
     for (RootInlineBox* curr = firstRootBox(); curr; curr = curr->nextRootBox()) {
         float currLogicalLeft = curr->logicalLeft();
         LayoutUnit blockRightEdge = logicalRightOffsetForLine(curr->lineTop(), firstLine);
         LayoutUnit blockLeftEdge = logicalLeftOffsetForLine(curr->lineTop(), firstLine);
         LayoutUnit lineBoxEdge = ltr ? currLogicalLeft + curr->logicalWidth() : currLogicalLeft;
         if ((ltr && lineBoxEdge > blockRightEdge) || (!ltr && lineBoxEdge < blockLeftEdge)) {
             // This line spills out of our box in the appropriate direction.  Now we need to see if the line
             // can be truncated.  In order for truncation to be possible, the line must have sufficient space to
             // accommodate our truncation string, and no replaced elements (images, tables) can overlap the ellipsis
             // space.
 
             LayoutUnit width = firstLine ? firstLineEllipsisWidth : ellipsisWidth;
             LayoutUnit blockEdge = ltr ? blockRightEdge : blockLeftEdge;
             if (curr->lineCanAccommodateEllipsis(ltr, blockEdge, lineBoxEdge, width)) {
-                float totalLogicalWidth = curr->placeEllipsis(ellipsisStr, ltr, blockLeftEdge.toFloat(), blockRightEdge.toFloat(), width.toFloat());
+                float totalLogicalWidth = 0;
+                if (useHorizontalEllipsis)
+                    totalLogicalWidth = curr->placeEllipsis(ellipsisStr, ltr, blockLeftEdge.toFloat(), blockRightEdge.toFloat(), width.toFloat());

[Dominik Röttsches, 2015/01/08 13:02:25]

Does this code need to differentiate between firstLineFont and font?

+                else
+                    totalLogicalWidth = curr->placeEllipsis(fullstopCharacterStr, ltr, blockLeftEdge.toFloat(), blockRightEdge.toFloat(), width.toFloat());
 
                 float logicalLeft = 0; // We are only intersted in the delta from the base position.
                 float availableLogicalWidth = (blockRightEdge - blockLeftEdge).toFloat();
                 updateLogicalWidthForAlignment(textAlign, curr, 0, logicalLeft, totalLogicalWidth, availableLogicalWidth, 0);
                 if (ltr)
                     curr->adjustLogicalPosition(logicalLeft, 0);
                 else
                     curr->adjustLogicalPosition(logicalLeft - (availableLogicalWidth - totalLogicalWidth), 0);
             }
         }
@@ skipping 64 matching lines @@
     float logicalLeft = logicalLeftOffsetForLine(logicalHeight(), false).toFloat();
     float availableLogicalWidth = logicalRightOffsetForLine(logicalHeight(), false) - logicalLeft;
     updateLogicalWidthForAlignment(textAlign, 0, 0, logicalLeft, totalLogicalWidth, availableLogicalWidth, 0);
 
     if (!style()->isLeftToRightDirection())
         return logicalWidth() - logicalLeft;
     return logicalLeft;
 }
 
 }