Simplify AtomicStringTable and remove lots of dead code.

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

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "wtf/text/AtomicStringTable.h"
 
 #include "wtf/text/StringHash.h"
 #include "wtf/text/UTF8.h"
 
 namespace WTF {
@@ skipping 50 matching lines @@
     }
 
     static void translate(StringImpl*& location, const UCharBuffer& buf, unsigned hash)
     {
         location = StringImpl::create8BitIfPossible(buf.s, buf.length).leakRef();
         location->setHash(hash);
         location->setIsAtomic(true);
     }
 };
 
-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;
     unsigned length;
     unsigned utf16Length;
 };
 
 struct HashAndUTF8CharactersTranslator {
     static unsigned hash(const HashAndUTF8Characters& buffer)
     {
@@ skipping 62 matching lines @@
     if (!s)
         return nullptr;
 
     if (!length)
         return StringImpl::empty();
 
     UCharBuffer buffer = { s, 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)
     {
         return StringHasher::computeHashAndMaskTop8Bits(buf.s, buf.length);
     }
 
     static bool equal(StringImpl* const& str, const LCharBuffer& buf)
     {
         return WTF::equal(str, buf.s, buf.length);
@@ skipping 38 matching lines @@
     HashAndUTF8Characters buffer;
     buffer.characters = charactersStart;
     buffer.hash = calculateStringHashAndLengthFromUTF8MaskingTop8Bits(charactersStart, charactersEnd, buffer.length, buffer.utf16Length);
 
     if (!buffer.hash)
         return nullptr;
 
     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);
 }
 
 } // namespace WTF