Remove WTF_ATTRIBUTE_PRINTF.

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 42 matching lines @@
 #define ENABLE_ASSERT 0
 #else
 #define ENABLE_ASSERT 1
 #endif /* defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON) */
 #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

[Yuta Kitamura, 2016/11/21 08:58:39]

Can you explicitly include base/compiler_specific.h and document
the availability of PRINTF_FORMAT here?

[tkent, 2016/11/21 09:12:30]

The Blink counterpart of base/compiler_specific.h is wtf/Compiler.h.  Should we
include base/compiler_specific.h though this file already includes
wtf/Compiler.h?

[Yuta Kitamura, 2016/11/21 09:27:48]

That's okay, too.

[tkent, 2016/11/22 02:15:18]

Uploaded Patch Set 2.

-
 // 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 PRINTF_FORMAT(1, 2) void WTFLogAlways(const char* format, ...);
 WTF_EXPORT void WTFReportBacktrace(int framesToShow = 31);
 
 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);
+  PRINTF_FORMAT(3, 4) ScopedLogger(bool condition, const char* format, ...);
   ~ScopedLogger();
-  void log(const char* format, ...) WTF_ATTRIBUTE_PRINTF(2, 3);
+  PRINTF_FORMAT(2, 3) void log(const char* format, ...);
 
  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();
@@ skipping 186 matching lines @@
     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