Simplify AtomicStringTable and remove lots of dead code.

The special path for doing substring additions only made sense when we
shared StringImpls for substrings, now that we don't there's no reason
to keep it. The code was dead either way with nothing calling it
anymore.

I also removed constructors for AtomicString that no one used and
switched to using lengthOfNullTerminatedString directly in AtomicString
instead of having a separate code path in AtomicStringTable for finding
the length of UChar* strings.

Finally I simplified AtomicStringTable::remove which was using a find
codepath designed to find a string that may not exist in the table
without actually allocating a new string. This doesn't make sense since
remove is only ever called from StringImpl's destructor on a string we
already know to be atomic so it must be in the table and must have a
hash so we can just do m_table.remove on it.

Review-Url: https://codereview.chromium.org/2111653004
Cr-Commit-Position: refs/heads/master@{#403408}

third_party/WebKit/Source/wtf/text/AtomicString.cpp

@@ -25,6 +25,7 @@
 #include "wtf/dtoa.h"
 #include "wtf/text/AtomicStringTable.h"
 #include "wtf/text/IntegerToStringConversion.h"
+#include "wtf/text/StringImpl.h"
 
 namespace WTF {
 
@@ -36,19 +37,13 @@ AtomicString::AtomicString(const LChar* chars, unsigned length)
 AtomicString::AtomicString(const UChar* chars, unsigned length)
     : m_string(AtomicStringTable::instance().add(chars, length)) {}
 
-AtomicString::AtomicString(const UChar* chars, unsigned length, unsigned existingHash)
-    : m_string(AtomicStringTable::instance().add(chars, length, existingHash)) {}
-
 AtomicString::AtomicString(const UChar* chars)
-    : m_string(AtomicStringTable::instance().add(chars)) {}
-
-AtomicString::AtomicString(StringImpl* string, unsigned offset, unsigned length)
-    : m_string(AtomicStringTable::instance().add(string, offset, length)) {}
+    : m_string(AtomicStringTable::instance().add(chars, chars ? lengthOfNullTerminatedString(chars) : 0)) {}
 
-PassRefPtr<StringImpl> AtomicString::addSlowCase(StringImpl* chars)
+PassRefPtr<StringImpl> AtomicString::addSlowCase(StringImpl* string)
 {
-    DCHECK(!chars->isAtomic());
-    return AtomicStringTable::instance().add(chars);
+    DCHECK(!string->isAtomic());
+    return AtomicStringTable::instance().add(string);
 }
 
 AtomicString AtomicString::fromUTF8(const char* chars, size_t length)

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

@@ -45,7 +45,6 @@ public:
         : AtomicString(reinterpret_cast<const LChar*>(chars)) {}
     AtomicString(const LChar* chars, unsigned length);
     AtomicString(const UChar* chars, unsigned length);
-    AtomicString(const UChar* chars, unsigned length, unsigned existingHash);
     AtomicString(const UChar* chars);
 
     template<size_t inlineCapacity>
@@ -57,8 +56,6 @@ public:
     explicit AtomicString(StringImpl* impl) : m_string(add(impl)) { }
     explicit AtomicString(const String& s) : m_string(add(s.impl())) { }
 
-    AtomicString(StringImpl* baseString, unsigned start, unsigned length);
-
     // Hash table deleted values, which are only constructed and never copied or destroyed.
     AtomicString(WTF::HashTableDeletedValueType) : m_string(WTF::HashTableDeletedValue) { }
     bool isHashTableDeletedValue() const { return m_string.isHashTableDeletedValue(); }

third_party/WebKit/Source/wtf/text/AtomicStringTable.cpp

@@ -68,34 +68,6 @@ struct UCharBufferTranslator {
     }
 };
 
-template<typename CharacterType>
-struct HashAndCharacters {
-    unsigned hash;
-    const CharacterType* characters;
-    unsigned length;
-};
-
-template<typename CharacterType>
-struct HashAndCharactersTranslator {
-    static unsigned hash(const HashAndCharacters<CharacterType>& buffer)
-    {
-        DCHECK(buffer.hash == StringHasher::computeHashAndMaskTop8Bits(buffer.characters, buffer.length));
-        return buffer.hash;
-    }
-
-    static bool equal(StringImpl* const& string, const HashAndCharacters<CharacterType>& buffer)
-    {
-        return WTF::equal(string, buffer.characters, buffer.length);
-    }
-
-    static void translate(StringImpl*& location, const HashAndCharacters<CharacterType>& buffer, unsigned hash)
-    {
-        location = StringImpl::create(buffer.characters, buffer.length).leakRef();
-        location->setHash(hash);
-        location->setIsAtomic(true);
-    }
-};
-
 struct HashAndUTF8Characters {
     unsigned hash;
     const char* characters;
@@ -178,82 +150,6 @@ PassRefPtr<StringImpl> AtomicStringTable::add(const UChar* s, unsigned length)
     return addToStringTable<UCharBuffer, UCharBufferTranslator>(buffer);
 }
 
-PassRefPtr<StringImpl> AtomicStringTable::add(const UChar* s, unsigned length, unsigned existingHash)
-{
-    DCHECK(s);
-    DCHECK(existingHash);
-
-    if (!length)
-        return StringImpl::empty();
-
-    HashAndCharacters<UChar> buffer = { existingHash, s, length };
-    return addToStringTable<HashAndCharacters<UChar>, HashAndCharactersTranslator<UChar>>(buffer);
-}
-
-PassRefPtr<StringImpl> AtomicStringTable::add(const UChar* s)
-{
-    if (!s)
-        return nullptr;
-
-    unsigned length = 0;
-    while (s[length] != UChar(0))
-        ++length;
-
-    if (!length)
-        return StringImpl::empty();
-
-    UCharBuffer buffer = { s, length };
-    return addToStringTable<UCharBuffer, UCharBufferTranslator>(buffer);
-}
-
-struct SubstringLocation {
-    StringImpl* baseString;
-    unsigned start;
-    unsigned length;
-};
-
-struct SubstringTranslator {
-    static unsigned hash(const SubstringLocation& buffer)
-    {
-        if (buffer.baseString->is8Bit())
-            return StringHasher::computeHashAndMaskTop8Bits(buffer.baseString->characters8() + buffer.start, buffer.length);
-        return StringHasher::computeHashAndMaskTop8Bits(buffer.baseString->characters16() + buffer.start, buffer.length);
-    }
-
-    static bool equal(StringImpl* const& string, const SubstringLocation& buffer)
-    {
-        if (buffer.baseString->is8Bit())
-            return WTF::equal(string, buffer.baseString->characters8() + buffer.start, buffer.length);
-        return WTF::equal(string, buffer.baseString->characters16() + buffer.start, buffer.length);
-    }
-
-    static void translate(StringImpl*& location, const SubstringLocation& buffer, unsigned hash)
-    {
-        location = buffer.baseString->substring(buffer.start, buffer.length).leakRef();
-        location->setHash(hash);
-        location->setIsAtomic(true);
-    }
-};
-
-PassRefPtr<StringImpl> AtomicStringTable::add(StringImpl* baseString, unsigned start, unsigned length)
-{
-    if (!baseString)
-        return nullptr;
-
-    if (!length || start >= baseString->length())
-        return StringImpl::empty();
-
-    unsigned maxLength = baseString->length() - start;
-    if (length >= maxLength) {
-        if (!start)
-            return add(baseString);
-        length = maxLength;
-    }
-
-    SubstringLocation buffer = { baseString, start, length };
-    return addToStringTable<SubstringLocation, SubstringTranslator>(buffer);
-}
-
 typedef HashTranslatorCharBuffer<LChar> LCharBuffer;
 struct LCharBufferTranslator {
     static unsigned hash(const LCharBuffer& buf)
@@ -312,20 +208,10 @@ PassRefPtr<StringImpl> AtomicStringTable::addUTF8(const char* charactersStart, c
     return addToStringTable<HashAndUTF8Characters, HashAndUTF8CharactersTranslator>(buffer);
 }
 
-template<typename CharacterType>
-HashSet<StringImpl*>::iterator AtomicStringTable::find(const StringImpl* string)
-{
-    HashAndCharacters<CharacterType> buffer = { string->existingHash(), string->getCharacters<CharacterType>(), string->length() };
-    return m_table.find<HashAndCharactersTranslator<CharacterType>>(buffer);
-}
-
 void AtomicStringTable::remove(StringImpl* string)
 {
-    HashSet<StringImpl*>::iterator iterator;
-    if (string->is8Bit())
-        iterator = find<LChar>(string);
-    else
-        iterator = find<UChar>(string);
+    DCHECK(string->isAtomic());
+    auto iterator = m_table.find(string);
     RELEASE_ASSERT(iterator != m_table.end());
     m_table.remove(iterator);
 }

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

@@ -31,19 +31,14 @@ public:
 
     // Used by system initialization to preallocate enough storage for all of
     // the static strings.
-    void reserveCapacity(unsigned);
+    void reserveCapacity(unsigned size);
 
-    // Adding a StringImpl.
+    // Inserting strings into the table. Note that the return value from adding
+    // a UChar string may be an LChar string as the table will attempt to
+    // convert the string to save memory if possible.
     StringImpl* add(StringImpl*);
-    PassRefPtr<StringImpl> add(StringImpl*, unsigned offset, unsigned length);
-
-    // Adding an LChar.
-    PassRefPtr<StringImpl> add(const LChar*, unsigned length);
-
-    // Adding a UChar.
-    PassRefPtr<StringImpl> add(const UChar*, unsigned length);
-    PassRefPtr<StringImpl> add(const UChar*, unsigned length, unsigned existingHash);
-    PassRefPtr<StringImpl> add(const UChar*);
+    PassRefPtr<StringImpl> add(const LChar* chars, unsigned length);
+    PassRefPtr<StringImpl> add(const UChar* chars, unsigned length);
 
     // Adding UTF8.
     // Returns null if the characters contain invalid utf8 sequences.
@@ -58,9 +53,6 @@ private:
     template<typename T, typename HashTranslator>
     inline PassRefPtr<StringImpl> addToStringTable(const T& value);
 
-    template<typename CharacterType>
-    inline HashSet<StringImpl*>::iterator find(const StringImpl*);
-
     HashSet<StringImpl*> m_table;
 };