reflow comments in wtf

third_party/WebKit/Source/wtf/HashFunctions.h

 /*
  * Copyright (C) 2005, 2006, 2008 Apple 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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 36 matching lines @@
   typedef uint32_t UnsignedType;
 };
 template <>
 struct IntTypes<8> {
   typedef int64_t SignedType;
   typedef uint64_t UnsignedType;
 };
 
 // integer hash function
 
-// Thomas Wang's 32 Bit Mix Function: http://www.cris.com/~Ttwang/tech/inthash.htm
+// Thomas Wang's 32 Bit Mix Function:
+// http://www.cris.com/~Ttwang/tech/inthash.htm
 inline unsigned hashInt(uint8_t key8) {
   unsigned key = key8;
   key += ~(key << 15);
   key ^= (key >> 10);
   key += (key << 3);
   key ^= (key >> 6);
   key += ~(key << 11);
   key ^= (key >> 16);
   return key;
 }
 
-// Thomas Wang's 32 Bit Mix Function: http://www.cris.com/~Ttwang/tech/inthash.htm
+// Thomas Wang's 32 Bit Mix Function:
+// http://www.cris.com/~Ttwang/tech/inthash.htm
 inline unsigned hashInt(uint16_t key16) {
   unsigned key = key16;
   key += ~(key << 15);
   key ^= (key >> 10);
   key += (key << 3);
   key ^= (key >> 6);
   key += ~(key << 11);
   key ^= (key >> 16);
   return key;
 }
 
-// Thomas Wang's 32 Bit Mix Function: http://www.cris.com/~Ttwang/tech/inthash.htm
+// Thomas Wang's 32 Bit Mix Function:
+// http://www.cris.com/~Ttwang/tech/inthash.htm
 inline unsigned hashInt(uint32_t key) {
   key += ~(key << 15);
   key ^= (key >> 10);
   key += (key << 3);
   key ^= (key >> 6);
   key += ~(key << 11);
   key ^= (key >> 16);
   return key;
 }
 
-// Thomas Wang's 64 bit Mix Function: http://www.cris.com/~Ttwang/tech/inthash.htm
+// Thomas Wang's 64 bit Mix Function:
+// http://www.cris.com/~Ttwang/tech/inthash.htm
 inline unsigned hashInt(uint64_t key) {
   key += ~(key << 32);
   key ^= (key >> 22);
   key += ~(key << 13);
   key ^= (key >> 8);
   key += (key << 3);
   key ^= (key >> 15);
   key += ~(key << 27);
   key ^= (key >> 31);
   return static_cast<unsigned>(key);
 }
 
-// Compound integer hash method: http://opendatastructures.org/versions/edition-0.1d/ods-java/node33.html#SECTION00832000000000000000
+// Compound integer hash method:
+// http://opendatastructures.org/versions/edition-0.1d/ods-java/node33.html#SECTION00832000000000000000
 inline unsigned hashInts(unsigned key1, unsigned key2) {
   unsigned shortRandom1 = 277951225;          // A random 32-bit value.
   unsigned shortRandom2 = 95187966;           // A random 32-bit value.
   uint64_t longRandom = 19248658165952622LL;  // A random 64-bit value.
 
   uint64_t product = longRandom * (shortRandom1 * key1 + shortRandom2 * key2);
   unsigned highBits =
       static_cast<unsigned>(product >> (sizeof(uint64_t) - sizeof(unsigned)));
   return highBits;
 }
@@ skipping 18 matching lines @@
   static const bool safeToCompareToEmptyOrDeleted = true;
 };
 
 // pointer identity hash function
 
 template <typename T>
 struct PtrHash {
   static unsigned hash(T* key) {
 #if COMPILER(MSVC)
 #pragma warning(push)
-#pragma warning( \
-    disable : 4244)  // work around what seems to be a bug in MSVC's conversion warnings
+// work around what seems to be a bug in MSVC's conversion warnings
+#pragma warning(disable : 4244)
 #endif
     return IntHash<uintptr_t>::hash(reinterpret_cast<uintptr_t>(key));
 #if COMPILER(MSVC)
 #pragma warning(pop)
 #endif
   }
   static bool equal(T* a, T* b) { return a == b; }
   static bool equal(std::nullptr_t, T* b) { return !b; }
   static bool equal(T* a, std::nullptr_t) { return !a; }
   static const bool safeToCompareToEmptyOrDeleted = true;
@@ skipping 29 matching lines @@
     return a == b.get();
   }
 };
 
 // Default hash function for each type.
 template <typename T>
 struct DefaultHash;
 
 // Actual implementation of DefaultHash.
 //
-// The case of |isIntegral| == false is not implemented. If you see a compile error saying DefaultHashImpl<T, false>
-// is not defined, that's because the default hash functions for T are not defined. You need to implement them yourself.
+// The case of |isIntegral| == false is not implemented. If you see a compile
+// error saying DefaultHashImpl<T, false> is not defined, that's because the
+// default hash functions for T are not defined. You need to implement them
+// yourself.
 template <typename T, bool isIntegral>
 struct DefaultHashImpl;
 
 template <typename T>
 struct DefaultHashImpl<T, true> {
   using Hash = IntHash<typename std::make_unsigned<T>::type>;
 };
 
 // Canonical implementation of DefaultHash.
 template <typename T>
@@ skipping 67 matching lines @@
   using Hash = PairHash<T, U>;
 };
 
 }  // namespace WTF
 
 using WTF::DefaultHash;
 using WTF::IntHash;
 using WTF::PtrHash;
 
 #endif  // WTF_HashFunctions_h