[webkit-changes] [225751] trunk/Source

Mon, 11 Dec 2017 11:22:24 -0800

Title: [225751] trunk/Source
Revision
225751
Author
utatane....@gmail.com
Date
2017-12-11 11:22:01 -0800 (Mon, 11 Dec 2017)

Log Message

[WTF] Add Converter traits to StringHasher instead of function pointer
https://bugs.webkit.org/show_bug.cgi?id=180656

Reviewed by JF Bastien.

Source/WebKit:

* WebProcess/WebProcess.cpp:
(WebKit::addCaseFoldedCharacters):

Source/WTF:

In the latest ICU, UChar is char16_t. So defining defaultConverter(UChar)
and defaultConverter(char16_t) causes duplicate definitions.
Instead of passing a funtion pointer, we pass a trait class DefaultConveter
which has `convert` static function. And we make this `convert` function
generic. This avoids defining convert function for UChar and char16_t.

* wtf/text/StringHash.h:
(WTF::ASCIICaseInsensitiveHash::FoldCase::convert):
(WTF::ASCIICaseInsensitiveHash::hash):
(WTF::ASCIICaseInsensitiveHash::foldCase): Deleted.
* wtf/text/StringHasher.h:
(WTF::StringHasher::DefaultConverter::convert):
(WTF::StringHasher::addCharactersAssumingAligned):
(WTF::StringHasher::addCharacters):
(WTF::StringHasher::computeHashAndMaskTop8Bits):
(WTF::StringHasher::computeHash):
(WTF::StringHasher::computeLiteralHash):
(WTF::StringHasher::computeLiteralHashAndMaskTop8Bits):
(WTF::StringHasher::computeHashImpl):
(WTF::StringHasher::Converter): Deleted.
(WTF::StringHasher::defaultConverter): Deleted.

Modified Paths

Diff

Modified: trunk/Source/WTF/ChangeLog (225750 => 225751)


--- trunk/Source/WTF/ChangeLog	2017-12-11 19:19:35 UTC (rev 225750)
+++ trunk/Source/WTF/ChangeLog	2017-12-11 19:22:01 UTC (rev 225751)
@@ -1,3 +1,32 @@
+2017-12-11  Yusuke Suzuki  <utatane....@gmail.com>
+
+        [WTF] Add Converter traits to StringHasher instead of function pointer
+        https://bugs.webkit.org/show_bug.cgi?id=180656
+
+        Reviewed by JF Bastien.
+
+        In the latest ICU, UChar is char16_t. So defining defaultConverter(UChar)
+        and defaultConverter(char16_t) causes duplicate definitions.
+        Instead of passing a funtion pointer, we pass a trait class DefaultConveter
+        which has `convert` static function. And we make this `convert` function
+        generic. This avoids defining convert function for UChar and char16_t.
+
+        * wtf/text/StringHash.h:
+        (WTF::ASCIICaseInsensitiveHash::FoldCase::convert):
+        (WTF::ASCIICaseInsensitiveHash::hash):
+        (WTF::ASCIICaseInsensitiveHash::foldCase): Deleted.
+        * wtf/text/StringHasher.h:
+        (WTF::StringHasher::DefaultConverter::convert):
+        (WTF::StringHasher::addCharactersAssumingAligned):
+        (WTF::StringHasher::addCharacters):
+        (WTF::StringHasher::computeHashAndMaskTop8Bits):
+        (WTF::StringHasher::computeHash):
+        (WTF::StringHasher::computeLiteralHash):
+        (WTF::StringHasher::computeLiteralHashAndMaskTop8Bits):
+        (WTF::StringHasher::computeHashImpl):
+        (WTF::StringHasher::Converter): Deleted.
+        (WTF::StringHasher::defaultConverter): Deleted.
+
 2017-12-10  Yusuke Suzuki  <utatane....@gmail.com>
 
         [WTF] Reduce sizeof(Thread) by adjusting alignment

Modified: trunk/Source/WTF/wtf/text/StringHash.h (225750 => 225751)


--- trunk/Source/WTF/wtf/text/StringHash.h	2017-12-11 19:19:35 UTC (rev 225750)
+++ trunk/Source/WTF/wtf/text/StringHash.h	2017-12-11 19:22:01 UTC (rev 225751)
@@ -80,14 +80,17 @@
     };
 
     struct ASCIICaseInsensitiveHash {
-        template<typename T> static inline UChar foldCase(T character)
-        {
-            return toASCIILower(character);
-        }
+        template<typename T>
+        struct FoldCase {
+            static inline UChar convert(T character)
+            {
+                return toASCIILower(character);
+            }
+        };
 
         static unsigned hash(const UChar* data, unsigned length)
         {
-            return StringHasher::computeHashAndMaskTop8Bits<UChar, foldCase<UChar>>(data, length);
+            return StringHasher::computeHashAndMaskTop8Bits<UChar, FoldCase<UChar>>(data, length);
         }
 
         static unsigned hash(StringImpl& string)
@@ -104,7 +107,7 @@
 
         static unsigned hash(const LChar* data, unsigned length)
         {
-            return StringHasher::computeHashAndMaskTop8Bits<LChar, foldCase<LChar>>(data, length);
+            return StringHasher::computeHashAndMaskTop8Bits<LChar, FoldCase<LChar>>(data, length);
         }
 
         static inline unsigned hash(const char* data, unsigned length)

Modified: trunk/Source/WTF/wtf/text/StringHasher.h (225750 => 225751)


--- trunk/Source/WTF/wtf/text/StringHasher.h	2017-12-11 19:19:35 UTC (rev 225750)
+++ trunk/Source/WTF/wtf/text/StringHasher.h	2017-12-11 19:22:01 UTC (rev 225751)
@@ -42,6 +42,14 @@
     static constexpr const unsigned flagCount = 8; // Save 8 bits for StringImpl to use as flags.
     static constexpr const unsigned maskHash = (1U << (sizeof(unsigned) * 8 - flagCount)) - 1;
 
+    struct DefaultConverter {
+        template<typename CharType>
+        static constexpr UChar convert(CharType character)
+        {
+            return static_cast<std::make_unsigned_t<CharType>>((character));
+        }
+    };
+
     StringHasher() = default;
 
     // The hasher hashes two characters at a time, and thus an "aligned" hasher is one
@@ -82,7 +90,7 @@
         addCharactersAssumingAligned(a, b);
     }
 
-    template<typename T, UChar Converter(T)> void addCharactersAssumingAligned(const T* data, unsigned length)
+    template<typename T, typename Converter> void addCharactersAssumingAligned(const T* data, unsigned length)
     {
         ASSERT(!m_hasPendingCharacter);
 
@@ -90,20 +98,20 @@
         length >>= 1;
 
         while (length--) {
-            addCharactersAssumingAligned(Converter(data[0]), Converter(data[1]));
+            addCharactersAssumingAligned(Converter::convert(data[0]), Converter::convert(data[1]));
             data += 2;
         }
 
         if (remainder)
-            addCharacter(Converter(*data));
+            addCharacter(Converter::convert(*data));
     }
 
     template<typename T> void addCharactersAssumingAligned(const T* data, unsigned length)
     {
-        addCharactersAssumingAligned<T, defaultConverter>(data, length);
+        addCharactersAssumingAligned<T, DefaultConverter>(data, length);
     }
 
-    template<typename T, UChar Converter(T)> void addCharactersAssumingAligned(const T* data)
+    template<typename T, typename Converter> void addCharactersAssumingAligned(const T* data)
     {
         ASSERT(!m_hasPendingCharacter);
 
@@ -110,25 +118,25 @@
         while (T a = *data++) {
             T b = *data++;
             if (!b) {
-                addCharacter(Converter(a));
+                addCharacter(Converter::convert(a));
                 break;
             }
-            addCharactersAssumingAligned(Converter(a), Converter(b));
+            addCharactersAssumingAligned(Converter::convert(a), Converter::convert(b));
         }
     }
 
     template<typename T> void addCharactersAssumingAligned(const T* data)
     {
-        addCharactersAssumingAligned<T, defaultConverter>(data);
+        addCharactersAssumingAligned<T, DefaultConverter>(data);
     }
 
-    template<typename T, UChar Converter(T)> void addCharacters(const T* data, unsigned length)
+    template<typename T, typename Converter> void addCharacters(const T* data, unsigned length)
     {
         if (!length)
             return;
         if (m_hasPendingCharacter) {
             m_hasPendingCharacter = false;
-            addCharactersAssumingAligned(m_pendingCharacter, Converter(*data++));
+            addCharactersAssumingAligned(m_pendingCharacter, Converter::convert(*data++));
             --length;
         }
         addCharactersAssumingAligned<T, Converter>(data, length);
@@ -136,14 +144,14 @@
 
     template<typename T> void addCharacters(const T* data, unsigned length)
     {
-        addCharacters<T, defaultConverter>(data, length);
+        addCharacters<T, DefaultConverter>(data, length);
     }
 
-    template<typename T, UChar Converter(T)> void addCharacters(const T* data)
+    template<typename T, typename Converter> void addCharacters(const T* data)
     {
         if (m_hasPendingCharacter && *data) {
             m_hasPendingCharacter = false;
-            addCharactersAssumingAligned(m_pendingCharacter, Converter(*data++));
+            addCharactersAssumingAligned(m_pendingCharacter, Converter::convert(*data++));
         }
         addCharactersAssumingAligned<T, Converter>(data);
     }
@@ -150,7 +158,7 @@
 
     template<typename T> void addCharacters(const T* data)
     {
-        addCharacters<T, defaultConverter>(data);
+        addCharacters<T, DefaultConverter>(data);
     }
 
     unsigned hashWithTop8BitsMasked() const
@@ -163,12 +171,12 @@
         return finalize(processPendingCharacter());
     }
 
-    template<typename T, UChar Converter(T)> static constexpr unsigned computeHashAndMaskTop8Bits(const T* data, unsigned length)
+    template<typename T, typename Converter> static constexpr unsigned computeHashAndMaskTop8Bits(const T* data, unsigned length)
     {
         return finalizeAndMaskTop8Bits(computeHashImpl<T, Converter>(data, length));
     }
 
-    template<typename T, UChar Converter(T)> static constexpr unsigned computeHashAndMaskTop8Bits(const T* data)
+    template<typename T, typename Converter> static constexpr unsigned computeHashAndMaskTop8Bits(const T* data)
     {
         return finalizeAndMaskTop8Bits(computeHashImpl<T, Converter>(data));
     }
@@ -175,20 +183,20 @@
 
     template<typename T> static constexpr unsigned computeHashAndMaskTop8Bits(const T* data, unsigned length)
     {
-        return computeHashAndMaskTop8Bits<T, defaultConverter>(data, length);
+        return computeHashAndMaskTop8Bits<T, DefaultConverter>(data, length);
     }
 
     template<typename T> static constexpr unsigned computeHashAndMaskTop8Bits(const T* data)
     {
-        return computeHashAndMaskTop8Bits<T, defaultConverter>(data);
+        return computeHashAndMaskTop8Bits<T, DefaultConverter>(data);
     }
 
-    template<typename T, UChar Converter(T)> static constexpr unsigned computeHash(const T* data, unsigned length)
+    template<typename T, typename Converter> static constexpr unsigned computeHash(const T* data, unsigned length)
     {
         return finalize(computeHashImpl<T, Converter>(data, length));
     }
 
-    template<typename T, UChar Converter(T)> static constexpr unsigned computeHash(const T* data)
+    template<typename T, typename Converter> static constexpr unsigned computeHash(const T* data)
     {
         return finalize(computeHashImpl<T, Converter>(data));
     }
@@ -195,12 +203,12 @@
 
     template<typename T> static constexpr unsigned computeHash(const T* data, unsigned length)
     {
-        return computeHash<T, defaultConverter>(data, length);
+        return computeHash<T, DefaultConverter>(data, length);
     }
 
     template<typename T> static constexpr unsigned computeHash(const T* data)
     {
-        return computeHash<T, defaultConverter>(data);
+        return computeHash<T, DefaultConverter>(data);
     }
 
 
@@ -207,13 +215,13 @@
     template<typename T, unsigned charactersCount>
     static constexpr unsigned computeLiteralHash(const T (&characters)[charactersCount])
     {
-        return computeHash<T, defaultConverter>(characters, charactersCount - 1);
+        return computeHash<T, DefaultConverter>(characters, charactersCount - 1);
     }
 
     template<typename T, unsigned charactersCount>
     static constexpr unsigned computeLiteralHashAndMaskTop8Bits(const T (&characters)[charactersCount])
     {
-        return computeHashAndMaskTop8Bits<T, defaultConverter>(characters, charactersCount - 1);
+        return computeHashAndMaskTop8Bits<T, DefaultConverter>(characters, charactersCount - 1);
     }
 
     static unsigned hashMemory(const void* data, unsigned length)
@@ -234,26 +242,6 @@
     }
 
 private:
-    static constexpr UChar defaultConverter(UChar character)
-    {
-        return character;
-    }
-
-    static constexpr UChar defaultConverter(LChar character)
-    {
-        return character;
-    }
-
-    static constexpr UChar defaultConverter(char character)
-    {
-        return static_cast<LChar>(character);
-    }
-
-    static constexpr UChar defaultConverter(char16_t character)
-    {
-        return character;
-    }
-
     ALWAYS_INLINE static constexpr unsigned avalancheBits(unsigned hash)
     {
         unsigned result = hash;
@@ -312,7 +300,7 @@
         return result;
     }
 
-    template<typename T, UChar Converter(T)>
+    template<typename T, typename Converter>
     static constexpr unsigned computeHashImpl(const T* characters, unsigned length)
     {
         unsigned result = stringHashingStartValue;
@@ -320,16 +308,16 @@
         length >>= 1;
 
         while (length--) {
-            result = calculateWithTwoCharacters(result, Converter(characters[0]), Converter(characters[1]));
+            result = calculateWithTwoCharacters(result, Converter::convert(characters[0]), Converter::convert(characters[1]));
             characters += 2;
         }
 
         if (remainder)
-            return calculateWithRemainingLastCharacter(result, Converter(characters[0]));
+            return calculateWithRemainingLastCharacter(result, Converter::convert(characters[0]));
         return result;
     }
 
-    template<typename T, UChar Converter(T)>
+    template<typename T, typename Converter>
     static constexpr unsigned computeHashImpl(const T* characters)
     {
         unsigned result = stringHashingStartValue;
@@ -336,8 +324,8 @@
         while (T a = *characters++) {
             T b = *characters++;
             if (!b)
-                return calculateWithRemainingLastCharacter(result, Converter(a));
-            result = calculateWithTwoCharacters(result, Converter(a), Converter(b));
+                return calculateWithRemainingLastCharacter(result, Converter::convert(a));
+            result = calculateWithTwoCharacters(result, Converter::convert(a), Converter::convert(b));
         }
         return result;
     }

Modified: trunk/Source/WebKit/ChangeLog (225750 => 225751)


--- trunk/Source/WebKit/ChangeLog	2017-12-11 19:19:35 UTC (rev 225750)
+++ trunk/Source/WebKit/ChangeLog	2017-12-11 19:22:01 UTC (rev 225751)
@@ -1,3 +1,13 @@
+2017-12-11  Yusuke Suzuki  <utatane....@gmail.com>
+
+        [WTF] Add Converter traits to StringHasher instead of function pointer
+        https://bugs.webkit.org/show_bug.cgi?id=180656
+
+        Reviewed by JF Bastien.
+
+        * WebProcess/WebProcess.cpp:
+        (WebKit::addCaseFoldedCharacters):
+
 2017-12-11  David Quesada  <david_ques...@apple.com>
 
         Turn on ENABLE_APPLICATION_MANIFEST

Modified: trunk/Source/WebKit/WebProcess/WebProcess.cpp (225750 => 225751)


--- trunk/Source/WebKit/WebProcess/WebProcess.cpp	2017-12-11 19:19:35 UTC (rev 225750)
+++ trunk/Source/WebKit/WebProcess/WebProcess.cpp	2017-12-11 19:22:01 UTC (rev 225751)
@@ -779,10 +779,10 @@
     if (string.isEmpty())
         return;
     if (string.is8Bit()) {
-        hasher.addCharacters<LChar, ASCIICaseInsensitiveHash::foldCase<LChar>>(string.characters8(), string.length());
+        hasher.addCharacters<LChar, ASCIICaseInsensitiveHash::FoldCase<LChar>>(string.characters8(), string.length());
         return;
     }
-    hasher.addCharacters<UChar, ASCIICaseInsensitiveHash::foldCase<UChar>>(string.characters16(), string.length());
+    hasher.addCharacters<UChar, ASCIICaseInsensitiveHash::FoldCase<UChar>>(string.characters16(), string.length());
 }
 
 static unsigned hashForPlugInOrigin(const String& pageOrigin, const String& pluginOrigin, const String& mimeType)

_______________________________________________
webkit-changes mailing list
webkit-changes@lists.webkit.org
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to