Make members of SegmentedSubstring private

Source/platform/text/SegmentedString.h

 /*
     Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple 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.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 107 matching lines @@
     }
 
     ALWAYS_INLINE UChar incrementAndGetCurrentChar()
     {
         ASSERT(m_length);
         if (is8Bit())
             return incrementAndGetCurrentChar8();
         return incrementAndGetCurrentChar16();
     }
 
-public:
+    ALWAYS_INLINE bool haveOneCharacterLeft() const
+    {
+        return m_length == 1;
+    }
+
+    ALWAYS_INLINE void decrementLength() { --m_length; }
+
+    ALWAYS_INLINE int length() const { return m_length; }
+
+private:
     union {
         const LChar* string8Ptr;
         const UChar* string16Ptr;
     } m_data;
     int m_length;
-
-private:
     bool m_doNotExcludeLineNumbers;
     bool m_is8Bit;
     String m_string;
 };
 
 class PLATFORM_EXPORT SegmentedString {
 public:
     SegmentedString()
         : m_pushedChar1(0)
         , m_pushedChar2(0)
@@ skipping 14 matching lines @@
         , m_pushedChar2(0)
         , m_currentString(str)
         , m_currentChar(0)
         , m_numberOfCharactersConsumedPriorToCurrentString(0)
         , m_numberOfCharactersConsumedPriorToCurrentLine(0)
         , m_currentLine(0)
         , m_closed(false)
         , m_empty(!str.length())
         , m_fastPathFlags(NoFastPath)
     {
-        if (m_currentString.m_length)
+        if (m_currentString.length())
             m_currentChar = m_currentString.getCurrentChar();
         updateAdvanceFunctionPointers();
     }
 
     void clear();
     void close();
 
     void append(const SegmentedString&);
     void prepend(const SegmentedString&);
 
@@ skipping 23 matching lines @@
         NotEnoughCharacters,
     };
 
     LookAheadResult lookAhead(const String& string) { return lookAheadInline(string, TextCaseSensitive); }
     LookAheadResult lookAheadIgnoringCase(const String& string) { return lookAheadInline(string, TextCaseInsensitive); }
 
     void advance()
     {
         if (m_fastPathFlags & Use8BitAdvance) {
             ASSERT(!m_pushedChar1);
-            bool haveOneCharacterLeft = (--m_currentString.m_length == 1);
             m_currentChar = m_currentString.incrementAndGetCurrentChar8();
-
-            if (!haveOneCharacterLeft)
+            m_currentString.decrementLength();
+            if (!m_currentString.haveOneCharacterLeft())
                 return;
 
             updateSlowCaseFunctionPointers();
 
             return;
         }
 
         (this->*m_advanceFunc)();
     }
 
     inline void advanceAndUpdateLineNumber()
     {
         if (m_fastPathFlags & Use8BitAdvance) {
             ASSERT(!m_pushedChar1);
 
             bool haveNewLine = (m_currentChar == '\n') & !!(m_fastPathFlags & Use8BitAdvanceAndUpdateLineNumbers);
-            bool haveOneCharacterLeft = (--m_currentString.m_length == 1);
-
             m_currentChar = m_currentString.incrementAndGetCurrentChar8();
-
-            if (!(haveNewLine | haveOneCharacterLeft))
-                return;
+            m_currentString.decrementLength();
+            bool haveOneCharacterLeft = m_currentString.haveOneCharacterLeft();
 
             if (haveNewLine) {
                 ++m_currentLine;
                 m_numberOfCharactersConsumedPriorToCurrentLine =  m_numberOfCharactersConsumedPriorToCurrentString + m_currentString.numberOfCharactersConsumed();
             }
 
             if (haveOneCharacterLeft)
                 updateSlowCaseFunctionPointers();
 
             return;
@@ skipping 16 matching lines @@
 
     void advancePastNonNewline()
     {
         ASSERT(currentChar() != '\n');
         advance();
     }
 
     void advancePastNewlineAndUpdateLineNumber()
     {
         ASSERT(currentChar() == '\n');
-        if (!m_pushedChar1 && m_currentString.m_length > 1) {
+        if (!m_pushedChar1 && m_currentString.length() > 1) {
             int newLineFlag = m_currentString.doNotExcludeLineNumbers();
             m_currentLine += newLineFlag;
             if (newLineFlag)
                 m_numberOfCharactersConsumedPriorToCurrentLine = numberOfCharactersConsumed() + 1;
             decrementAndCheckLength();
             m_currentChar = m_currentString.incrementAndGetCurrentChar();
             return;
         }
         advanceAndUpdateLineNumberSlowCase();
     }
@@ skipping 42 matching lines @@
     void advanceAndUpdateLineNumber16();
     void advanceSlowCase();
     void advanceAndUpdateLineNumberSlowCase();
     void advanceEmpty();
     void advanceSubstring();
 
     void updateSlowCaseFunctionPointers();
 
     void decrementAndCheckLength()
     {
-        ASSERT(m_currentString.m_length > 1);
-        if (--m_currentString.m_length == 1)
+        ASSERT(m_currentString.length() > 1);
+        m_currentString.decrementLength();
+        if (m_currentString.haveOneCharacterLeft())
             updateSlowCaseFunctionPointers();
     }
 
     void updateAdvanceFunctionPointers()
     {
-        if ((m_currentString.m_length > 1) && !m_pushedChar1) {
+        if ((m_currentString.length() > 1) && !m_pushedChar1) {
             if (m_currentString.is8Bit()) {
                 m_advanceFunc = &SegmentedString::advance8;
                 m_fastPathFlags = Use8BitAdvance;
                 if (m_currentString.doNotExcludeLineNumbers()) {
                     m_advanceAndUpdateLineNumberFunc = &SegmentedString::advanceAndUpdateLineNumber8;
                     m_fastPathFlags |= Use8BitAdvanceAndUpdateLineNumbers;
                 } else {
                     m_advanceAndUpdateLineNumberFunc = &SegmentedString::advance8;
                 }
                 return;
             }
 
             m_advanceFunc = &SegmentedString::advance16;
             m_fastPathFlags = NoFastPath;
             if (m_currentString.doNotExcludeLineNumbers())
                 m_advanceAndUpdateLineNumberFunc = &SegmentedString::advanceAndUpdateLineNumber16;
             else
                 m_advanceAndUpdateLineNumberFunc = &SegmentedString::advance16;
             return;
         }
 
-        if (!m_currentString.m_length && !isComposite()) {
+        if (!m_currentString.length() && !isComposite()) {
             m_advanceFunc = &SegmentedString::advanceEmpty;
             m_fastPathFlags = NoFastPath;
             m_advanceAndUpdateLineNumberFunc = &SegmentedString::advanceEmpty;
         }
 
         updateSlowCaseFunctionPointers();
     }
 
     inline LookAheadResult lookAheadInline(const String& string, TextCaseSensitivity caseSensitivity)
     {
-        if (!m_pushedChar1 && string.length() <= static_cast<unsigned>(m_currentString.m_length)) {
+        if (!m_pushedChar1 && string.length() <= static_cast<unsigned>(m_currentString.length())) {
             String currentSubstring = m_currentString.currentSubString(string.length());
             if (currentSubstring.startsWith(string, caseSensitivity))
                 return DidMatch;
             return DidNotMatch;
         }
         return lookAheadSlowCase(string, caseSensitivity);
     }
 
     LookAheadResult lookAheadSlowCase(const String& string, TextCaseSensitivity caseSensitivity)
     {
@@ skipping 23 matching lines @@
     bool m_closed;
     bool m_empty;
     unsigned char m_fastPathFlags;
     void (SegmentedString::*m_advanceFunc)();
     void (SegmentedString::*m_advanceAndUpdateLineNumberFunc)();
 };
 
 }
 
 #endif