This is code readability patch, No Layout Test case needed

Source/core/rendering/RenderText.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 ? ' ' : previous;
+    stringWithPrevious[0] = previous == noBreakSpace ? space : 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] = ' ';
+            stringWithPrevious[i] = space;
         else
             stringWithPrevious[i] = input[i - 1];
     }
 
     TextBreakIterator* boundary = wordBreakIterator(stringWithPrevious.characters(), length + 1);
     if (!boundary)
         return;
 
     StringBuilder result;
     result.reserveCapacity(length);
@@ skipping 185 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(' ');
+            plainTextBuilder.append(space);
     }
     return plainTextBuilder.toString();
 }
 
 void RenderText::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const
 {
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
         rects.append(enclosingIntRect(FloatRect(accumulatedOffset + box->topLeft(), box->size())));
 }
 
@@ skipping 382 matching lines @@
     }
 
     if (f.isFixedPitch() && f.fontDescription().variant() == FontVariantNormal && m_isAllASCII && (!glyphOverflow || !glyphOverflow->computeBounds)) {
         float monospaceCharacterWidth = f.spaceWidth();
         float w = 0;
         bool isSpace;
         ASSERT(m_text);
         StringImpl& text = *m_text.impl();
         for (int i = start; i < start + len; i++) {
             char c = text[i];
-            if (c <= ' ') {
-                if (c == ' ' || c == '\n') {
+            if (c <= space) {
+                if (c == space || c == newlineCharacter) {
                     w += monospaceCharacterWidth;
                     isSpace = true;
-                } else if (c == '\t') {
+                } else if (c == characterTabulation) {
                     if (style()->collapseWhiteSpace()) {
                         w += monospaceCharacterWidth;
                         isSpace = true;
                     } else {
                         w += f.tabWidth(style()->tabSize(), xPos + w);
                         isSpace = false;
                     }
                 } else
                     isSpace = false;
             } else {
@@ skipping 52 matching lines @@
     maxWidth = 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] == ' ' || (text[0] == '\n' && !style()->preserveNewline()) || text[0] == '\t') {
+    if (text[0] == space || (text[0] == newlineCharacter && !style()->preserveNewline()) || text[0] == characterTabulation) {
         const Font& font = style()->font(); // FIXME: This ignores first-line.
         if (stripFrontSpaces) {
-            const UChar space = ' ';
-            float spaceWidth = font.width(constructTextRun(this, font, &space, 1, style(), direction));
+            const UChar spaceChar = space;
+            float spaceWidth = font.width(constructTextRun(this, font, &spaceChar, 1, style(), direction));
             maxWidth -= spaceWidth;
         } else {
             maxWidth += font.fontDescription().wordSpacing();
         }
     }
 
     stripFrontSpaces = collapseWhiteSpace && m_hasEndWhiteSpace;
 
     if (!style()->autoWrap() || minWidth > maxWidth)
         minWidth = maxWidth;
 
     // Compute our max widths by scanning the string for newlines.
     if (hasBreak) {
         const Font& f = style()->font(); // FIXME: This ignores first-line.
         bool firstLine = true;
         firstLineMaxWidth = maxWidth;
         lastLineMaxWidth = maxWidth;
         for (int i = 0; i < len; i++) {
             int linelen = 0;
-            while (i + linelen < len && text[i + linelen] != '\n')
+            while (i + linelen < len && text[i + linelen] != newlineCharacter)
                 linelen++;
 
             if (linelen) {
                 lastLineMaxWidth = widthFromCache(f, i, linelen, leadWidth + lastLineMaxWidth, direction, 0, 0);
                 if (firstLine) {
                     firstLine = false;
                     leadWidth = 0;
                     firstLineMaxWidth = lastLineMaxWidth;
                 }
                 i += linelen;
@@ skipping 112 matching lines @@
             while (i >= run->stop() || (run->next() && run->next()->direction() == run->direction()))
                 run = run->next();
 
             ASSERT(run);
             ASSERT(i <= run->stop());
             textDirection = run->direction();
         }
 
         bool previousCharacterIsSpace = isSpace;
         bool isNewline = false;
-        if (c == '\n') {
+        if (c == newlineCharacter) {
             if (styleToUse->preserveNewline()) {
                 m_hasBreak = true;
                 isNewline = true;
                 isSpace = false;
             } else
                 isSpace = true;
-        } else if (c == '\t') {
+        } else if (c == characterTabulation) {
             if (!styleToUse->collapseWhiteSpace()) {
                 m_hasTab = true;
                 isSpace = false;
             } else
                 isSpace = true;
-        } else
-            isSpace = c == ' ';
+        } else {
+            isSpace = c == space;
+        }
 
         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)
@@ skipping 11 matching lines @@
             currMaxWidth += widthFromCache(f, lastWordBoundary, i - lastWordBoundary, leadWidth + currMaxWidth, textDirection, &fallbackFonts, &glyphOverflow);
             if (firstGlyphLeftOverflow < 0)
                 firstGlyphLeftOverflow = glyphOverflow.left;
             lastWordBoundary = i + 1;
             continue;
         }
 
         bool hasBreak = breakAll || isBreakable(breakIterator, i, nextBreakable);
         bool betweenWords = true;
         int j = i;
-        while (c != '\n' && c != ' ' && c != '\t' && (c != softHyphen)) {
+        while (c != newlineCharacter && c != space && c != characterTabulation && (c != softHyphen)) {
             j++;
             if (j == len)
                 break;
             c = uncheckedCharacterAt(j);
             if (isBreakable(breakIterator, j, nextBreakable) && characterAt(j - 1) != softHyphen)
                 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 == ' ';
+            bool isSpace = (j < len) && c == space;
 
             // 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;
                 wordTrailingSpaceWidth = cachedWordTrailingSpaceWidth[textDirection];
             }
@@ skipping 119 matching lines @@
     }
     return true;
 }
 
 bool RenderText::containsOnlyWhitespace(unsigned from, unsigned len) const
 {
     ASSERT(m_text);
     StringImpl& text = *m_text.impl();
     unsigned currPos;
     for (currPos = from;
-         currPos < from + len && (text[currPos] == '\n' || text[currPos] == ' ' || text[currPos] == '\t');
-         currPos++) { }
+    currPos < from + len && (text[currPos] == newlineCharacter || text[currPos] == space || text[currPos] == characterTabulation);
+    currPos++) { }
     return currPos >= (from + len);
 }
 
 FloatPoint RenderText::firstRunOrigin() const
 {
     return IntPoint(firstRunX(), firstRunY());
 }
 
 float RenderText::firstRunX() const
 {
@@ skipping 133 matching lines @@
     return toRenderText(o)->text().isEmpty();
 }
 
 UChar RenderText::previousCharacter() const
 {
     // find previous text renderer if one exists
     const RenderObject* previousText = previousInPreOrder();
     for (; previousText; previousText = previousText->previousInPreOrder())
         if (!isInlineFlowOrEmptyText(previousText))
             break;
-    UChar prev = ' ';
+    UChar prev = space;
     if (previousText && previousText->isText())
         if (StringImpl* previousString = toRenderText(previousText)->text().impl())
             prev = (*previousString)[previousString->length() - 1];
     return prev;
 }
 
 void RenderText::addLayerHitTestRects(LayerHitTestRects&, const RenderLayer* currentLayer, const LayoutPoint& layerOffset, const LayoutRect& containerRect) const
 {
     // Text nodes aren't event targets, so don't descend any further.
 }
@@ skipping 36 matching lines @@
             break;
         case TSDISC:
             secureText(bullet);
             break;
         case TSSQUARE:
             secureText(blackSquare);
         }
     }
 
     ASSERT(m_text);
-    ASSERT(!isBR() || (textLength() == 1 && m_text[0] == '\n'));
+    ASSERT(!isBR() || (textLength() == 1 && m_text[0] == newlineCharacter));
 
     m_isAllASCII = m_text.containsOnlyASCII();
     m_canUseSimpleFontCodePath = computeCanUseSimpleFontCodePath();
 }
 
 void RenderText::secureText(UChar mask)
 {
     if (!m_text.length())
         return;
 
@@ skipping 487 matching lines @@
     }
     secureTextTimer->restartWithNewText(lastTypedCharacterOffset);
 }
 
 PassRefPtr<AbstractInlineTextBox> RenderText::firstAbstractInlineTextBox()
 {
     return AbstractInlineTextBox::getOrCreate(this, m_firstTextBox);
 }
 
 } // namespace blink