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

third_party/WebKit/Source/wtf/StdLibExtras.h

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 62 matching lines @@
 
   static T& unwrap(T* singleton) { return *singleton; }
 };
 
 template <typename T>
 class StaticLocalWrapper<T, true> {
  public:
   using WrapType = blink::Persistent<T>;
 
   static T& unwrap(blink::Persistent<T>* singleton) {
-    ASSERT(singleton);
+    DCHECK(singleton);
     // If this assert triggers, you're supplying an empty ("()") 'Arguments'
     // argument to DEFINE_STATIC_LOCAL() - it must be the heap object you wish
     // to create as a static singleton and wrapped up with a Persistent
     // reference.
-    ASSERT(*singleton);
+    DCHECK(*singleton);
     return **singleton;
   }
 };
 
 #if DCHECK_IS_ON()
 #define DEFINE_STATIC_LOCAL_CHECK_THREADSAFE_ACCESS(Name) \
   static StaticLocalVerifier Name##StaticLocalVerifier;   \
-  ASSERT(Name##StaticLocalVerifier.isNotRacy())
+  DCHECK(Name##StaticLocalVerifier.isNotRacy())
 #else
 #define DEFINE_STATIC_LOCAL_CHECK_THREADSAFE_ACCESS(Name)
 #endif
 
 // Use DEFINE_STATIC_LOCAL() to declare and define a static local variable
 // (static T;) so that it is leaked and its destructors are not called at exit.
 // T may also be a Blink garbage collected object, in which case it is
 // wrapped up by an off-heap Persistent<T> reference to the object, keeping
 // it alive across GCs.
 //
@@ skipping 31 matching lines @@
  * - http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43976
  */
 #if CPU(ARM) && COMPILER(GCC)
 template <typename Type>
 bool isPointerTypeAlignmentOkay(Type* ptr) {
   return !(reinterpret_cast<intptr_t>(ptr) % __alignof__(Type));
 }
 
 template <typename TypePtr>
 TypePtr reinterpret_cast_ptr(void* ptr) {
-  ASSERT(isPointerTypeAlignmentOkay(reinterpret_cast<TypePtr>(ptr)));
+  DCHECK(isPointerTypeAlignmentOkay(reinterpret_cast<TypePtr>(ptr)));
   return reinterpret_cast<TypePtr>(ptr);
 }
 
 template <typename TypePtr>
 TypePtr reinterpret_cast_ptr(const void* ptr) {
-  ASSERT(isPointerTypeAlignmentOkay(reinterpret_cast<TypePtr>(ptr)));
+  DCHECK(isPointerTypeAlignmentOkay(reinterpret_cast<TypePtr>(ptr)));
   return reinterpret_cast<TypePtr>(ptr);
 }
 #else
 template <typename Type>
 bool isPointerTypeAlignmentOkay(Type*) {
   return true;
 }
 #define reinterpret_cast_ptr reinterpret_cast
 #endif
 
@@ skipping 65 matching lines @@
 template <typename T>
 char (&ArrayLengthHelperFunction(T (&)[0]))[0];
 #endif
 #define WTF_ARRAY_LENGTH(array) sizeof(::WTF::ArrayLengthHelperFunction(array))
 
 }  // namespace WTF
 
 // This version of placement new omits a 0 check.
 enum NotNullTag { NotNull };
 inline void* operator new(size_t, NotNullTag, void* location) {
-  ASSERT(location);
+  DCHECK(location);
   return location;
 }
 
 using WTF::bitwiseCast;
 using WTF::safeCast;
 
 #endif  // WTF_StdLibExtras_h