Apply clang-format with Chromium-style without column limit.

third_party/WebKit/Source/wtf/PrintStream.h

 /*
  * Copyright (C) 2012 Apple 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
@@ skipping 20 matching lines @@
 #include "wtf/StdLibExtras.h"
 #include "wtf/WTFExport.h"
 #include <stdarg.h>
 
 namespace WTF {
 
 class CString;
 class String;
 
 class WTF_EXPORT PrintStream {
-    USING_FAST_MALLOC(PrintStream); WTF_MAKE_NONCOPYABLE(PrintStream);
-public:
-    PrintStream();
-    virtual ~PrintStream();
+  USING_FAST_MALLOC(PrintStream);
+  WTF_MAKE_NONCOPYABLE(PrintStream);
 
-    void printf(const char* format, ...) WTF_ATTRIBUTE_PRINTF(2, 3);
-    virtual void vprintf(const char* format, va_list) WTF_ATTRIBUTE_PRINTF(2, 0) = 0;
+ public:
+  PrintStream();
+  virtual ~PrintStream();
 
-    // Typically a no-op for many subclasses of PrintStream, this is a hint that
-    // the implementation should flush its buffers if it had not done so already.
-    virtual void flush();
+  void printf(const char* format, ...) WTF_ATTRIBUTE_PRINTF(2, 3);
+  virtual void vprintf(const char* format, va_list) WTF_ATTRIBUTE_PRINTF(2, 0) = 0;
 
-    template <typename T>
-    void print(const T& value)
-    {
-        printInternal(*this, value);
-    }
+  // Typically a no-op for many subclasses of PrintStream, this is a hint that
+  // the implementation should flush its buffers if it had not done so already.
+  virtual void flush();
 
-    template <typename T1, typename... RemainingTypes>
-    void print(const T1& value1, const RemainingTypes&... values)
-    {
-        print(value1);
-        print(values...);
-    }
+  template <typename T>
+  void print(const T& value) {
+    printInternal(*this, value);
+  }
+
+  template <typename T1, typename... RemainingTypes>
+  void print(const T1& value1, const RemainingTypes&... values) {
+    print(value1);
+    print(values...);
+  }
 };
 
 WTF_EXPORT void printInternal(PrintStream&, const char*);
 WTF_EXPORT void printInternal(PrintStream&, const CString&);
 WTF_EXPORT void printInternal(PrintStream&, const String&);
-inline void printInternal(PrintStream& out, char* value) { printInternal(out, static_cast<const char*>(value)); }
-inline void printInternal(PrintStream& out, CString& value) { printInternal(out, static_cast<const CString&>(value)); }
-inline void printInternal(PrintStream& out, String& value) { printInternal(out, static_cast<const String&>(value)); }
+inline void printInternal(PrintStream& out, char* value) {
+  printInternal(out, static_cast<const char*>(value));
+}
+inline void printInternal(PrintStream& out, CString& value) {
+  printInternal(out, static_cast<const CString&>(value));
+}
+inline void printInternal(PrintStream& out, String& value) {
+  printInternal(out, static_cast<const String&>(value));
+}
 WTF_EXPORT void printInternal(PrintStream&, bool);
 WTF_EXPORT void printInternal(PrintStream&, int);
 WTF_EXPORT void printInternal(PrintStream&, unsigned);
 WTF_EXPORT void printInternal(PrintStream&, long);
 WTF_EXPORT void printInternal(PrintStream&, unsigned long);
 WTF_EXPORT void printInternal(PrintStream&, long long);
 WTF_EXPORT void printInternal(PrintStream&, unsigned long long);
 WTF_EXPORT void printInternal(PrintStream&, float);
 WTF_EXPORT void printInternal(PrintStream&, double);
 
 template <typename T>
-void printInternal(PrintStream& out, const T& value)
-{
-    value.dump(out);
+void printInternal(PrintStream& out, const T& value) {
+  value.dump(out);
 }
 
 #define MAKE_PRINT_ADAPTOR(Name, Type, function) \
-    class Name {                                 \
-    public:                                      \
-        Name(const Type& value)                  \
-            : m_value(value)                     \
-        {                                        \
-        }                                        \
-        void dump(PrintStream& out) const        \
-        {                                        \
-            function(out, m_value);              \
-        }                                        \
-    private:                                     \
-        Type m_value;                            \
-    }
+  class Name {                                   \
+   public:                                       \
+    Name(const Type& value)                      \
+        : m_value(value) {                       \
+    }                                            \
+    void dump(PrintStream& out) const {          \
+      function(out, m_value);                    \
+    }                                            \
+                                                 \
+   private:                                      \
+    Type m_value;                                \
+  }
 
 #define MAKE_PRINT_METHOD_ADAPTOR(Name, Type, method) \
-    class Name {                                 \
-    public:                                      \
-        Name(const Type& value)                  \
-            : m_value(value)                     \
-        {                                        \
-        }                                        \
-        void dump(PrintStream& out) const        \
-        {                                        \
-            m_value.method(out);                 \
-        }                                        \
-    private:                                     \
-        const Type& m_value;                     \
-    }
+  class Name {                                        \
+   public:                                            \
+    Name(const Type& value)                           \
+        : m_value(value) {                            \
+    }                                                 \
+    void dump(PrintStream& out) const {               \
+      m_value.method(out);                            \
+    }                                                 \
+                                                      \
+   private:                                           \
+    const Type& m_value;                              \
+  }
 
-#define MAKE_PRINT_METHOD(Type, dumpMethod, method) \
-    MAKE_PRINT_METHOD_ADAPTOR(DumperFor_##method, Type, dumpMethod);    \
-    DumperFor_##method method() const { return DumperFor_##method(*this); }
+#define MAKE_PRINT_METHOD(Type, dumpMethod, method)                \
+  MAKE_PRINT_METHOD_ADAPTOR(DumperFor_##method, Type, dumpMethod); \
+  DumperFor_##method method() const { return DumperFor_##method(*this); }
 
 // Use an adaptor-based dumper for characters to avoid situations where
 // you've "compressed" an integer to a character and it ends up printing
 // as ASCII when you wanted it to print as a number.
 void dumpCharacter(PrintStream&, char);
 MAKE_PRINT_ADAPTOR(CharacterDump, char, dumpCharacter);
 
 template <typename T>
 class PointerDump {
-public:
-    PointerDump(const T* ptr)
-        : m_ptr(ptr)
-    {
-    }
+ public:
+  PointerDump(const T* ptr)
+      : m_ptr(ptr) {
+  }
 
-    void dump(PrintStream& out) const
-    {
-        if (m_ptr)
-            printInternal(out, *m_ptr);
-        else
-            out.print("(null)");
-    }
+  void dump(PrintStream& out) const {
+    if (m_ptr)
+      printInternal(out, *m_ptr);
+    else
+      out.print("(null)");
+  }
 
-private:
-    const T* m_ptr;
+ private:
+  const T* m_ptr;
 };
 
 template <typename T>
-PointerDump<T> pointerDump(const T* ptr) { return PointerDump<T>(ptr); }
+PointerDump<T> pointerDump(const T* ptr) {
+  return PointerDump<T>(ptr);
+}
 
-} // namespace WTF
+}  // namespace WTF
 
 using WTF::CharacterDump;
 using WTF::PointerDump;
 using WTF::PrintStream;
 using WTF::pointerDump;
 
-#endif // PrintStream_h
-
+#endif  // PrintStream_h