Refactor to remove unnecessary code from the string hashing functions

Source/wtf/StringHasher.h

 /*
  * Copyright (C) 2005, 2006, 2008, 2010, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
  *
  * 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.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 91 matching lines @@
 
         if (remainder)
             addCharacter(Converter(*data));
     }
 
     template<typename T> void addCharactersAssumingAligned(const T* data, unsigned length)
     {
         addCharactersAssumingAligned<T, defaultConverter>(data, length);
     }
 
-    template<typename T, UChar Converter(T)> void addCharactersAssumingAligned(const T* data)
-    {
-        ASSERT(!m_hasPendingCharacter);
-
-        while (T a = *data++) {
-            T b = *data++;
-            if (!b) {
-                addCharacter(Converter(a));
-                break;
-            }
-            addCharactersAssumingAligned(Converter(a), Converter(b));
-        }
-    }
-
-    template<typename T> void addCharactersAssumingAligned(const T* data)
-    {
-        addCharactersAssumingAligned<T, defaultConverter>(data);
-    }
-
     template<typename T, UChar Converter(T)> void addCharacters(const T* data, unsigned length)
     {
         if (m_hasPendingCharacter && length) {
             m_hasPendingCharacter = false;
             addCharactersAssumingAligned(m_pendingCharacter, Converter(*data++));
             --length;
         }
         addCharactersAssumingAligned<T, Converter>(data, length);
     }
 
     template<typename T> void addCharacters(const T* data, unsigned length)
     {
         addCharacters<T, defaultConverter>(data, length);
     }
 
-    template<typename T, UChar Converter(T)> void addCharacters(const T* data)
-    {
-        if (m_hasPendingCharacter && *data) {
-            m_hasPendingCharacter = false;
-            addCharactersAssumingAligned(m_pendingCharacter, Converter(*data++));
-        }
-        addCharactersAssumingAligned<T, Converter>(data);
-    }
-
-    template<typename T> void addCharacters(const T* data)
-    {
-        addCharacters<T, defaultConverter>(data);
-    }
-
     unsigned hashWithTop8BitsMasked() const
     {
         unsigned result = avalancheBits();
 
         // Reserving space from the high bits for flags preserves most of the hash's
         // value, since hash lookup typically masks out the high bits anyway.
         result &= (1U << (sizeof(result) * 8 - flagCount)) - 1;
 
         // This avoids ever returning a hash code of 0, since that is used to
         // signal "hash not computed yet". Setting the high bit maintains
@@ skipping 19 matching lines @@
         return result;
     }
 
     template<typename T, UChar Converter(T)> static unsigned computeHashAndMaskTop8Bits(const T* data, unsigned length)
     {
         StringHasher hasher;
         hasher.addCharactersAssumingAligned<T, Converter>(data, length);
         return hasher.hashWithTop8BitsMasked();
     }
 
-    template<typename T, UChar Converter(T)> static unsigned computeHashAndMaskTop8Bits(const T* data)
-    {
-        StringHasher hasher;
-        hasher.addCharactersAssumingAligned<T, Converter>(data);
-        return hasher.hashWithTop8BitsMasked();
-    }
-
     template<typename T> static unsigned computeHashAndMaskTop8Bits(const T* data, unsigned length)
     {
         return computeHashAndMaskTop8Bits<T, defaultConverter>(data, length);
     }
 
-    template<typename T> static unsigned computeHashAndMaskTop8Bits(const T* data)
-    {
-        return computeHashAndMaskTop8Bits<T, defaultConverter>(data);
-    }
-
     template<typename T, UChar Converter(T)> static unsigned computeHash(const T* data, unsigned length)
     {
         StringHasher hasher;
         hasher.addCharactersAssumingAligned<T, Converter>(data, length);
         return hasher.hash();
     }
 
-    template<typename T, UChar Converter(T)> static unsigned computeHash(const T* data)
-    {
-        StringHasher hasher;
-        hasher.addCharactersAssumingAligned<T, Converter>(data);
-        return hasher.hash();
-    }
-
     template<typename T> static unsigned computeHash(const T* data, unsigned length)
     {
         return computeHash<T, defaultConverter>(data, length);
     }
 
-    template<typename T> static unsigned computeHash(const T* data)
-    {
-        return computeHash<T, defaultConverter>(data);
-    }
-
     static unsigned hashMemory(const void* data, unsigned length)
     {
         // FIXME: Why does this function use the version of the hash that drops the top 8 bits?
         // We want that for all string hashing so we can use those bits in StringImpl and hash
         // strings consistently, but I don't see why we'd want that for general memory hashing.
         ASSERT(!(length % 2));
         return computeHashAndMaskTop8Bits<UChar>(static_cast<const UChar*>(data), length / sizeof(UChar));
     }
 
     template<size_t length> static unsigned hashMemory(const void* data)
@@ skipping 37 matching lines @@
     unsigned m_hash;
     bool m_hasPendingCharacter;
     UChar m_pendingCharacter;
 };
 
 } // namespace WTF
 
 using WTF::StringHasher;
 
 #endif // WTF_StringHasher_h