Bug 662669 - nsCharSeparatedTokenizer/nsWhiteSpaceSeparatedTokenizer should use RangedPtr. r=Waldo
☠☠ backed out by 0415635dba49 ☠ ☠
authorSahil Chelaramani <Sahilc.2200@gmail.com>
Fri, 16 Aug 2013 09:18:13 -0400
changeset 142870 35afcb18f192a06f1ca5b672711af9723632c380
parent 142869 3b4b734eaa1af3aef432dc580aeffeb4d43c0af2
child 142871 d959083ba5f637f3be439102853c792fdc9ad690
push id25112
push userryanvm@gmail.com
push dateFri, 16 Aug 2013 19:33:41 +0000
treeherdermozilla-central@72800965e07b [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersWaldo
bugs662669
milestone26.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 662669 - nsCharSeparatedTokenizer/nsWhiteSpaceSeparatedTokenizer should use RangedPtr. r=Waldo
xpcom/ds/nsCharSeparatedTokenizer.h
xpcom/ds/nsWhitespaceTokenizer.h
--- a/xpcom/ds/nsCharSeparatedTokenizer.h
+++ b/xpcom/ds/nsCharSeparatedTokenizer.h
@@ -1,16 +1,18 @@
 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef __nsCharSeparatedTokenizer_h
 #define __nsCharSeparatedTokenizer_h
 
+#include "mozilla/RangedPtr.h"
+
 #include "nsDependentSubstring.h"
 #include "nsCRT.h"
 
 /**
  * This parses a SeparatorChar-separated string into tokens.
  * Whitespace surrounding tokens is not treated as part of tokens, however
  * whitespace inside a token is. If the final token is the empty string, it is
  * not returned.
@@ -39,37 +41,37 @@ public:
 
     nsCharSeparatedTokenizerTemplate(const nsSubstring& aSource,
                                      PRUnichar aSeparatorChar,
                                      uint32_t  aFlags = 0)
         : mFirstTokenBeganWithWhitespace(false),
           mLastTokenEndedWithWhitespace(false),
           mLastTokenEndedWithSeparator(false),
           mSeparatorChar(aSeparatorChar),
-          mFlags(aFlags)
+          mFlags(aFlags),
+          mIter(aSource.Data(), aSource.Length()),
+          mEnd(aSource.Data() + aSource.Length(), aSource.Data(),
+               aSource.Length())
     {
-        aSource.BeginReading(mIter);
-        aSource.EndReading(mEnd);
-
         // Skip initial whitespace
-        while (mIter != mEnd && IsWhitespace(*mIter)) {
+        while (mIter < mEnd && IsWhitespace(*mIter)) {
             mFirstTokenBeganWithWhitespace = true;
             ++mIter;
         }
     }
 
     /**
      * Checks if any more tokens are available.
      */
     bool hasMoreTokens()
     {
         NS_ASSERTION(mIter == mEnd || !IsWhitespace(*mIter),
                      "Should be at beginning of token if there is one");
 
-        return mIter != mEnd;
+        return mIter < mEnd;
     }
 
     bool firstTokenBeganWithWhitespace() const
     {
         return mFirstTokenBeganWithWhitespace;
     }
 
     bool lastTokenEndedWithSeparator() const
@@ -82,66 +84,67 @@ public:
         return mLastTokenEndedWithWhitespace;
     }
 
     /**
      * Returns the next token.
      */
     const nsDependentSubstring nextToken()
     {
-        nsSubstring::const_char_iterator end = mIter, begin = mIter;
+        mozilla::RangedPtr<const PRUnichar> tokenStart = mIter, tokenEnd = mIter;
 
         NS_ASSERTION(mIter == mEnd || !IsWhitespace(*mIter),
                      "Should be at beginning of token if there is one");
 
         // Search until we hit separator or end (or whitespace, if separator
         // isn't required -- see clause with 'break' below).
-        while (mIter != mEnd && *mIter != mSeparatorChar) {
+        while (mIter < mEnd && *mIter != mSeparatorChar) {
           // Skip to end of current word.
-          while (mIter != mEnd &&
+          while (mIter < mEnd &&
                  !IsWhitespace(*mIter) && *mIter != mSeparatorChar) {
               ++mIter;
           }
-          end = mIter;
+          tokenEnd = mIter;
 
           // Skip whitespace after current word.
           mLastTokenEndedWithWhitespace = false;
-          while (mIter != mEnd && IsWhitespace(*mIter)) {
+          while (mIter < mEnd && IsWhitespace(*mIter)) {
               mLastTokenEndedWithWhitespace = true;
               ++mIter;
           }
           if (mFlags & SEPARATOR_OPTIONAL) {
             // We've hit (and skipped) whitespace, and that's sufficient to end
             // our token, regardless of whether we've reached a SeparatorChar.
             break;
           } // (else, we'll keep looping until we hit mEnd or SeparatorChar)
         }
 
         mLastTokenEndedWithSeparator = (mIter != mEnd &&
                                         *mIter == mSeparatorChar);
         NS_ASSERTION((mFlags & SEPARATOR_OPTIONAL) ||
-                     (mLastTokenEndedWithSeparator == (mIter != mEnd)),
+                     (mLastTokenEndedWithSeparator == (mIter < mEnd)),
                      "If we require a separator and haven't hit the end of "
                      "our string, then we shouldn't have left the loop "
                      "unless we hit a separator");
 
         // Skip separator (and any whitespace after it), if we're at one.
         if (mLastTokenEndedWithSeparator) {
             ++mIter;
 
-            while (mIter != mEnd && IsWhitespace(*mIter)) {
+            while (mIter < mEnd && IsWhitespace(*mIter)) {
                 ++mIter;
             }
         }
 
-        return Substring(begin, end);
+        return Substring(tokenStart.get(), tokenEnd.get());
     }
 
 private:
-    nsSubstring::const_char_iterator mIter, mEnd;
+    mozilla::RangedPtr<const PRUnichar> mIter;
+    const mozilla::RangedPtr<const PRUnichar> mEnd;
     bool mFirstTokenBeganWithWhitespace;
     bool mLastTokenEndedWithWhitespace;
     bool mLastTokenEndedWithSeparator;
     PRUnichar mSeparatorChar;
     uint32_t  mFlags;
 };
 
 class nsCharSeparatedTokenizer: public nsCharSeparatedTokenizerTemplate<>
@@ -155,69 +158,71 @@ public:
     }
 };
 
 class nsCCharSeparatedTokenizer
 {
 public:
     nsCCharSeparatedTokenizer(const nsCSubstring& aSource,
                               char aSeparatorChar)
-        : mSeparatorChar(aSeparatorChar)
+        : mSeparatorChar(aSeparatorChar),
+          mIter(aSource.Data(), aSource.Length()),
+          mEnd(aSource.Data() + aSource.Length(), aSource.Data(),
+               aSource.Length())
     {
-        aSource.BeginReading(mIter);
-        aSource.EndReading(mEnd);
 
-        while (mIter != mEnd && isWhitespace(*mIter)) {
+        while (mIter < mEnd && isWhitespace(*mIter)) {
             ++mIter;
         }
     }
 
     /**
      * Checks if any more tokens are available.
      */
     bool hasMoreTokens()
     {
-        return mIter != mEnd;
+        return mIter < mEnd;
     }
 
     /**
      * Returns the next token.
      */
     const nsDependentCSubstring nextToken()
     {
-        nsCSubstring::const_char_iterator end = mIter, begin = mIter;
+        mozilla::RangedPtr<const char> tokenStart = mIter,tokenEnd = mIter;
 
         // Search until we hit separator or end.
-        while (mIter != mEnd && *mIter != mSeparatorChar) {
-          while (mIter != mEnd &&
+        while (mIter < mEnd && *mIter != mSeparatorChar) {
+          while (mIter < mEnd &&
                  !isWhitespace(*mIter) && *mIter != mSeparatorChar) {
               ++mIter;
           }
-          end = mIter;
+          tokenEnd = mIter;
 
-          while (mIter != mEnd && isWhitespace(*mIter)) {
+          while (mIter < mEnd && isWhitespace(*mIter)) {
               ++mIter;
           }
         }
 
         // Skip separator (and any whitespace after it).
-        if (mIter != mEnd) {
+        if (mIter < mEnd) {
             NS_ASSERTION(*mIter == mSeparatorChar, "Ended loop too soon");
             ++mIter;
 
-            while (mIter != mEnd && isWhitespace(*mIter)) {
+            while (mIter < mEnd && isWhitespace(*mIter)) {
                 ++mIter;
             }
         }
 
-        return Substring(begin, end);
+        return Substring(tokenStart.get(), tokenEnd.get());
     }
 
 private:
-    nsCSubstring::const_char_iterator mIter, mEnd;
+    mozilla::RangedPtr<const char> mIter;
+    const mozilla::RangedPtr<const char> mEnd;
     char mSeparatorChar;
 
     bool isWhitespace(unsigned char aChar)
     {
         return aChar <= ' ' &&
                (aChar == ' ' || aChar == '\n' ||
                 aChar == '\r'|| aChar == '\t');
     }
--- a/xpcom/ds/nsWhitespaceTokenizer.h
+++ b/xpcom/ds/nsWhitespaceTokenizer.h
@@ -1,105 +1,108 @@
 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef __nsWhitespaceTokenizer_h
 #define __nsWhitespaceTokenizer_h
 
+#include "mozilla/RangedPtr.h"
 #include "nsDependentSubstring.h"
 
 class nsWhitespaceTokenizer
 {
 public:
     nsWhitespaceTokenizer(const nsSubstring& aSource)
+        : mIter(aSource.Data(), aSource.Length()),
+          mEnd(aSource.Data() + aSource.Length(), aSource.Data(),
+               aSource.Length())
     {
-        aSource.BeginReading(mIter);
-        aSource.EndReading(mEnd);
-
-        while (mIter != mEnd && isWhitespace(*mIter)) {
+        while (mIter < mEnd && isWhitespace(*mIter)) {
             ++mIter;
         }
     }
 
     /**
      * Checks if any more tokens are available.
      */
     bool hasMoreTokens()
     {
-        return mIter != mEnd;
+        return mIter < mEnd;
     }
 
     /**
      * Returns the next token.
      */
     const nsDependentSubstring nextToken()
     {
-        nsSubstring::const_char_iterator begin = mIter;
-        while (mIter != mEnd && !isWhitespace(*mIter)) {
+        const mozilla::RangedPtr<const PRUnichar> tokenStart = mIter;
+        while (mIter < mEnd && !isWhitespace(*mIter)) {
             ++mIter;
         }
-        nsSubstring::const_char_iterator end = mIter;
-        while (mIter != mEnd && isWhitespace(*mIter)) {
+        const mozilla::RangedPtr<const PRUnichar> tokenEnd = mIter;
+        while (mIter < mEnd && isWhitespace(*mIter)) {
             ++mIter;
         }
-        return Substring(begin, end);
+        return Substring(tokenStart.get(), tokenEnd.get());
     }
 
 private:
-    nsSubstring::const_char_iterator mIter, mEnd;
+    mozilla::RangedPtr<const PRUnichar> mIter;
+    const mozilla::RangedPtr<const PRUnichar> mEnd;
 
     bool isWhitespace(PRUnichar aChar)
     {
         return aChar <= ' ' &&
                (aChar == ' ' || aChar == '\n' ||
                 aChar == '\r'|| aChar == '\t');
     }
 };
 
 class nsCWhitespaceTokenizer
 {
 public:
     nsCWhitespaceTokenizer(const nsCSubstring& aSource)
+        : mIter(aSource.Data(), aSource.Length()),
+          mEnd(aSource.Data() + aSource.Length(), aSource.Data(),
+               aSource.Length())
     {
-        aSource.BeginReading(mIter);
-        aSource.EndReading(mEnd);
-
-        while (mIter != mEnd && isWhitespace(*mIter)) {
+        while (mIter < mEnd && isWhitespace(*mIter)) {
             ++mIter;
         }
     }
 
     /**
      * Checks if any more tokens are available.
      */
     bool hasMoreTokens()
     {
-        return mIter != mEnd;
+        return mIter < mEnd;
     }
 
     /**
      * Returns the next token.
      */
     const nsDependentCSubstring nextToken()
     {
-        nsCSubstring::const_char_iterator begin = mIter;
-        while (mIter != mEnd && !isWhitespace(*mIter)) {
+        const mozilla::RangedPtr<const char> tokenStart = mIter;
+        while (mIter < mEnd && !isWhitespace(*mIter)) {
             ++mIter;
         }
-        nsCSubstring::const_char_iterator end = mIter;
-        while (mIter != mEnd && isWhitespace(*mIter)) {
+        const mozilla::RangedPtr<const char> tokenEnd = mIter;
+        while (mIter < mEnd && isWhitespace(*mIter)) {
             ++mIter;
         }
-        return Substring(begin, end);
+        return Substring(tokenStart.get(), tokenEnd.get());
     }
 
 private:
-    nsCSubstring::const_char_iterator mIter, mEnd;
+    mozilla::RangedPtr<const char> mIter;
+    const mozilla::RangedPtr<const char> mEnd;
 
     bool isWhitespace(char aChar)
     {
         return aChar <= ' ' &&
                (aChar == ' ' || aChar == '\n' ||
                 aChar == '\r'|| aChar == '\t');
     }
 };