Making Unicode character names consistent

Source/core/layout/LayoutText.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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
@@ skipping 90 matching lines @@
     if (string->isNull())
         return;
 
     unsigned length = string->length();
     const StringImpl& input = *string->impl();
 
     if (length >= std::numeric_limits<unsigned>::max())
         CRASH();
 
     StringBuffer<UChar> stringWithPrevious(length + 1);
-    stringWithPrevious[0] = previous == noBreakSpace ? space : previous;
+    stringWithPrevious[0] = previous == noBreakSpaceCharacter ? spaceCharacter : previous;
     for (unsigned i = 1; i < length + 1; i++) {
         // Replace &nbsp with a real space since ICU no longer treats &nbsp as a word separator.
-        if (input[i - 1] == noBreakSpace)
-            stringWithPrevious[i] = space;
+        if (input[i - 1] == noBreakSpaceCharacter)
+            stringWithPrevious[i] = spaceCharacter;
         else
             stringWithPrevious[i] = input[i - 1];
     }
 
     TextBreakIterator* boundary = wordBreakIterator(stringWithPrevious.characters(), length + 1);
     if (!boundary)
         return;
 
     StringBuilder result;
     result.reserveCapacity(length);
 
     int32_t endOfWord;
     int32_t startOfWord = boundary->first();
     for (endOfWord = boundary->next(); endOfWord != TextBreakDone; startOfWord = endOfWord, endOfWord = boundary->next()) {
         if (startOfWord) // Ignore first char of previous string
-            result.append(input[startOfWord - 1] == noBreakSpace ? noBreakSpace : toTitleCase(stringWithPrevious[startOfWord]));
+            result.append(input[startOfWord - 1] == noBreakSpaceCharacter ? noBreakSpaceCharacter : toTitleCase(stringWithPrevious[startOfWord]));
         for (int i = startOfWord + 1; i < endOfWord; i++)
             result.append(input[i - 1]);
     }
 
     *string = result.toString();
 }
 
 LayoutText::LayoutText(Node* node, PassRefPtr<StringImpl> str)
     : LayoutObject(!node || node->isDocumentNode() ? 0 : node)
     , m_hasTab(false)
@@ skipping 165 matching lines @@
 {
     if (node())
         return blink::plainText(rangeOfContents(node()).get());
 
     // FIXME: this is just a stopgap until TextIterator is adapted to support generated text.
     StringBuilder plainTextBuilder;
     for (InlineTextBox* textBox = firstTextBox(); textBox; textBox = textBox->nextTextBox()) {
         String text = m_text.substring(textBox->start(), textBox->len()).simplifyWhiteSpace(WTF::DoNotStripWhiteSpace);
         plainTextBuilder.append(text);
         if (textBox->nextTextBox() && textBox->nextTextBox()->start() > textBox->end() && text.length() && !text.right(1).containsOnlyWhitespace())
-            plainTextBuilder.append(space);
+            plainTextBuilder.append(spaceCharacter);
     }
     return plainTextBuilder.toString();
 }
 
 void LayoutText::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const
 {
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
         rects.append(enclosingIntRect(FloatRect(FloatPoint(accumulatedOffset) + box->topLeft().toFloatPoint(), box->size().toFloatSize())));
 }
 
@@ skipping 433 matching lines @@
     floatMaxWidth = m_maxWidth;
 
     firstLineMinWidth = m_firstLineMinWidth;
     lastLineMinWidth = m_lastLineLineMinWidth;
 
     hasBreakableChar = m_hasBreakableChar;
     hasBreak = m_hasBreak;
 
     ASSERT(m_text);
     StringImpl& text = *m_text.impl();
-    if (text[0] == space || (text[0] == newlineCharacter && !style()->preserveNewline()) || text[0] == characterTabulation) {
+    if (text[0] == spaceCharacter || (text[0] == newlineCharacter && !style()->preserveNewline()) || text[0] == tabulationCharacter) {
         const Font& font = style()->font(); // FIXME: This ignores first-line.
         if (stripFrontSpaces) {
-            const UChar spaceChar = space;
+            const UChar spaceChar = spaceCharacter;
             TextRun run = constructTextRun(this, font, &spaceChar, 1, styleRef(), direction);
             run.setCodePath(canUseSimpleFontCodePath() ? TextRun::ForceSimple : TextRun::ForceComplex);
             float spaceWidth = font.width(run);
             floatMaxWidth -= spaceWidth;
         } else {
             floatMaxWidth += font.fontDescription().wordSpacing();
         }
     }
 
     stripFrontSpaces = collapseWhiteSpace && m_hasEndWhiteSpace;
@@ skipping 146 matching lines @@
         bool previousCharacterIsSpace = isSpace;
         bool isNewline = false;
         if (c == newlineCharacter) {
             if (styleToUse.preserveNewline()) {
                 m_hasBreak = true;
                 isNewline = true;
                 isSpace = false;
             } else {
                 isSpace = true;
             }
-        } else if (c == characterTabulation) {
+        } else if (c == tabulationCharacter) {
             if (!styleToUse.collapseWhiteSpace()) {
                 m_hasTab = true;
                 isSpace = false;
             } else {
                 isSpace = true;
             }
         } else {
-            isSpace = c == space;
+            isSpace = c == spaceCharacter;
         }
 
         bool isBreakableLocation = isNewline || (isSpace && styleToUse.autoWrap());
         if (!i)
             m_hasBreakableStart = isBreakableLocation;
         if (i == len - 1) {
             m_hasBreakableEnd = isBreakableLocation;
             m_hasEndWhiteSpace = isNewline || isSpace;
         }
 
         if (!ignoringSpaces && styleToUse.collapseWhiteSpace() && previousCharacterIsSpace && isSpace)
             ignoringSpaces = true;
 
         if (ignoringSpaces && !isSpace)
             ignoringSpaces = false;
 
         // Ignore spaces and soft hyphens
         if (ignoringSpaces) {
             ASSERT(lastWordBoundary == i);
             lastWordBoundary++;
             continue;
         }
-        if (c == softHyphen) {
+        if (c == softHyphenCharacter) {
             currMaxWidth += widthFromCache(f, lastWordBoundary, i - lastWordBoundary, leadWidth + currMaxWidth, textDirection, &fallbackFonts, &glyphOverflow);
             if (firstGlyphLeftOverflow < 0)
                 firstGlyphLeftOverflow = glyphOverflow.left;
             lastWordBoundary = i + 1;
             continue;
         }
 
         bool hasBreak = breakIterator.isBreakable(i, nextBreakable, breakAll ? LineBreakType::BreakAll : keepAll ? LineBreakType::KeepAll : LineBreakType::Normal);
         bool betweenWords = true;
         int j = i;
-        while (c != newlineCharacter && c != space && c != characterTabulation && (c != softHyphen)) {
+        while (c != newlineCharacter && c != spaceCharacter && c != tabulationCharacter && (c != softHyphenCharacter)) {
             j++;
             if (j == len)
                 break;
             c = uncheckedCharacterAt(j);
-            if (breakIterator.isBreakable(j, nextBreakable) && characterAt(j - 1) != softHyphen)
+            if (breakIterator.isBreakable(j, nextBreakable) && characterAt(j - 1) != softHyphenCharacter)
                 break;
             if (breakAll) {
                 betweenWords = false;
                 break;
             }
         }
 
         // Terminate word boundary at bidi run boundary.
         if (run)
             j = std::min(j, run->stop() + 1);
         int wordLen = j - i;
         if (wordLen) {
-            bool isSpace = (j < len) && c == space;
+            bool isSpace = (j < len) && c == spaceCharacter;
 
             // Non-zero only when kerning is enabled, in which case we measure words with their trailing
             // space, then subtract its width.
             float wordTrailingSpaceWidth = 0;
             if (isSpace && (f.fontDescription().typesettingFeatures() & Kerning)) {
                 ASSERT(textDirection >=0 && textDirection <= 1);
                 if (!cachedWordTrailingSpaceWidth[textDirection])
-                    cachedWordTrailingSpaceWidth[textDirection] = f.width(constructTextRun(this, f, &space, 1, styleToUse, textDirection)) + wordSpacing;
+                    cachedWordTrailingSpaceWidth[textDirection] = f.width(constructTextRun(this, f, &spaceCharacter, 1, styleToUse, textDirection)) + wordSpacing;
                 wordTrailingSpaceWidth = cachedWordTrailingSpaceWidth[textDirection];
             }
 
             float w;
             if (wordTrailingSpaceWidth && isSpace) {
                 w = widthFromCache(f, i, wordLen + 1, leadWidth + currMaxWidth, textDirection, &fallbackFonts, &glyphOverflow) - wordTrailingSpaceWidth;
             } else {
                 w = widthFromCache(f, i, wordLen, leadWidth + currMaxWidth, textDirection, &fallbackFonts, &glyphOverflow);
-                if (c == softHyphen)
+                if (c == softHyphenCharacter)
                     currMinWidth += hyphenWidth(this, f, textDirection);
             }
 
             if (firstGlyphLeftOverflow < 0)
                 firstGlyphLeftOverflow = glyphOverflow.left;
             currMinWidth += w;
             if (betweenWords) {
                 if (lastWordBoundary == i)
                     currMaxWidth += w;
                 else
@@ skipping 103 matching lines @@
     }
     return true;
 }
 
 bool LayoutText::containsOnlyWhitespace(unsigned from, unsigned len) const
 {
     ASSERT(m_text);
     StringImpl& text = *m_text.impl();
     unsigned currPos;
     for (currPos = from;
-    currPos < from + len && (text[currPos] == newlineCharacter || text[currPos] == space || text[currPos] == characterTabulation);
+    currPos < from + len && (text[currPos] == newlineCharacter || text[currPos] == spaceCharacter || text[currPos] == tabulationCharacter);
     currPos++) { }
     return currPos >= (from + len);
 }
 
 FloatPoint LayoutText::firstRunOrigin() const
 {
     return IntPoint(firstRunX(), firstRunY());
 }
 
 float LayoutText::firstRunX() const
@@ skipping 136 matching lines @@
 }
 
 UChar LayoutText::previousCharacter() const
 {
     // find previous text layoutObject if one exists
     const LayoutObject* previousText = previousInPreOrder();
     for (; previousText; previousText = previousText->previousInPreOrder()) {
         if (!isInlineFlowOrEmptyText(previousText))
             break;
     }
-    UChar prev = space;
+    UChar prev = spaceCharacter;
     if (previousText && previousText->isText()) {
         if (StringImpl* previousString = toLayoutText(previousText)->text().impl())
             prev = (*previousString)[previousString->length() - 1];
     }
     return prev;
 }
 
 void LayoutText::addLayerHitTestRects(LayerHitTestRects&, const DeprecatedPaintLayer* currentLayer, const LayoutPoint& layerOffset, const LayoutRect& containerRect) const
 {
     // Text nodes aren't event targets, so don't descend any further.
@@ skipping 26 matching lines @@
 
     if (style()) {
         applyTextTransform(style(), m_text, previousCharacter());
 
         // We use the same characters here as for list markers.
         // See the listMarkerText function in LayoutListMarker.cpp.
         switch (style()->textSecurity()) {
         case TSNONE:
             break;
         case TSCIRCLE:
-            secureText(whiteBullet);
+            secureText(whiteBulletCharacter);
             break;
         case TSDISC:
-            secureText(bullet);
+            secureText(bulletCharacter);
             break;
         case TSSQUARE:
-            secureText(blackSquare);
+            secureText(blackSquareCharacter);
         }
     }
 
     ASSERT(m_text);
     ASSERT(!isBR() || (textLength() == 1 && m_text[0] == newlineCharacter));
 
     m_canUseSimpleFontCodePath = computeCanUseSimpleFontCodePath();
 }
 
 void LayoutText::secureText(UChar mask)
@@ skipping 492 matching lines @@
 }
 
 void LayoutText::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const
 {
     LayoutObject::invalidateDisplayItemClients(paintInvalidationContainer);
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
         paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*box);
 }
 
 } // namespace blink