wtf reformat test

third_party/WebKit/Source/wtf/text/CString.h

 /*
  * Copyright (C) 2003, 2006, 2008, 2009, 2010, 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 18 matching lines @@
 #include "wtf/Allocator.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
 #include "wtf/WTFExport.h"
 
 namespace WTF {
 
 // CStringBuffer is the ref-counted storage class for the characters in a CString.
 // The data is implicitly allocated 1 character longer than length(), as it is zero-terminated.
 class WTF_EXPORT CStringBuffer : public RefCounted<CStringBuffer> {
-public:
-    const char* data() { return mutableData(); }
-    size_t length() const { return m_length; }
+ public:
+  const char* data() { return mutableData(); }
+  size_t length() const { return m_length; }
 
-private:
-    friend class CString;
-    friend class RefCounted<CStringBuffer>;
-    // CStringBuffers are allocated out of the WTF buffer partition.
-    void* operator new(size_t, void* ptr) { return ptr; }
-    void operator delete(void*);
+ private:
+  friend class CString;
+  friend class RefCounted<CStringBuffer>;
+  // CStringBuffers are allocated out of the WTF buffer partition.
+  void* operator new(size_t, void* ptr) { return ptr; }
+  void operator delete(void*);
 
-    static PassRefPtr<CStringBuffer> createUninitialized(size_t length);
+  static PassRefPtr<CStringBuffer> createUninitialized(size_t length);
 
-    CStringBuffer(size_t length) : m_length(length) { }
-    char* mutableData() { return reinterpret_cast<char*>(this + 1); }
+  CStringBuffer(size_t length) : m_length(length) {}
+  char* mutableData() { return reinterpret_cast<char*>(this + 1); }
 
-    const unsigned m_length;
+  const unsigned m_length;
 };
 
 // A container for a null-terminated char array supporting copy-on-write
 // assignment.  The contained char array may be null.
 class WTF_EXPORT CString {
-    USING_FAST_MALLOC(CString);
-public:
-    CString() { }
-    CString(const char*);
-    CString(const char*, size_t length);
-    CString(CStringBuffer* buffer) : m_buffer(buffer) { }
-    static CString newUninitialized(size_t length, char*& characterBuffer);
+  USING_FAST_MALLOC(CString);
 
-    const char* data() const
-    {
-        return m_buffer ? m_buffer->data() : 0;
-    }
-    char* mutableData();
-    size_t length() const
-    {
-        return m_buffer ? m_buffer->length() : 0;
-    }
+ public:
+  CString() {}
+  CString(const char*);
+  CString(const char*, size_t length);
+  CString(CStringBuffer* buffer) : m_buffer(buffer) {}
+  static CString newUninitialized(size_t length, char*& characterBuffer);
 
-    bool isNull() const { return !m_buffer; }
-    bool isSafeToSendToAnotherThread() const;
+  const char* data() const { return m_buffer ? m_buffer->data() : 0; }
+  char* mutableData();
+  size_t length() const { return m_buffer ? m_buffer->length() : 0; }
 
-    CStringBuffer* buffer() const { return m_buffer.get(); }
+  bool isNull() const { return !m_buffer; }
+  bool isSafeToSendToAnotherThread() const;
 
-private:
-    void copyBufferIfNeeded();
-    void init(const char*, size_t length);
-    RefPtr<CStringBuffer> m_buffer;
+  CStringBuffer* buffer() const { return m_buffer.get(); }
+
+ private:
+  void copyBufferIfNeeded();
+  void init(const char*, size_t length);
+  RefPtr<CStringBuffer> m_buffer;
 };
 
 WTF_EXPORT bool operator==(const CString& a, const CString& b);
-inline bool operator!=(const CString& a, const CString& b) { return !(a == b); }
+inline bool operator!=(const CString& a, const CString& b) {
+  return !(a == b);
+}
 WTF_EXPORT bool operator==(const CString& a, const char* b);
-inline bool operator!=(const CString& a, const char* b) { return !(a == b); }
+inline bool operator!=(const CString& a, const char* b) {
+  return !(a == b);
+}
 
-} // namespace WTF
+}  // namespace WTF
 
 using WTF::CString;
 
-#endif // CString_h
+#endif  // CString_h