Cache contains only ascii in StringImpl

third_party/WebKit/Source/wtf/text/StringImpl.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2013 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2009 Google 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.
@@ skipping 12 matching lines @@
 
 #ifndef StringImpl_h
 #define StringImpl_h
 
 #include "wtf/ASCIICType.h"
 #include "wtf/Forward.h"
 #include "wtf/HashMap.h"
 #include "wtf/StringHasher.h"
 #include "wtf/Vector.h"
 #include "wtf/WTFExport.h"
+#include "wtf/text/ASCIIFastPath.h"
 #include "wtf/text/Unicode.h"
 #include <limits.h>
 #include <string.h>
 
 #if OS(MACOSX)
 typedef const struct __CFString* CFStringRef;
 #endif
 
 #ifdef __OBJC__
 @class NSString;
@@ skipping 83 matching lines @@
 
   // Used to construct static strings, which have an special refCount that can
   // never hit zero.  This means that the static string will never be
   // destroyed, which is important because static strings will be shared
   // across threads & ref-counted in a non-threadsafe manner.
   enum ConstructEmptyStringTag { ConstructEmptyString };
   explicit StringImpl(ConstructEmptyStringTag)
       : m_refCount(1),
         m_length(0),
         m_hash(0),
+        m_containsOnlyASCII(true),
+        m_needsASCIICheck(false),
         m_isAtomic(false),
         m_is8Bit(true),
         m_isStatic(true) {
     // Ensure that the hash is computed so that AtomicStringHash can call
     // existingHash() with impunity. The empty string is special because it
     // is never entered into AtomicString's HashKey, but still needs to
     // compare correctly.
     STRING_STATS_ADD_8BIT_STRING(m_length);
     hash();
   }
 
   enum ConstructEmptyString16BitTag { ConstructEmptyString16Bit };
   explicit StringImpl(ConstructEmptyString16BitTag)
       : m_refCount(1),
         m_length(0),
         m_hash(0),
+        m_containsOnlyASCII(true),
+        m_needsASCIICheck(false),
         m_isAtomic(false),
         m_is8Bit(false),
         m_isStatic(true) {
     STRING_STATS_ADD_16BIT_STRING(m_length);
     hash();
   }
 
   // FIXME: there has to be a less hacky way to do this.
   enum Force8Bit { Force8BitConstructor };
   StringImpl(unsigned length, Force8Bit)
       : m_refCount(1),
         m_length(length),
         m_hash(0),
+        m_containsOnlyASCII(!length),
+        m_needsASCIICheck(static_cast<bool>(length)),
         m_isAtomic(false),
         m_is8Bit(true),
         m_isStatic(false) {
     DCHECK(m_length);
     STRING_STATS_ADD_8BIT_STRING(m_length);
   }
 
   StringImpl(unsigned length)
       : m_refCount(1),
         m_length(length),
         m_hash(0),
+        m_containsOnlyASCII(!length),
+        m_needsASCIICheck(static_cast<bool>(length)),
         m_isAtomic(false),
         m_is8Bit(false),
         m_isStatic(false) {
     DCHECK(m_length);
     STRING_STATS_ADD_16BIT_STRING(m_length);
   }
 
   enum StaticStringTag { StaticString };
   StringImpl(unsigned length, unsigned hash, StaticStringTag)
       : m_refCount(1),
         m_length(length),
         m_hash(hash),
+        m_containsOnlyASCII(!length),
+        m_needsASCIICheck(static_cast<bool>(length)),
         m_isAtomic(false),
         m_is8Bit(true),
         m_isStatic(true) {}
 
  public:
   ~StringImpl();
 
   static StringImpl* createStatic(const char* string,
                                   unsigned length,
                                   unsigned hash);
@@ skipping 48 matching lines @@
 
   size_t charactersSizeInBytes() const {
     return length() * (is8Bit() ? sizeof(LChar) : sizeof(UChar));
   }
 
   bool isAtomic() const { return m_isAtomic; }
   void setIsAtomic(bool isAtomic) { m_isAtomic = isAtomic; }
 
   bool isStatic() const { return m_isStatic; }
 
+  bool containsOnlyASCII() const;
+
   bool isSafeToSendToAnotherThread() const;
 
   // The high bits of 'hash' are always empty, but we prefer to store our
   // flags in the low bits because it makes them slightly more efficient to
   // access.  So, we shift left and right when setting and getting our hash
   // code.
   void setHash(unsigned hash) const {
     DCHECK(!hasHash());
     // Multiple clients assume that StringHasher is the canonical string
     // hash function.
@@ skipping 202 matching lines @@
                                  unsigned replacementLength);
 
   template <class UCharPredicate>
   PassRefPtr<StringImpl> stripMatchedCharacters(UCharPredicate);
   template <typename CharType, class UCharPredicate>
   PassRefPtr<StringImpl> simplifyMatchedCharactersToSpace(UCharPredicate,
                                                           StripBehavior);
   NEVER_INLINE unsigned hashSlowCase() const;
 
   void destroyIfNotStatic();
+  void updateContainsOnlyASCII() const;
 
 #ifdef STRING_STATS
   static StringStats m_stringStats;
 #endif
 
   static unsigned m_highestStaticStringLength;
 
 #if DCHECK_IS_ON()
   void assertHashIsCorrect() {
     DCHECK(hasHash());
     DCHECK_EQ(existingHash(), StringHasher::computeHashAndMaskTop8Bits(
                                   characters8(), length()));
   }
 #endif
 
  private:
   unsigned m_refCount;
   const unsigned m_length;
   mutable unsigned m_hash : 24;
+  mutable unsigned m_containsOnlyASCII : 1;
+  mutable unsigned m_needsASCIICheck : 1;
   unsigned m_isAtomic : 1;
   const unsigned m_is8Bit : 1;
   const unsigned m_isStatic : 1;
 };
 
 template <>
 ALWAYS_INLINE const LChar* StringImpl::getCharacters<LChar>() const {
   return characters8();
 }
 
@@ skipping 13 matching lines @@
   return equal(a, reinterpret_cast<const LChar*>(b), length);
 }
 inline bool equal(const LChar* a, StringImpl* b) {
   return equal(b, a);
 }
 inline bool equal(const char* a, StringImpl* b) {
   return equal(b, reinterpret_cast<const LChar*>(a));
 }
 WTF_EXPORT bool equalNonNull(const StringImpl* a, const StringImpl* b);
 
+ALWAYS_INLINE bool StringImpl::containsOnlyASCII() const {
+  if (m_needsASCIICheck)
+    updateContainsOnlyASCII();
+  return m_containsOnlyASCII;
+}
+
 template <typename CharType>
 ALWAYS_INLINE bool equal(const CharType* a,
                          const CharType* b,
                          unsigned length) {
   return !memcmp(a, b, length * sizeof(CharType));
 }
 
 ALWAYS_INLINE bool equal(const LChar* a, const UChar* b, unsigned length) {
   for (unsigned i = 0; i < length; ++i) {
     if (a[i] != b[i])
@@ skipping 298 matching lines @@
 using WTF::TextCaseASCIIInsensitive;
 using WTF::TextCaseUnicodeInsensitive;
 using WTF::TextCaseSensitive;
 using WTF::TextCaseSensitivity;
 using WTF::equal;
 using WTF::equalNonNull;
 using WTF::lengthOfNullTerminatedString;
 using WTF::reverseFind;
 
 #endif