SegmentedString::prepend should know if the prepended string is new or previously consumed

third_party/WebKit/Source/platform/text/SegmentedString.cpp

 /*
     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 69 matching lines @@
     ASSERT(c);
 
     // pushIfPossible attempts to rewind the pointer in the SegmentedSubstring,
     // however it will fail if the SegmentedSubstring is empty, or
     // when we prepended some text while consuming a SegmentedSubstring by document.write().
     if (m_currentString.pushIfPossible(c)) {
         m_currentChar = c;
         return;
     }
 
-    prepend(SegmentedString(String(&c, 1)));
+    prepend(SegmentedString(String(&c, 1)), PrependType::Unconsume);
 }
 
-void SegmentedString::prepend(const SegmentedSubstring& s)
+void SegmentedString::prepend(const SegmentedSubstring& s, PrependType type)
 {
     ASSERT(!s.numberOfCharactersConsumed());
     if (!s.length())
         return;
 
-    // FIXME: We're assuming that the prepend were originally consumed by
-    //        this SegmentedString. We're also ASSERTing that s is a fresh
-    //        SegmentedSubstring. These assumptions are sufficient for our
-    //        current use, but we might need to handle the more elaborate
-    //        cases in the future.
+    // FIXME: We're also ASSERTing that s is a fresh SegmentedSubstring.
+    //        The assumption is sufficient for our current use, but we might
+    //        need to handle the more elaborate cases in the future.
     m_numberOfCharactersConsumedPriorToCurrentString += m_currentString.numberOfCharactersConsumed();
-    m_numberOfCharactersConsumedPriorToCurrentString -= s.length();
+    if (type == PrependType::Unconsume)
+        m_numberOfCharactersConsumedPriorToCurrentString -= s.length();
     if (!m_currentString.length()) {
         m_currentString = s;
         updateAdvanceFunctionPointers();
     } else {
         // Shift our m_currentString into our list.
         m_substrings.prepend(m_currentString);
         m_currentString = s;
         updateAdvanceFunctionPointers();
     }
     m_empty = false;
@@ skipping 13 matching lines @@
     append(s.m_currentString);
     if (s.isComposite()) {
         Deque<SegmentedSubstring>::const_iterator it = s.m_substrings.begin();
         Deque<SegmentedSubstring>::const_iterator e = s.m_substrings.end();
         for (; it != e; ++it)
             append(*it);
     }
     m_currentChar = m_currentString.length() ? m_currentString.getCurrentChar() : 0;
 }
 
-void SegmentedString::prepend(const SegmentedString& s)
+void SegmentedString::prepend(const SegmentedString& s, PrependType type)
 {
     if (s.isComposite()) {
         Deque<SegmentedSubstring>::const_reverse_iterator it = s.m_substrings.rbegin();
         Deque<SegmentedSubstring>::const_reverse_iterator e = s.m_substrings.rend();
         for (; it != e; ++it)
-            prepend(*it);
+            prepend(*it, type);
     }
-    prepend(s.m_currentString);
+    prepend(s.m_currentString, type);
     m_currentChar = m_currentString.length() ? m_currentString.getCurrentChar() : 0;
 }
 
 void SegmentedString::advanceSubstring()
 {
     if (isComposite()) {
         m_numberOfCharactersConsumedPriorToCurrentString += m_currentString.numberOfCharactersConsumed();
         m_currentString = m_substrings.takeFirst();
         // If we've previously consumed some characters of the non-current
         // string, we now account for those characters as part of the current
@@ skipping 129 matching lines @@
     return OrdinalNumber::fromZeroBasedInt(zeroBasedColumn);
 }
 
 void SegmentedString::setCurrentPosition(OrdinalNumber line, OrdinalNumber columnAftreProlog, int prologLength)
 {
     m_currentLine = line.zeroBasedInt();
     m_numberOfCharactersConsumedPriorToCurrentLine = numberOfCharactersConsumed() + prologLength - columnAftreProlog.zeroBasedInt();
 }
 
 } // namespace blink