Remove ASSERT_WITH_SECURITY_IMPLICATION.

third_party/WebKit/Source/wtf/Assertions.h

 /*
  * Copyright (C) 2003, 2006, 2007 Apple Inc.  All rights reserved.
  * Copyright (C) 2013 Google 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
@@ skipping 205 matching lines @@
 #define NO_RETURN_DUE_TO_ASSERT NO_RETURN_DUE_TO_CRASH
 
 #else
 
 #define ASSERT(assertion) ((void)0)
 #define ASSERT_NOT_REACHED() ((void)0)
 #define NO_RETURN_DUE_TO_ASSERT
 
 #endif
 
-// ASSERT_WITH_SECURITY_IMPLICATION
-// It is deprecated.  ASSERT_WITH_SECURITY_IMPLICATION should be replaced
-// with SECURITY_DCHECK.
-#ifdef ADDRESS_SANITIZER
-
-#define ASSERT_WITH_SECURITY_IMPLICATION(assertion)                            \
-  (!(assertion) ? (WTFReportAssertionFailure(__FILE__, __LINE__,               \
-                                             WTF_PRETTY_FUNCTION, #assertion), \
-                   CRASH())                                                    \
-                : (void)0)
-
-#else
-#define ASSERT_WITH_SECURITY_IMPLICATION(assertion) ASSERT(assertion)
-#endif
-
 // Users must test "#if ENABLE(SECURITY_ASSERT)", which helps ensure
 // that code testing this macro has included this header.
 #if defined(ADDRESS_SANITIZER) || ENABLE(ASSERT)
 #define ENABLE_SECURITY_ASSERT 1
 #else
 #define ENABLE_SECURITY_ASSERT 0
 #endif
 
 // SECURITY_DCHECK and SECURITY_CHECK
 // Use in places where failure of the assertion indicates a possible security
@@ skipping 47 matching lines @@
     return !(a == b);                                            \
   }                                                              \
   inline bool operator!=(const thisType& a, const thisType* b) { \
     return !(a == b);                                            \
   }                                                              \
   inline bool operator!=(const thisType* a, const thisType& b) { \
     return !(a == b);                                            \
   }
 
 // DEFINE_TYPE_CASTS
-// Provide static_cast<> wrappers with ASSERT_WITH_SECURITY_IMPLICATION for bad
-// casts.
-#define DEFINE_TYPE_CASTS(thisType, argumentType, argumentName,            \
-                          pointerPredicate, referencePredicate)            \
-  inline thisType* to##thisType(argumentType* argumentName) {              \
-    ASSERT_WITH_SECURITY_IMPLICATION(!argumentName || (pointerPredicate)); \
-    return static_cast<thisType*>(argumentName);                           \
-  }                                                                        \
-  inline const thisType* to##thisType(const argumentType* argumentName) {  \
-    ASSERT_WITH_SECURITY_IMPLICATION(!argumentName || (pointerPredicate)); \
-    return static_cast<const thisType*>(argumentName);                     \
-  }                                                                        \
-  inline thisType& to##thisType(argumentType& argumentName) {              \
-    ASSERT_WITH_SECURITY_IMPLICATION(referencePredicate);                  \
-    return static_cast<thisType&>(argumentName);                           \
-  }                                                                        \
-  inline const thisType& to##thisType(const argumentType& argumentName) {  \
-    ASSERT_WITH_SECURITY_IMPLICATION(referencePredicate);                  \
-    return static_cast<const thisType&>(argumentName);                     \
-  }                                                                        \
-  void to##thisType(const thisType*);                                      \
+// Provide static_cast<> wrappers with SECURITY_DCHECK for bad casts.
+#define DEFINE_TYPE_CASTS(thisType, argumentType, argumentName,           \
+                          pointerPredicate, referencePredicate)           \
+  inline thisType* to##thisType(argumentType* argumentName) {             \
+    SECURITY_DCHECK(!argumentName || (pointerPredicate));                 \
+    return static_cast<thisType*>(argumentName);                          \
+  }                                                                       \
+  inline const thisType* to##thisType(const argumentType* argumentName) { \
+    SECURITY_DCHECK(!argumentName || (pointerPredicate));                 \
+    return static_cast<const thisType*>(argumentName);                    \
+  }                                                                       \
+  inline thisType& to##thisType(argumentType& argumentName) {             \
+    SECURITY_DCHECK(referencePredicate);                                  \
+    return static_cast<thisType&>(argumentName);                          \
+  }                                                                       \
+  inline const thisType& to##thisType(const argumentType& argumentName) { \
+    SECURITY_DCHECK(referencePredicate);                                  \
+    return static_cast<const thisType&>(argumentName);                    \
+  }                                                                       \
+  void to##thisType(const thisType*);                                     \
   void to##thisType(const thisType&)
 
 #endif  // WTF_Assertions_h