Replace ASSERT, ENABLE(ASSERT), and ASSERT_NOT_REACHED in wtf

third_party/WebKit/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 38 matching lines @@
   StringHasher()
       : m_hash(stringHashingStartValue),
         m_hasPendingCharacter(false),
         m_pendingCharacter(0) {}
 
   // The hasher hashes two characters at a time, and thus an "aligned" hasher is
   // one where an even number of characters have been added. Callers that
   // always add characters two at a time can use the "assuming aligned"
   // functions.
   void addCharactersAssumingAligned(UChar a, UChar b) {
-    ASSERT(!m_hasPendingCharacter);
+    DCHECK(!m_hasPendingCharacter);
     m_hash += a;
     m_hash = (m_hash << 16) ^ ((b << 11) ^ m_hash);
     m_hash += m_hash >> 11;
   }
 
   void addCharacter(UChar character) {
     if (m_hasPendingCharacter) {
       m_hasPendingCharacter = false;
       addCharactersAssumingAligned(m_pendingCharacter, character);
       return;
     }
 
     m_pendingCharacter = character;
     m_hasPendingCharacter = true;
   }
 
   void addCharacters(UChar a, UChar b) {
     if (m_hasPendingCharacter) {
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
       m_hasPendingCharacter = false;
 #endif
       addCharactersAssumingAligned(m_pendingCharacter, a);
       m_pendingCharacter = b;
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
       m_hasPendingCharacter = true;
 #endif
       return;
     }
 
     addCharactersAssumingAligned(a, b);
   }
 
   template <typename T, UChar Converter(T)>
   void addCharactersAssumingAligned(const T* data, unsigned length) {
-    ASSERT(!m_hasPendingCharacter);
+    DCHECK(!m_hasPendingCharacter);
 
     bool remainder = length & 1;
     length >>= 1;
 
     while (length--) {
       addCharactersAssumingAligned(Converter(data[0]), Converter(data[1]));
       data += 2;
     }
 
     if (remainder)
@@ skipping 72 matching lines @@
   template <typename T>
   static unsigned computeHash(const T* data, unsigned length) {
     return computeHash<T, defaultConverter>(data, length);
   }
 
   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));
+    DCHECK(!(length % 2));
     return computeHashAndMaskTop8Bits<UChar>(static_cast<const UChar*>(data),
                                              length / sizeof(UChar));
   }
 
   template <size_t length>
   static unsigned hashMemory(const void* data) {
     static_assert(!(length % 2), "length must be a multiple of two");
     return hashMemory(data, length);
   }
 
@@ skipping 25 matching lines @@
   unsigned m_hash;
   bool m_hasPendingCharacter;
   UChar m_pendingCharacter;
 };
 
 }  // namespace WTF
 
 using WTF::StringHasher;
 
 #endif  // WTF_StringHasher_h