Making Unicode character names consistent

Source/core/editing/iterators/TextIterator.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2005 Alexey Proskuryakov.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 406 matching lines @@
     Text* textNode = toText(m_node);
     LayoutText* layoutObject = textNode->layoutObject();
 
     m_lastTextNode = textNode;
     String str = layoutObject->text();
 
     // handle pre-formatted text
     if (!layoutObject->style()->collapseWhiteSpace()) {
         int runStart = m_offset;
         if (m_lastTextNodeEndedWithCollapsedSpace && hasVisibleTextNode(layoutObject)) {
-            emitCharacter(space, textNode, 0, runStart, runStart);
+            emitCharacter(spaceCharacter, textNode, 0, runStart, runStart);
             return false;
         }
         if (!m_handledFirstLetter && layoutObject->isTextFragment() && !m_offset) {
             handleTextNodeFirstLetter(toLayoutTextFragment(layoutObject));
             if (m_firstLetterText) {
                 String firstLetter = m_firstLetterText->text();
                 emitText(textNode, m_firstLetterText, m_offset, m_offset + firstLetter.length());
                 m_firstLetterText = nullptr;
                 m_textBox = 0;
                 return false;
@@ skipping 63 matching lines @@
             InlineTextBox* firstTextBox = layoutObject->containsReversedText() ? (m_sortedTextBoxes.isEmpty() ? 0 : m_sortedTextBoxes[0]) : layoutObject->firstTextBox();
             bool needSpace = m_lastTextNodeEndedWithCollapsedSpace
                 || (m_textBox == firstTextBox && textBoxStart == runStart && runStart > 0);
             if (needSpace && !layoutObject->style()->isCollapsibleWhiteSpace(m_textState.lastCharacter()) && m_textState.lastCharacter()) {
                 if (m_lastTextNode == m_node && runStart > 0 && str[runStart - 1] == ' ') {
                     unsigned spaceRunStart = runStart - 1;
                     while (spaceRunStart > 0 && str[spaceRunStart - 1] == ' ')
                         --spaceRunStart;
                     emitText(m_node, layoutObject, spaceRunStart, spaceRunStart + 1);
                 } else {
-                    emitCharacter(space, m_node, 0, runStart, runStart);
+                    emitCharacter(spaceCharacter, m_node, 0, runStart, runStart);
                 }
                 return;
             }
             unsigned textBoxEnd = textBoxStart + m_textBox->len();
             unsigned runEnd = std::min(textBoxEnd, end);
 
             // Determine what the next text box will be, but don't advance yet
             InlineTextBox* nextTextBox = nullptr;
             if (layoutObject->containsReversedText()) {
                 if (m_sortedTextBoxesPosition + 1 < m_sortedTextBoxes.size())
@@ skipping 11 matching lines @@
                 m_textBox = 0;
                 return;
             }
             ASSERT(!nextTextBox || nextTextBox->layoutObject() == layoutObject);
 
             if (runStart < runEnd) {
                 // Handle either a single newline character (which becomes a space),
                 // or a run of characters that does not include a newline.
                 // This effectively translates newlines to spaces without copying the text.
                 if (str[runStart] == '\n') {
-                    emitCharacter(space, m_node, 0, runStart, runStart + 1);
+                    emitCharacter(spaceCharacter, m_node, 0, runStart, runStart + 1);
                     m_offset = runStart + 1;
                 } else {
                     size_t subrunEnd = str.find('\n', runStart);
                     if (subrunEnd == kNotFound || subrunEnd > runEnd)
                         subrunEnd = runEnd;
 
                     m_offset = subrunEnd;
                     emitText(m_node, layoutObject, runStart, subrunEnd);
                 }
 
@@ skipping 77 matching lines @@
     LayoutObject* layoutObject = m_node->layoutObject();
     if (layoutObject->style()->visibility() != VISIBLE && !ignoresStyleVisibility())
         return false;
 
     if (emitsObjectReplacementCharacter()) {
         emitCharacter(objectReplacementCharacter, Strategy::parent(*m_node), m_node, 0, 1);
         return true;
     }
 
     if (m_lastTextNodeEndedWithCollapsedSpace) {
-        emitCharacter(space, Strategy::parent(*m_lastTextNode), m_lastTextNode, 1, 1);
+        emitCharacter(spaceCharacter, Strategy::parent(*m_lastTextNode), m_lastTextNode, 1, 1);
         return false;
     }
 
     if (entersTextControls() && layoutObject->isTextControl()) {
         // The shadow tree should be already visited.
         return true;
     }
 
     if (emitsCharactersBetweenAllVisiblePositions()) {
         // We want replaced elements to behave like punctuation for boundary
@@ skipping 216 matching lines @@
     // on m_node to see if it necessitates emitting a character first and will early return
     // before encountering shouldRepresentNodeOffsetZero()s worse case behavior.
     if (shouldEmitTabBeforeNode(m_node)) {
         if (shouldRepresentNodeOffsetZero())
             emitCharacter('\t', Strategy::parent(*m_node), m_node, 0, 0);
     } else if (shouldEmitNewlineBeforeNode(*m_node)) {
         if (shouldRepresentNodeOffsetZero())
             emitCharacter('\n', Strategy::parent(*m_node), m_node, 0, 0);
     } else if (shouldEmitSpaceBeforeAndAfterNode(m_node)) {
         if (shouldRepresentNodeOffsetZero())
-            emitCharacter(space, Strategy::parent(*m_node), m_node, 0, 0);
+            emitCharacter(spaceCharacter, Strategy::parent(*m_node), m_node, 0, 0);
     }
 }
 
 
 template<typename Strategy>
 bool TextIteratorAlgorithm<Strategy>::handleNonTextNode()
 {
     if (shouldEmitNewlineForNode(m_node, emitsOriginalText()))
         emitCharacter('\n', Strategy::parent(*m_node), m_node, 0, 1);
     else if (emitsCharactersBetweenAllVisiblePositions() && m_node->layoutObject() && m_node->layoutObject()->isHR())
-        emitCharacter(space, Strategy::parent(*m_node), m_node, 0, 1);
+        emitCharacter(spaceCharacter, Strategy::parent(*m_node), m_node, 0, 1);
     else
         representNodeOffsetZero();
 
     return true;
 }
 
 template<typename Strategy>
 void TextIteratorAlgorithm<Strategy>::exitNode()
 {
     // prevent emitting a newline when exiting a collapsed block at beginning of the range
@@ skipping 13 matching lines @@
     // TextIterator in _web_attributedStringFromRange.
     // See <rdar://problem/5428427> for an example of how this mismatch will cause problems.
     if (m_lastTextNode && shouldEmitNewlineAfterNode(*m_node)) {
         // use extra newline to represent margin bottom, as needed
         bool addNewline = shouldEmitExtraNewlineForNode(m_node);
 
         // FIXME: We need to emit a '\n' as we leave an empty block(s) that
         // contain a VisiblePosition when doing selection preservation.
         if (m_textState.lastCharacter() != '\n') {
             // insert a newline with a position following this block's contents.
-            emitCharacter('\n', Strategy::parent(*baseNode), baseNode, 1, 1);
+            emitCharacter(newlineCharacter, Strategy::parent(*baseNode), baseNode, 1, 1);
             // remember whether to later add a newline for the current node
             ASSERT(!m_needsAnotherNewline);
             m_needsAnotherNewline = addNewline;
         } else if (addNewline) {
             // insert a newline with a position following this block's contents.
-            emitCharacter('\n', Strategy::parent(*baseNode), baseNode, 1, 1);
+            emitCharacter(newlineCharacter, Strategy::parent(*baseNode), baseNode, 1, 1);
         }
     }
 
     // If nothing was emitted, see if we need to emit a space.
     if (!m_textState.positionNode() && shouldEmitSpaceBeforeAndAfterNode(m_node))
-        emitCharacter(space, Strategy::parent(*baseNode), baseNode, 1, 1);
+        emitCharacter(spaceCharacter, Strategy::parent(*baseNode), baseNode, 1, 1);
 }
 
 template<typename Strategy>
 void TextIteratorAlgorithm<Strategy>::emitCharacter(UChar c, Node* textNode, Node* offsetBaseNode, int textStartOffset, int textEndOffset)
 {
     // Since m_lastTextNodeEndedWithCollapsedSpace seems better placed in
     // TextIterator, but is always reset when we call emitCharacter, we
     // wrap TextIteratorTextState::emitCharacter() with this function.
     m_textState.emitCharacter(c, textNode, offsetBaseNode, textStartOffset, textEndOffset);
     m_lastTextNodeEndedWithCollapsedSpace = false;
@@ skipping 155 matching lines @@
 
 String plainText(const PositionInComposedTree& start, const PositionInComposedTree& end, TextIteratorBehaviorFlags behavior)
 {
     return createPlainText<EditingInComposedTreeStrategy>(start, end, behavior);
 }
 
 template class CORE_EXPORT TextIteratorAlgorithm<EditingStrategy>;
 template class CORE_EXPORT TextIteratorAlgorithm<EditingInComposedTreeStrategy>;
 
 } // namespace blink