Restore ScopedLogger and add documentation.

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/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>
 
 // Users must test "#if ENABLE(ASSERT)", which helps ensure that code
 // testing this macro has included this header.
 #ifndef ENABLE_ASSERT
@@ skipping 29 matching lines @@
 
 WTF_EXPORT void WTFReportAssertionFailure(const char* file, int line, const char* function, const char* assertion);
 WTF_EXPORT void WTFLog(WTFLogChannel*, const char* format, ...) WTF_ATTRIBUTE_PRINTF(2, 3);
 WTF_EXPORT void WTFLogVerbose(const char* file, int line, const char* function, WTFLogChannel*, const char* format, ...) WTF_ATTRIBUTE_PRINTF(5, 6);
 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
+
+// ScopedLogger wraps log messages in parentheses, with indentation proportional
+// to the number of instances. This makes it easy to see the flow of control in
+// the output, particularly when instrumenting recursive functions.
+//
+// NOTE: This class is a debugging tool, not intended for use by checked-in
+// code. Please do not remove it.
+//
+class WTF_EXPORT ScopedLogger {
+    WTF_MAKE_NONCOPYABLE(ScopedLogger);
+public:
+    // The first message is passed to the constructor.  Additional messages for
+    // the same scope can be added with log(). If condition is false, produce no
+    // output and do not create a scope.
+    ScopedLogger(bool condition, const char* format, ...) WTF_ATTRIBUTE_PRINTF(3, 4);
+    ~ScopedLogger();
+    void log(const char* format, ...) WTF_ATTRIBUTE_PRINTF(2, 3);
+
+private:
+    FRIEND_TEST_ALL_PREFIXES(AssertionsTest, ScopedLogger);
+    using PrintFunctionPtr = void (*)(const char* format, va_list args);
+    static void setPrintFuncForTests(PrintFunctionPtr p) { m_printFunc = p; } // Note: not thread safe.
+
+    void init(const char* format, va_list args);
+    void writeNewlineIfNeeded();
+    void indent();
+    void print(const char* format, ...);
+    void printIndent();
+    static ScopedLogger*& current();
+
+    ScopedLogger* const m_parent;
+    bool m_multiline; // The ')' will go on the same line if there is only one entry.
+    static PrintFunctionPtr m_printFunc;
+};
+
+#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. */
 #ifndef IMMEDIATE_CRASH
 #if COMPILER(GCC) || COMPILER(CLANG)
 #define IMMEDIATE_CRASH() __builtin_trap()
 #else
 #define IMMEDIATE_CRASH() ((void)(*(volatile char*)0 = 0))
 #endif
 #endif
 
 /* CRASH() - Raises a fatal error resulting in program termination and triggering either the debugger or the crash reporter.
@@ skipping 160 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 */