Changeset 65100 in webkit

Timestamp:

Aug 10, 2010 4:46:54 PM (14 years ago)

Author:

abarth@webkit.org

Message:

2010-08-10 Adam Barth <​abarth@webkit.org>

Reviewed by Eric Seidel.

SegmentedString should keep track of how many characters it consumes
​https://bugs.webkit.org/show_bug.cgi?id=43765

The easiest way to keep track of how many characters we've consumed
would be to increment a counter every time we advance, but that's too
slow. Instead, we keep track lazily and update our summary durning the
slow case of advance (which is sufficiently rare).

There's some subtly to how this works w.r.t. "unconsuming" characters
by pushing them back on the front of the segmented string. This isn't
really a "right answer" here because the notion of unconsuming input
isn't present in the API. This patch makes some assumptions about how
clients of this class use its API. In a future patch, we might want to
rename some of the method names to make this more explicit.

• platform/text/SegmentedString.cpp: (WebCore::SegmentedString::operator=): (WebCore::SegmentedString::append): (WebCore::SegmentedString::prepend): (WebCore::SegmentedString::advanceSubstring):
• platform/text/SegmentedString.h: (WebCore::SegmentedSubstring::numberOfCharactersConsumed): (WebCore::SegmentedString::SegmentedString): (WebCore::SegmentedString::numberOfCharactersConsumed):

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• platform/text/SegmentedString.cpp (modified) (4 diffs)
• platform/text/SegmentedString.h (modified) (4 diffs)

trunk/WebCore/ChangeLog

@@ +1 @@
+2010-08-10  Adam Barth  <abarth@webkit.org>
+
+        Reviewed by Eric Seidel.
+
+        SegmentedString should keep track of how many characters it consumes
+        https://bugs.webkit.org/show_bug.cgi?id=43765
+
+        The easiest way to keep track of how many characters we've consumed
+        would be to increment a counter every time we advance, but that's too
+        slow.  Instead, we keep track lazily and update our summary durning the
+        slow case of advance (which is sufficiently rare).
+
+        There's some subtly to how this works w.r.t. "unconsuming" characters
+        by pushing them back on the front of the segmented string.  This isn't
+        really a "right answer" here because the notion of unconsuming input
+        isn't present in the API.  This patch makes some assumptions about how
+        clients of this class use its API.  In a future patch, we might want to
+        rename some of the method names to make this more explicit.
+
+        * platform/text/SegmentedString.cpp:
+        (WebCore::SegmentedString::operator=):
+        (WebCore::SegmentedString::append):
+        (WebCore::SegmentedString::prepend):
+        (WebCore::SegmentedString::advanceSubstring):
+        * platform/text/SegmentedString.h:
+        (WebCore::SegmentedSubstring::numberOfCharactersConsumed):
+        (WebCore::SegmentedString::SegmentedString):
+        (WebCore::SegmentedString::numberOfCharactersConsumed):
+
 2010-08-10  Gavin Barraclough  <barraclough@apple.com>
 

trunk/WebCore/platform/text/SegmentedString.cpp

@@ -53 +53 @@
         m_currentChar = other.m_currentChar;
     m_closed = other.m_closed;
+    m_numberOfCharactersConsumedPriorToCurrentString = other.m_numberOfCharactersConsumedPriorToCurrentString;
     return *this;
 }
@@ -100 +101 @@
     if (s.m_length) {
         if (!m_currentString.m_length) {
+            m_numberOfCharactersConsumedPriorToCurrentString += m_currentString.numberOfCharactersConsumed();
             m_currentString = s;
         } else {
@@ -111 +113 @@
 {
     ASSERT(!escaped());
+    // FIXME: Add this ASSERT once we've deleted the LegacyHTMLDocumentParser.
+    // ASSERT(!s.numberOfCharactersConsumed());
     if (s.m_length) {
+        // 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.
+        m_numberOfCharactersConsumedPriorToCurrentString += m_currentString.numberOfCharactersConsumed();
+        m_numberOfCharactersConsumedPriorToCurrentString -= s.m_length;
         if (!m_currentString.m_length)
             m_currentString = s;
@@ -161 +172 @@
 {
     if (m_composite) {
+        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
+        // string, not as part of "prior to current string."
+        m_numberOfCharactersConsumedPriorToCurrentString -= m_currentString.numberOfCharactersConsumed();
         if (m_substrings.isEmpty())
             m_composite = false;

trunk/WebCore/platform/text/SegmentedString.h

@@ -46 +46 @@
     void setExcludeLineNumbers() { m_doNotExcludeLineNumbers = false; }
 
+    int numberOfCharactersConsumed() const { return m_string.length() - m_length; }
+
     void appendTo(String& str) const
     {
@@ -70 +72 @@
 public:
     SegmentedString()
-        : m_pushedChar1(0), m_pushedChar2(0), m_currentChar(0), m_composite(false), m_closed(false) {}
+        : m_pushedChar1(0)
+        , m_pushedChar2(0)
+        , m_currentChar(0)
+        , m_numberOfCharactersConsumedPriorToCurrentString(0)
+        , m_composite(false)
+        , m_closed(false)
+    {
+    }
+
     SegmentedString(const String& str)
-        : m_pushedChar1(0), m_pushedChar2(0), m_currentString(str)
-        , m_currentChar(m_currentString.m_current), m_composite(false), m_closed(false) {}
+        : m_pushedChar1(0)
+        , m_pushedChar2(0)
+        , m_currentString(str)
+        , m_currentChar(m_currentString.m_current)
+        , m_numberOfCharactersConsumedPriorToCurrentString(0)
+        , m_composite(false)
+        , m_closed(false)
+    {
+    }
+
     SegmentedString(const SegmentedString&);
 
@@ -173 +191 @@
 
     bool escaped() const { return m_pushedChar1; }
+
+    int numberOfCharactersConsumed()
+    {
+        // We don't currently handle the case when there are pushed character.
+        ASSERT(!m_pushedChar1);
+        return m_numberOfCharactersConsumedPriorToCurrentString + m_currentString.numberOfCharactersConsumed();
+    }
 
     String toString() const;
@@ -222 +247 @@
     SegmentedSubstring m_currentString;
     const UChar* m_currentChar;
+    int m_numberOfCharactersConsumedPriorToCurrentString;
     Deque<SegmentedSubstring> m_substrings;
     bool m_composite;