Cleanup of wtf/Assertions.*.

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
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WTF_Assertions_h
 #define WTF_Assertions_h
 
-/*
-   No namespaces because this file has to be includable from C and Objective-C.
-
-   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.
-
-*/
+// This file uses some GCC extensions, but it should be compatible with C++ and
+// Objective C++.
+//
+// For non-debug builds, everything is disabled by default, except for the
+// RELEASE_ASSERT family of macros.
 
 #include "base/gtest_prod_util.h"
 #include "base/logging.h"
 #include "wtf/Compiler.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/WTFExport.h"
 #include "wtf/build_config.h"
 #include <stdarg.h>
 
 #if OS(WIN)
 #include <windows.h>
 #endif
 
 // 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)
 /* Disable ASSERT* macros in release mode by default. */
 #define ENABLE_ASSERT 0
 #else
 #define ENABLE_ASSERT 1
 #endif /* defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON) */
 #endif
 
-#ifndef ASSERT_MSG_DISABLED
-#define ASSERT_MSG_DISABLED !ENABLE(ASSERT)
-#endif
-
 #ifndef LOG_DISABLED
 #define LOG_DISABLED !ENABLE(ASSERT)
 #endif
 
 #if COMPILER(GCC)
 #define WTF_ATTRIBUTE_PRINTF(formatStringArgument, extraArguments) __attribute__((__format__(printf, formatStringArgument, extraArguments)))
 #else
 #define WTF_ATTRIBUTE_PRINTF(formatStringArgument, extraArguments)
 #endif
 
-/* These helper functions are always declared, but not necessarily always defined if the corresponding function is disabled. */
+// These helper functions are always declared, but not necessarily always
+// defined if the corresponding function is disabled.
 
 WTF_EXPORT void WTFReportAssertionFailure(const char* file, int line, const char* function, const char* assertion);
+// WTFLogAlways() is deprecated. crbug.com/638849
 WTF_EXPORT void WTFLogAlways(const char* format, ...) WTF_ATTRIBUTE_PRINTF(1, 2);
-
-WTF_EXPORT void WTFGetBacktrace(void** stack, int* size);
 WTF_EXPORT void WTFReportBacktrace(int framesToShow = 31);
-WTF_EXPORT void WTFPrintBacktrace(void** stack, int size);
 
 namespace WTF {
 
 #if LOG_DISABLED
 
 #define WTF_CREATE_SCOPED_LOGGER(...) ((void) 0)
 #define WTF_CREATE_SCOPED_LOGGER_IF(...) ((void) 0)
 #define WTF_APPEND_SCOPED_LOGGER(...) ((void) 0)
 
 #else
@@ skipping 33 matching lines @@
 };
 
 #define WTF_CREATE_SCOPED_LOGGER(name, ...) WTF::ScopedLogger name(true, __VA_ARGS__)
 #define WTF_CREATE_SCOPED_LOGGER_IF(name, condition, ...) WTF::ScopedLogger name(condition, __VA_ARGS__)
 #define WTF_APPEND_SCOPED_LOGGER(name, ...) (name.log(__VA_ARGS__))
 
 #endif // LOG_DISABLED
 
 } // namespace WTF
 
-/* IMMEDIATE_CRASH() - Like CRASH() below but crashes in the fastest, simplest possible way with no attempt at logging. */
+// IMMEDIATE_CRASH() - Like CRASH() below but crashes in the fastest, simplest
+// possible way with no attempt at logging.
 #ifndef IMMEDIATE_CRASH
 #if COMPILER(GCC) || COMPILER(CLANG)
 #define IMMEDIATE_CRASH() __builtin_trap()
 #else
 #define IMMEDIATE_CRASH() ((void)(*(volatile char*)0 = 0))
 #endif
 #endif
 
-/* OOM_CRASH() - Specialization of IMMEDIATE_CRASH which will raise a custom exception on Windows to signal this is OOM and not a normal assert. */
+// OOM_CRASH() - Specialization of IMMEDIATE_CRASH which will raise a custom
+// exception on Windows to signal this is OOM and not a normal assert.
 #ifndef OOM_CRASH
 #if OS(WIN)
 #define OOM_CRASH() do { \
     ::RaiseException(0xE0000008, EXCEPTION_NONCONTINUABLE, 0, nullptr); \
     IMMEDIATE_CRASH(); \
 } while (0)
 #else
 #define OOM_CRASH() IMMEDIATE_CRASH()
 #endif
 #endif
 
-/* CRASH() - Raises a fatal error resulting in program termination and triggering either the debugger or the crash reporter.
-
-   Use CRASH() in response to known, unrecoverable errors like out-of-memory.
-   Macro is enabled in both debug and release mode.
-   To test for unknown errors and verify assumptions, use ASSERT instead, to avoid impacting performance in release builds.
-
-   Signals are ignored by the crash reporter on OS X so we must do better.
-*/
+// CRASH() - Raises a fatal error resulting in program termination and
+// triggering either the debugger or the crash reporter.
+//
+// Use CRASH() in response to known, unrecoverable errors like out-of-memory.
+// Macro is enabled in both debug and release mode.
+// To test for unknown errors and verify assumptions, use ASSERT instead, to
+// avoid impacting performance in release builds.
+//
+// Signals are ignored by the crash reporter on OS X so we must do better.
 #ifndef CRASH
 #if COMPILER(MSVC)
 #define CRASH() (__debugbreak(), IMMEDIATE_CRASH())
 #else
 #define CRASH() \
     (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.
 //  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 */
+// 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), \
             CRASH()) : \
         (void)0)
@@ skipping 52 matching lines @@
 #if ENABLE_SECURITY_ASSERT
 #define SECURITY_DCHECK(condition) LOG_IF(FATAL, !(condition)) << "Security check failed: " #condition ". "
 // TODO(tkent): Should we make SECURITY_CHECK different from SECURITY_DCHECK?
 // A SECURITY_CHECK failure is actually not vulnerable.
 #define SECURITY_CHECK(condition) SECURITY_DCHECK(condition)
 #else
 #define SECURITY_DCHECK(condition) ((void)0)
 #define SECURITY_CHECK(condition) CHECK(condition)
 #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
+// 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 is deprecated.  We should use CHECK() instead.
 #if ENABLE(ASSERT)
 #define RELEASE_ASSERT(assertion) ASSERT(assertion)
 #else
 #define RELEASE_ASSERT(assertion) (UNLIKELY(!(assertion)) ? (IMMEDIATE_CRASH()) : (void)0)
 #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_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); } \
     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 */
-
+// 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*); \
 void to##thisType(const thisType&)
 
-#endif /* WTF_Assertions_h */
+#endif // WTF_Assertions_h