Deprecate some macros in wtf/Assertions.h in favor of base/logging.h

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 22 matching lines @@
    Note, this file uses many GCC extensions, but it should be compatible with
    C, Objective C, C++, and Objective C++.
 
    For non-debug builds, everything is disabled by default, except for the
    RELEASE_ASSERT family of macros.
 
    Defining any of the symbols explicitly prevents this from having any effect.
 
 */
 
+#include "base/logging.h"
 #include "wtf/Compiler.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/WTFExport.h"
 #include "wtf/build_config.h"
 #include <stdarg.h>
 
 // Users must test "#if ENABLE(ASSERT)", which helps ensure that code
 // testing this macro has included this header.
 #ifndef ENABLE_ASSERT
 #if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
@@ skipping 76 matching lines @@
     (WTFReportBacktrace(), (*(int*)0xfbadbeef = 0), IMMEDIATE_CRASH())
 #endif
 #endif
 
 #if COMPILER(CLANG)
 #define NO_RETURN_DUE_TO_CRASH NO_RETURN
 #else
 #define NO_RETURN_DUE_TO_CRASH
 #endif
 
-/* ASSERT, ASSERT_NOT_REACHED, ASSERT_UNUSED
-
-  These macros are compiled out of release builds.
-  Expressions inside them are evaluated in debug builds only.
-*/
+// ASSERT, ASSERT_NOT_REACHED, ASSERT_UNUSED
+//  These macros are compiled out of release builds.
+//  Expressions inside them are evaluated in debug builds only.
+//  They are deprecated. We should use:
+//    - DCHECK() for ASSERT()
+//    - NOTREACHED() for ASSERT_NOT_REACHED()
+//    - DCHECK() and ALLOW_UNUSED_LOCAL() for ASSERT_UNUSED().
 #if OS(WIN)
 /* FIXME: Change to use something other than ASSERT to avoid this conflict with the underlying platform */
 #undef ASSERT
 #endif
 
 #if ENABLE(ASSERT)
 
 #define ASSERT(assertion) \
     (!(assertion) ? \
         (WTFReportAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #assertion), \
@@ skipping 51 matching lines @@
 #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
 
-/* ASSERT_WITH_MESSAGE */
-
+// ASSERT_WITH_MESSAGE
+// This is deprecated.  We should use DCHECK() << "message".
 #if ASSERT_MSG_DISABLED
 #define ASSERT_WITH_MESSAGE(assertion, ...) ((void)0)
 #else
 #define ASSERT_WITH_MESSAGE(assertion, ...) do \
     if (!(assertion)) { \
         WTFReportAssertionFailureWithMessage(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #assertion, __VA_ARGS__); \
         CRASH(); \
     } \
 while (0)
 #endif
 
-/* ASSERT_WITH_MESSAGE_UNUSED */
-
+// ASSERT_WITH_MESSAGE_UNUSED
+// This is deprecated.  We should use DCHECK() << "message" and
+// ALLOW_UNUSED_LOCAL().
 #if ASSERT_MSG_DISABLED
 #define ASSERT_WITH_MESSAGE_UNUSED(variable, assertion, ...) ((void)variable)
 #else
 #define ASSERT_WITH_MESSAGE_UNUSED(variable, assertion, ...) do \
     if (!(assertion)) { \
         WTFReportAssertionFailureWithMessage(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #assertion, __VA_ARGS__); \
         CRASH(); \
     } \
 while (0)
 #endif
 
 /* ASSERT_ARG */
 
 #if ASSERT_ARG_DISABLED
 
 #define ASSERT_ARG(argName, assertion) ((void)0)
 
 #else
 
 #define ASSERT_ARG(argName, assertion) do \
     if (!(assertion)) { \
         WTFReportArgumentAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #argName, #assertion); \
         CRASH(); \
     } \
 while (0)
 
 #endif
 
-/* FATAL */
-
+// FATAL
+// This is deprecated.  We should use DLOG(FATAL) << ...
 #if FATAL_DISABLED
 #define FATAL(...) ((void)0)
 #else
 #define FATAL(...) do { \
     WTFReportFatalError(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, __VA_ARGS__); \
     CRASH(); \
 } while (0)
 #endif
 
-/* WTF_LOG_ERROR */
-
+// WTF_LOG_ERROR
+// This is deprecated.  We should use DLOG(ERROR) << ...
 #if ERROR_DISABLED
 #define WTF_LOG_ERROR(...) ((void)0)
 #else
 #define WTF_LOG_ERROR(...) WTFReportError(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, __VA_ARGS__)
 #endif
 
-/* WTF_LOG */
-
+// WTF_LOG
+// This is deprecated.  Should be replaced with DVLOG(verboselevel), which works
+// only in debug build, or VLOG(verboselevel), which works in release build too.
 #if LOG_DISABLED
 #define WTF_LOG(channel, ...) ((void)0)
 #else
 #define WTF_LOG(channel, ...) WTFLog(&JOIN_LOG_CHANNEL_WITH_PREFIX(LOG_CHANNEL_PREFIX, channel), __VA_ARGS__)
 #define JOIN_LOG_CHANNEL_WITH_PREFIX(prefix, channel) JOIN_LOG_CHANNEL_WITH_PREFIX_LEVEL_2(prefix, channel)
 #define JOIN_LOG_CHANNEL_WITH_PREFIX_LEVEL_2(prefix, channel) prefix ## channel
 #endif
 
 /* RELEASE_ASSERT
 
    Use in places where failure of an assertion indicates a definite security
    vulnerability from which execution must not continue even in a release build.
    Please sure to file bugs for these failures using the security template:
       http://code.google.com/p/chromium/issues/entry?template=Security%20Bug
 */
-
+// RELEASE_ASSERT* are deprecated.  We should use:
+//  - CHECK() for RELEASE_ASSERT()
+//  - CHECK() << message for RELEASE_ASSERT_WITH_MESSAGE()
+//  - RELEASE_NOTREACHED() for RELEASE_ASSERT_NOT_REACHED().
 #if ENABLE(ASSERT)
 #define RELEASE_ASSERT(assertion) ASSERT(assertion)
 #define RELEASE_ASSERT_WITH_MESSAGE(assertion, ...) ASSERT_WITH_MESSAGE(assertion, __VA_ARGS__)
 #define RELEASE_ASSERT_NOT_REACHED() ASSERT_NOT_REACHED()
 #else
 #define RELEASE_ASSERT(assertion) (UNLIKELY(!(assertion)) ? (IMMEDIATE_CRASH()) : (void)0)
 #define RELEASE_ASSERT_WITH_MESSAGE(assertion, ...) RELEASE_ASSERT(assertion)
 #define RELEASE_ASSERT_NOT_REACHED() IMMEDIATE_CRASH()
 #endif
+// TODO(tkent): Move this to base/logging.h?
+#define RELEASE_NOTREACHED() LOG(FATAL)
 
 /* DEFINE_COMPARISON_OPERATORS_WITH_REFERENCES */
 
 // Allow equality comparisons of Objects by reference or pointer, interchangeably.
 // This can be only used on types whose equality makes no other sense than pointer equality.
 #define DEFINE_COMPARISON_OPERATORS_WITH_REFERENCES(thisType) \
     inline bool operator==(const thisType& a, const thisType& b) { 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; } \
     inline bool operator!=(const thisType& a, const thisType& b) { return !(a == b); } \
@@ skipping 27 matching lines @@
 } \
 inline const thisType& to##thisType(const argumentType& argumentName) \
 { \
     ASSERT_WITH_SECURITY_IMPLICATION(referencePredicate); \
     return static_cast<const thisType&>(argumentName); \
 } \
 void to##thisType(const thisType*); \
 void to##thisType(const thisType&)
 
 #endif /* WTF_Assertions_h */