Remove the pointer from StringImpl

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 97 matching lines @@
     friend struct WTF::HashAndUTF8CharactersTranslator;
     friend struct WTF::CharBufferFromLiteralDataTranslator;
     friend struct WTF::LCharBufferTranslator;
     friend struct WTF::SubstringTranslator;
     friend struct WTF::UCharBufferTranslator;
 
 private:
     // 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 ConstructStaticStringTag { ConstructStaticString };
-    StringImpl(const LChar* characters, unsigned length, ConstructStaticStringTag)
-        : m_data8(characters)
-        , m_refCount(s_refCountFlagIsStaticString)
-        , m_length(length)
+    enum ConstructEmptyStringTag { ConstructEmptyString };
+    explicit StringImpl(ConstructEmptyStringTag)
+        : m_refCount(s_refCountFlagIsStaticString)
+        , m_length(0)
         , m_hashAndFlags(s_hashFlag8BitBuffer)
     {
         // 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();
     }
 
     // FIXME: there has to be a less hacky way to do this.
     enum Force8Bit { Force8BitConstructor };
     StringImpl(unsigned length, Force8Bit)
-        : m_data8(reinterpret_cast<const LChar*>(this + 1))
-        , m_refCount(s_refCountIncrement)
+        : m_refCount(s_refCountIncrement)
         , m_length(length)
         , m_hashAndFlags(s_hashFlag8BitBuffer)
     {
-        ASSERT(m_data8);
         ASSERT(m_length);
-
         STRING_STATS_ADD_8BIT_STRING(m_length);
     }
 
     StringImpl(unsigned length)
-        : m_data16(reinterpret_cast<const UChar*>(this + 1))
-        , m_refCount(s_refCountIncrement)
+        : m_refCount(s_refCountIncrement)
         , m_length(length)
         , m_hashAndFlags(0)
     {
-        ASSERT(m_data16);
         ASSERT(m_length);
-
         STRING_STATS_ADD_16BIT_STRING(m_length);
     }
 
 public:
     ~StringImpl();
 
+    enum StaticStringTag { StaticString };
+    StringImpl(unsigned length, unsigned hash, StaticStringTag)
+        : m_refCount(s_refCountFlagIsStaticString)
+        , m_length(length)
+        , m_hashAndFlags(hash << s_flagCount | s_hashFlag8BitBuffer)
+    {
+#ifndef NDEBUG
+        assertHashIsCorrect();
+#endif
+    }
+
     static PassRefPtr<StringImpl> create(const UChar*, unsigned length);
     static PassRefPtr<StringImpl> create(const LChar*, unsigned length);
     static PassRefPtr<StringImpl> create8BitIfPossible(const UChar*, unsigned length);
     template<size_t inlineCapacity>
     static PassRefPtr<StringImpl> create8BitIfPossible(const Vector<UChar, inlineCapacity>& vector)
     {
         return create8BitIfPossible(vector.data(), vector.size());
     }
 
     ALWAYS_INLINE static PassRefPtr<StringImpl> create(const char* s, unsigned length) { return create(reinterpret_cast<const LChar*>(s), length); }
@@ skipping 13 matching lines @@
     void truncateAssumingIsolated(unsigned length)
     {
         ASSERT(hasOneRef());
         ASSERT(length <= m_length);
         m_length = length;
     }
 
     unsigned length() const { return m_length; }
     bool is8Bit() const { return m_hashAndFlags & s_hashFlag8BitBuffer; }
 
-    ALWAYS_INLINE const LChar* characters8() const { ASSERT(is8Bit()); return m_data8; }
-    ALWAYS_INLINE const UChar* characters16() const { ASSERT(!is8Bit()); return m_data16; }
+    ALWAYS_INLINE const LChar* characters8() const { ASSERT(is8Bit()); return reinterpret_cast<const LChar*>(this + 1); }
+    ALWAYS_INLINE const UChar* characters16() const { ASSERT(!is8Bit()); return reinterpret_cast<const UChar*>(this + 1); }
 
     template <typename CharType>
     ALWAYS_INLINE const CharType * getCharacters() const;
 
     size_t sizeInBytes() const;
 
     bool isAtomic() const { return m_hashAndFlags & s_hashFlagIsAtomic; }
     void setIsAtomic(bool isAtomic)
     {
         if (isAtomic)
             m_hashAndFlags |= s_hashFlagIsAtomic;
         else
             m_hashAndFlags &= ~s_hashFlagIsAtomic;
     }
 
     bool isStatic() const { return m_refCount & s_refCountFlagIsStaticString; }
 
 private:
     // 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
     {
         ASSERT(!hasHash());
         // Multiple clients assume that StringHasher is the canonical string hash function.
-        ASSERT(hash == (is8Bit() ? StringHasher::computeHashAndMaskTop8Bits(m_data8, m_length) : StringHasher::computeHashAndMaskTop8Bits(m_data16, m_length)));
+        ASSERT(hash == (is8Bit() ? StringHasher::computeHashAndMaskTop8Bits(characters8(), m_length) : StringHasher::computeHashAndMaskTop8Bits(characters16(), m_length)));
         ASSERT(!(hash & (s_flagMask << (8 * sizeof(hash) - s_flagCount)))); // Verify that enough high bits are empty.
 
         hash <<= s_flagCount;
         ASSERT(!(hash & m_hashAndFlags)); // Verify that enough low bits are empty after shift.
         ASSERT(hash); // Verify that 0 is a valid sentinel hash value.
 
         m_hashAndFlags |= hash; // Store hash with flags in low bits.
     }
 
     unsigned rawHash() const
@@ skipping 81 matching lines @@
     // thread-safe. We achieve thread safety by isolation, giving each thread
     // its own copy of the string.
     PassRefPtr<StringImpl> isolatedCopy() const;
 
     PassRefPtr<StringImpl> substring(unsigned pos, unsigned len = UINT_MAX);
 
     UChar operator[](unsigned i) const
     {
         ASSERT_WITH_SECURITY_IMPLICATION(i < m_length);
         if (is8Bit())
-            return m_data8[i];
-        return m_data16[i];
+            return characters8()[i];
+        return characters16()[i];
     }
     UChar32 characterStartingAt(unsigned);
 
     bool containsOnlyWhitespace();
 
     int toIntStrict(bool* ok = 0, int base = 10);
     unsigned toUIntStrict(bool* ok = 0, int base = 10);
     int64_t toInt64Strict(bool* ok = 0, int base = 10);
     uint64_t toUInt64Strict(bool* ok = 0, int base = 10);
     intptr_t toIntPtrStrict(bool* ok = 0, int base = 10);
@@ skipping 96 matching lines @@
     static const unsigned s_flagMask = (1u << s_flagCount) - 1;
     COMPILE_ASSERT(s_flagCount == StringHasher::flagCount, StringHasher_reserves_enough_bits_for_StringImpl_flags);
 
     static const unsigned s_hashFlagIsAtomic = 1u << 1;
     static const unsigned s_hashFlag8BitBuffer = 1u << 0;
 
 #ifdef STRING_STATS
     static StringStats m_stringStats;
 #endif
 
-public:
-    struct StaticASCIILiteral {
-        // These member variables must match the layout of StringImpl.
-        const LChar* m_data8;
-        unsigned m_refCount;
-        unsigned m_length;
-        unsigned m_hashAndFlags;
-
-        static const unsigned s_initialRefCount = s_refCountFlagIsStaticString;
-        static const unsigned s_initialFlags = s_hashFlag8BitBuffer;
-        static const unsigned s_hashShift = s_flagCount;
-    };
-
 #ifndef NDEBUG
     void assertHashIsCorrect()
     {
         ASSERT(hasHash());
         ASSERT(existingHash() == StringHasher::computeHashAndMaskTop8Bits(characters8(), length()));
     }
 #endif
 
 private:
-    // These member variables must match the layout of StaticASCIILiteral.
-    union {  // Pointers first: crbug.com/232031
-        const LChar* m_data8;
-        const UChar* m_data16;
-    };
     unsigned m_refCount;
     unsigned m_length;
     mutable unsigned m_hashAndFlags;
 };
 
-COMPILE_ASSERT(sizeof(StringImpl) == sizeof(StringImpl::StaticASCIILiteral), StringImpl_should_match_its_StaticASCIILiteral);
-
 template <>
 ALWAYS_INLINE const LChar* StringImpl::getCharacters<LChar>() const { return characters8(); }
 
 template <>
 ALWAYS_INLINE const UChar* StringImpl::getCharacters<UChar>() const { return characters16(); }
 
 WTF_EXPORT bool equal(const StringImpl*, const StringImpl*);
 WTF_EXPORT bool equal(const StringImpl*, const LChar*);
 inline bool equal(const StringImpl* a, const char* b) { return equal(a, reinterpret_cast<const LChar*>(b)); }
 WTF_EXPORT bool equal(const StringImpl*, const LChar*, unsigned);
@@ skipping 249 matching lines @@
 static inline bool isSpaceOrNewline(UChar c)
 {
     // Use isASCIISpace() for basic Latin-1.
     // This will include newlines, which aren't included in Unicode DirWS.
     return c <= 0x7F ? WTF::isASCIISpace(c) : WTF::Unicode::direction(c) == WTF::Unicode::WhiteSpaceNeutral;
 }
 
 inline PassRefPtr<StringImpl> StringImpl::isolatedCopy() const
 {
     if (is8Bit())
-        return create(m_data8, m_length);
-    return create(m_data16, m_length);
+        return create(characters8(), m_length);
+    return create(characters16(), m_length);
 }
 
 struct StringHash;
 
 // StringHash is the default hash for StringImpl* and RefPtr<StringImpl>
 template<typename T> struct DefaultHash;
 template<> struct DefaultHash<StringImpl*> {
     typedef StringHash Hash;
 };
 template<> struct DefaultHash<RefPtr<StringImpl> > {
     typedef StringHash Hash;
 };
 
 }
 
 using WTF::StringImpl;
 using WTF::equal;
 using WTF::equalNonNull;
 using WTF::TextCaseSensitivity;
 using WTF::TextCaseSensitive;
 using WTF::TextCaseInsensitive;
 
 #endif