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 69 matching lines @@
 #define STRING_STATS_ADD_16BIT_STRING(length) ((void)0)
 #define STRING_STATS_REMOVE_STRING(string) ((void)0)
 #endif
 
 // You can find documentation about this class in this doc:
 // https://docs.google.com/document/d/1kOCUlJdh2WJMJGDf-WoEQhmnjKLaOYRbiHz5TiGJl14/edit?usp=sharing
 class WTF_EXPORT StringImpl {
   WTF_MAKE_NONCOPYABLE(StringImpl);
 
  private:
+  enum ContainsASCIIFlag {
+    DoesNotContainOnlyASCII = 0,
+    ContainsOnlyASCII = 1,
+    NotCalculated = 2,
+  };
   // StringImpls are allocated out of the WTF buffer partition.
   void* operator new(size_t);
   void* operator new(size_t, void* ptr) { return ptr; }
   void operator delete(void*);
 
   // 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(NotCalculated),
         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(NotCalculated),
         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(NotCalculated),
         m_isAtomic(false),
         m_is8Bit(true),
         m_isStatic(false) {
     ASSERT(m_length);
     STRING_STATS_ADD_8BIT_STRING(m_length);
   }
 
   StringImpl(unsigned length)
       : m_refCount(1),
         m_length(length),
         m_hash(0),
+        m_containsOnlyASCII(NotCalculated),
         m_isAtomic(false),
         m_is8Bit(false),
         m_isStatic(false) {
     ASSERT(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(NotCalculated),
         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 225 matching lines @@
     ASSERT(hasHash());
     ASSERT(existingHash() ==
            StringHasher::computeHashAndMaskTop8Bits(characters8(), length()));
   }
 #endif
 
  private:
   unsigned m_refCount;
   const unsigned m_length;
   mutable unsigned m_hash : 24;
+  // Tristate enum set lazily on calls to containsOnlyASCII.
+  mutable unsigned m_containsOnlyASCII : 2;
   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);
 
+inline bool StringImpl::containsOnlyASCII() const {
+  if (m_containsOnlyASCII == NotCalculated) {
+    m_containsOnlyASCII =
+        !length() ||
+        (is8Bit() ? charactersAreAllASCII(characters8(), length())
+                  : charactersAreAllASCII(characters16(), length()));

[kinuko, 2016/12/26 07:32:19]

I'd defer the judgement to esprehn (so you might want to hold off) but I'm not a
big fan of this enum <-> boolean conversions (assuming we wouldn't get any perf
benefit after optimization runs).  Would clearly writing down the switches or
ternaries make the code that bigger?

+  }
+  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