Rename RenderText member variables to better reflect what they do.

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 123 matching lines @@
 
 RenderText::RenderText(Node* node, PassRefPtr<StringImpl> str)
     : RenderObject(!node || node->isDocumentNode() ? 0 : node)
     , m_hasTab(false)
     , m_linesDirty(false)
     , m_containsReversedText(false)
     , m_knownToHaveNoOverflowAndNoFallbackFonts(false)
     , m_needsTranscoding(false)
     , m_minWidth(-1)
     , m_maxWidth(-1)
-    , m_beginMinWidth(0)
-    , m_endMinWidth(0)
+    , m_firstLineMinWidth(0)
+    , m_lastLineLineMinWidth(0)
     , m_text(str)
     , m_firstTextBox(0)
     , m_lastTextBox(0)
 {
     ASSERT(m_text);
     // FIXME: Some clients of RenderText (and subclasses) pass Document as node to create anonymous renderer.
     // They should be switched to passing null and using setDocumentForAnonymous.
     if (node && node->isDocumentNode())
         setDocumentForAnonymous(toDocument(node));
 
@@ skipping 605 matching lines @@
     run.setCharactersLength(textLength() - start);
     ASSERT(run.charactersLength() >= run.length());
 
     run.setCharacterScanForCodePath(!canUseSimpleFontCodePath());
     run.setTabSize(!style()->collapseWhiteSpace(), style()->tabSize());
     run.setXPos(xPos);
     return f.width(run, fallbackFonts, glyphOverflow);
 }
 
 void RenderText::trimmedPrefWidths(float leadWidth,
-                                   float& beginMinW, bool& beginWS,
-                                   float& endMinW, bool& endWS,
-                                   bool& hasBreakableChar, bool& hasBreak,
-                                   float& beginMaxW, float& endMaxW,
-                                   float& minW, float& maxW, bool& stripFrontSpaces)
+    float& firstLineMinWidth, bool& hasBreakableStart,
+    float& lastLineMinWidth, bool& hasBreakableEnd,
+    bool& hasBreakableChar, bool& hasBreak,
+    float& firstLineMaxWidth, float& lastLineMaxWidth,
+    float& minWidth, float& maxWidth, bool& stripFrontSpaces)
 {
     bool collapseWhiteSpace = style()->collapseWhiteSpace();
     if (!collapseWhiteSpace)
         stripFrontSpaces = false;
 
     if (m_hasTab || preferredLogicalWidthsDirty())
         computePreferredLogicalWidths(leadWidth);
 
-    beginWS = !stripFrontSpaces && m_hasBeginWS;
-    endWS = m_hasEndWS;
+    hasBreakableStart = !stripFrontSpaces && m_hasBreakableStart;
+    hasBreakableEnd = m_hasBreakableEnd;
 
     int len = textLength();
 
     if (!len || (stripFrontSpaces && text()->containsOnlyWhitespace())) {
-        beginMinW = 0;
-        endMinW = 0;
-        beginMaxW = 0;
-        endMaxW = 0;
-        minW = 0;
-        maxW = 0;
+        firstLineMinWidth = 0;
+        lastLineMinWidth = 0;
+        firstLineMaxWidth = 0;
+        lastLineMaxWidth = 0;
+        minWidth = 0;
+        maxWidth = 0;
         hasBreak = false;
         return;
     }
 
-    minW = m_minWidth;
-    maxW = m_maxWidth;
+    minWidth = m_minWidth;
+    maxWidth = m_maxWidth;
 
-    beginMinW = m_beginMinWidth;
-    endMinW = m_endMinWidth;
+    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') {
         const Font& font = style()->font(); // FIXME: This ignores first-line.
         if (stripFrontSpaces) {
             const UChar space = ' ';
             float spaceWidth = font.width(RenderBlock::constructTextRun(this, font, &space, 1, style()));
-            maxW -= spaceWidth;
-        } else
-            maxW += font.wordSpacing();
+            maxWidth -= spaceWidth;
+        } else {
+            maxWidth += font.wordSpacing();
+        }
     }
 
-    stripFrontSpaces = collapseWhiteSpace && m_hasEndWS;
+    stripFrontSpaces = collapseWhiteSpace && m_hasBreakableEnd;
 
-    if (!style()->autoWrap() || minW > maxW)
-        minW = maxW;
+    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;
-        beginMaxW = maxW;
-        endMaxW = maxW;
+        firstLineMaxWidth = maxWidth;
+        lastLineMaxWidth = maxWidth;
         for (int i = 0; i < len; i++) {
             int linelen = 0;
             while (i + linelen < len && text[i + linelen] != '\n')
                 linelen++;
 
             if (linelen) {
-                endMaxW = widthFromCache(f, i, linelen, leadWidth + endMaxW, 0, 0);
+                lastLineMaxWidth = widthFromCache(f, i, linelen, leadWidth + lastLineMaxWidth, 0, 0);
                 if (firstLine) {
                     firstLine = false;
                     leadWidth = 0;
-                    beginMaxW = endMaxW;
+                    firstLineMaxWidth = lastLineMaxWidth;
                 }
                 i += linelen;
             } else if (firstLine) {
-                beginMaxW = 0;
+                firstLineMaxWidth = 0;
                 firstLine = false;
                 leadWidth = 0;
             }
 
-            if (i == len - 1)
+            if (i == len - 1) {
                 // A <pre> run that ends with a newline, as in, e.g.,
                 // <pre>Some text\n\n<span>More text</pre>
-                endMaxW = 0;
+                lastLineMaxWidth = 0;
+            }
         }
     }
 }
 
 float RenderText::minLogicalWidth() const
 {
     if (preferredLogicalWidthsDirty())
         const_cast<RenderText*>(this)->computePreferredLogicalWidths(0);
         
     return m_minWidth;
@@ skipping 60 matching lines @@
     }
 
     return maxFragmentWidth;
 }
 
 void RenderText::computePreferredLogicalWidths(float leadWidth, HashSet<const SimpleFontData*>& fallbackFonts, GlyphOverflow& glyphOverflow)
 {
     ASSERT(m_hasTab || preferredLogicalWidthsDirty() || !m_knownToHaveNoOverflowAndNoFallbackFonts);
 
     m_minWidth = 0;
-    m_beginMinWidth = 0;
-    m_endMinWidth = 0;
     m_maxWidth = 0;
+    m_firstLineMinWidth = 0;
+    m_lastLineLineMinWidth = 0;
 
     if (isBR())
         return;
 
     float currMinWidth = 0;
     float currMaxWidth = 0;
     m_hasBreakableChar = false;
     m_hasBreak = false;
     m_hasTab = false;
-    m_hasBeginWS = false;
-    m_hasEndWS = false;
+    m_hasBreakableStart = false;
+    m_hasBreakableEnd = false;
 
     RenderStyle* styleToUse = style();
     const Font& f = styleToUse->font(); // FIXME: This ignores first-line.
     float wordSpacing = styleToUse->wordSpacing();
     int len = textLength();
     LazyLineBreakIterator breakIterator(m_text, styleToUse->locale());
     bool needsWordSpacing = false;
     bool ignoringSpaces = false;
     bool isSpace = false;
     bool firstWord = true;
@@ skipping 43 matching lines @@
         } else if (c == '\t') {
             if (!styleToUse->collapseWhiteSpace()) {
                 m_hasTab = true;
                 isSpace = false;
             } else
                 isSpace = true;
         } else
             isSpace = c == ' ';
 
         if ((isSpace || isNewline) && !i)
-            m_hasBeginWS = true;
+            m_hasBreakableStart = true;
         if ((isSpace || isNewline) && i == len - 1)
-            m_hasEndWS = true;
+            m_hasBreakableEnd = true;
 
         if (!ignoringSpaces && styleToUse->collapseWhiteSpace() && previousCharacterIsSpace && isSpace)
             ignoringSpaces = true;
 
         if (ignoringSpaces && !isSpace)
             ignoringSpaces = false;
 
         // Ignore spaces and soft hyphens
         if (ignoringSpaces) {
             ASSERT(lastWordBoundary == i);
@@ skipping 74 matching lines @@
             if (wordSpacing && (isSpace || isCollapsibleWhiteSpace) && !containsOnlyWhitespace(j, len-j))
                 currMaxWidth += wordSpacing;
 
             if (firstWord) {
                 firstWord = false;
                 // If the first character in the run is breakable, then we consider ourselves to have a beginning
                 // minimum width of 0, since a break could occur right before our run starts, preventing us from ever
                 // being appended to a previous text run when considering the total minimum width of the containing block.
                 if (hasBreak)
                     m_hasBreakableChar = true;
-                m_beginMinWidth = hasBreak ? 0 : currMinWidth;
+                m_firstLineMinWidth = hasBreak ? 0 : currMinWidth;
             }
-            m_endMinWidth = currMinWidth;
+            m_lastLineLineMinWidth = currMinWidth;
 
             if (currMinWidth > m_minWidth)
                 m_minWidth = currMinWidth;
             currMinWidth = 0;
 
             i += wordLen - 1;
         } else {
             // Nowrap can never be broken, so don't bother setting the
             // breakable character boolean. Pre can only be broken if we encounter a newline.
             if (style()->autoWrap() || isNewline)
                 m_hasBreakableChar = true;
 
             if (currMinWidth > m_minWidth)
                 m_minWidth = currMinWidth;
             currMinWidth = 0;
 
             if (isNewline) { // Only set if preserveNewline was true and we saw a newline.
                 if (firstLine) {
                     firstLine = false;
                     leadWidth = 0;
                     if (!styleToUse->autoWrap())
-                        m_beginMinWidth = currMaxWidth;
+                        m_firstLineMinWidth = currMaxWidth;
                 }
 
                 if (currMaxWidth > m_maxWidth)
                     m_maxWidth = currMaxWidth;
                 currMaxWidth = 0;
             } else {
                 TextRun run = RenderBlock::constructTextRun(this, f, this, i, 1, styleToUse);
                 run.setCharactersLength(len - i);
                 ASSERT(run.charactersLength() >= run.length());
                 run.setTabSize(!style()->collapseWhiteSpace(), style()->tabSize());
@@ skipping 15 matching lines @@
         currMaxWidth += wordSpacing;
 
     m_minWidth = max(currMinWidth, m_minWidth);
     m_maxWidth = max(currMaxWidth, m_maxWidth);
 
     if (!styleToUse->autoWrap())
         m_minWidth = m_maxWidth;
 
     if (styleToUse->whiteSpace() == PRE) {
         if (firstLine)
-            m_beginMinWidth = m_maxWidth;
-        m_endMinWidth = currMaxWidth;
+            m_firstLineMinWidth = m_maxWidth;
+        m_lastLineLineMinWidth = currMaxWidth;
     }
 
     setPreferredLogicalWidthsDirty(false);
 }
 
 bool RenderText::isAllCollapsibleWhitespace() const
 {
     unsigned length = textLength();
     if (is8Bit()) {
         for (unsigned i = 0; i < length; ++i) {
@@ skipping 746 matching lines @@
 void RenderText::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
     MemoryClassInfo info(memoryObjectInfo, this, PlatformMemoryTypes::Rendering);
     RenderObject::reportMemoryUsage(memoryObjectInfo);
     info.addMember(m_text, "text");
     info.addMember(m_firstTextBox, "firstTextBox");
     info.addMember(m_lastTextBox, "lastTextBox");
 }
 
 } // namespace WebCore