wtf reformat test

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

Index: third_party/WebKit/Source/wtf/text/StringBuilder.h
diff --git a/third_party/WebKit/Source/wtf/text/StringBuilder.h b/third_party/WebKit/Source/wtf/text/StringBuilder.h
index ba58742831c72491f5eb3b1adb1935c07025b386..6cb13e6460e9f4f5b10751967989bc8ffd6d0481 100644
--- a/third_party/WebKit/Source/wtf/text/StringBuilder.h
+++ b/third_party/WebKit/Source/wtf/text/StringBuilder.h
@@ -34,370 +34,355 @@
 namespace WTF {
 
 class WTF_EXPORT StringBuilder {
-    // Disallow copying since it's expensive and we don't want code to do it by accident.
-    WTF_MAKE_NONCOPYABLE(StringBuilder);
-
-public:
-    StringBuilder()
-        : m_bufferCharacters8(0)
-        , m_length(0)
-        , m_is8Bit(true)
-    {
+  // Disallow copying since it's expensive and we don't want code to do it by accident.
+  WTF_MAKE_NONCOPYABLE(StringBuilder);
+
+ public:
+  StringBuilder() : m_bufferCharacters8(0), m_length(0), m_is8Bit(true) {}
+
+  void append(const UChar*, unsigned);
+  void append(const LChar*, unsigned);
+
+  ALWAYS_INLINE void append(const char* characters, unsigned length) {
+    append(reinterpret_cast<const LChar*>(characters), length);
+  }
+
+  void append(const String& string) {
+    if (!string.length())
+      return;
+
+    // If we're appending to an empty string, and there is not a buffer (reserveCapacity has not been called)
+    // then just retain the string.
+    if (!m_length && !m_buffer) {
+      m_string = string;
+      m_length = string.length();
+      m_is8Bit = m_string.is8Bit();
+      return;
     }
 
-    void append(const UChar*, unsigned);
-    void append(const LChar*, unsigned);
-
-    ALWAYS_INLINE void append(const char* characters, unsigned length) { append(reinterpret_cast<const LChar*>(characters), length); }
-
-    void append(const String& string)
-    {
-        if (!string.length())
-            return;
-
-        // If we're appending to an empty string, and there is not a buffer (reserveCapacity has not been called)
-        // then just retain the string.
-        if (!m_length && !m_buffer) {
-            m_string = string;
-            m_length = string.length();
-            m_is8Bit = m_string.is8Bit();
-            return;
-        }
-
-        if (string.is8Bit())
-            append(string.characters8(), string.length());
-        else
-            append(string.characters16(), string.length());
+    if (string.is8Bit())
+      append(string.characters8(), string.length());
+    else
+      append(string.characters16(), string.length());
+  }
+
+  void append(const StringBuilder& other) {
+    if (!other.m_length)
+      return;
+
+    // If we're appending to an empty string, and there is not a buffer (reserveCapacity has not been called)
+    // then just retain the string.
+    if (!m_length && !m_buffer && !other.m_string.isNull()) {
+      m_string = other.m_string;
+      m_length = other.m_length;
+      return;
     }
 
-    void append(const StringBuilder& other)
-    {
-        if (!other.m_length)
-            return;
-
-        // If we're appending to an empty string, and there is not a buffer (reserveCapacity has not been called)
-        // then just retain the string.
-        if (!m_length && !m_buffer && !other.m_string.isNull()) {
-            m_string = other.m_string;
-            m_length = other.m_length;
-            return;
-        }
-
-        if (other.is8Bit())
-            append(other.characters8(), other.m_length);
-        else
-            append(other.characters16(), other.m_length);
+    if (other.is8Bit())
+      append(other.characters8(), other.m_length);
+    else
+      append(other.characters16(), other.m_length);
+  }
+
+  void append(const String& string, unsigned offset, unsigned length) {
+    if (!string.length())
+      return;
+
+    unsigned extent = offset + length;
+    if (extent < offset || extent > string.length())
+      return;
+
+    if (string.is8Bit())
+      append(string.characters8() + offset, length);
+    else
+      append(string.characters16() + offset, length);
+  }
+
+  void append(const StringView& string) {
+    if (!string.length())
+      return;
+
+    if (string.is8Bit())
+      append(string.characters8(), string.length());
+    else
+      append(string.characters16(), string.length());
+  }
+
+  void append(const char* characters) {
+    if (characters)
+      append(characters, strlen(characters));
+  }
+
+  void append(UChar c) {
+    if (m_buffer && m_length < m_buffer->length() && m_string.isNull()) {
+      if (!m_is8Bit) {
+        m_bufferCharacters16[m_length++] = c;
+        return;
+      }
+
+      if (!(c & ~0xff)) {
+        m_bufferCharacters8[m_length++] = static_cast<LChar>(c);
+        return;
+      }
     }
-
-    void append(const String& string, unsigned offset, unsigned length)
-    {
-        if (!string.length())
-            return;
-
-        unsigned extent = offset + length;
-        if (extent < offset || extent > string.length())
-            return;
-
-        if (string.is8Bit())
-            append(string.characters8() + offset, length);
-        else
-            append(string.characters16() + offset, length);
-    }
-
-    void append(const StringView& string)
-    {
-        if (!string.length())
-            return;
-
-        if (string.is8Bit())
-            append(string.characters8(), string.length());
-        else
-            append(string.characters16(), string.length());
-    }
-
-    void append(const char* characters)
-    {
-        if (characters)
-            append(characters, strlen(characters));
-    }
-
-    void append(UChar c)
-    {
-        if (m_buffer && m_length < m_buffer->length() && m_string.isNull()) {
-            if (!m_is8Bit) {
-                m_bufferCharacters16[m_length++] = c;
-                return;
-            }
-
-            if (!(c & ~0xff)) {
-                m_bufferCharacters8[m_length++] = static_cast<LChar>(c);
-                return;
-            }
-        }
-        append(&c, 1);
-    }
-
-    void append(LChar c)
-    {
-        if (m_buffer && m_length < m_buffer->length() && m_string.isNull()) {
-            if (m_is8Bit)
-                m_bufferCharacters8[m_length++] = c;
-            else
-                m_bufferCharacters16[m_length++] = c;
-        } else {
-            append(&c, 1);
-        }
+    append(&c, 1);
+  }
+
+  void append(LChar c) {
+    if (m_buffer && m_length < m_buffer->length() && m_string.isNull()) {
+      if (m_is8Bit)
+        m_bufferCharacters8[m_length++] = c;
+      else
+        m_bufferCharacters16[m_length++] = c;
+    } else {
+      append(&c, 1);
     }
+  }
 
-    void append(char c)
-    {
-        append(static_cast<LChar>(c));
-    }
-
-    void append(UChar32 c)
-    {
-        if (U_IS_BMP(c)) {
-            append(static_cast<UChar>(c));
-            return;
-        }
-        append(U16_LEAD(c));
-        append(U16_TRAIL(c));
-    }
-
-    template<unsigned charactersCount>
-    ALWAYS_INLINE void appendLiteral(const char (&characters)[charactersCount]) { append(characters, charactersCount - 1); }
-
-    void appendNumber(int);
-    void appendNumber(unsigned);
-    void appendNumber(long);
-    void appendNumber(unsigned long);
-    void appendNumber(long long);
-    void appendNumber(unsigned long long);
-    void appendNumber(double, unsigned precision = 6, TrailingZerosTruncatingPolicy = TruncateTrailingZeros);
-
-    String toString()
-    {
-        shrinkToFit();
-        if (m_string.isNull())
-            reifyString();
-        return m_string;
-    }
-
-    String substring(unsigned position, unsigned length) const
-    {
-        if (!m_length)
-            return emptyString();
-        if (!m_string.isNull())
-            return m_string.substring(position, length);
-        return reifySubstring(position, length);
-    }
-
-    AtomicString toAtomicString() const
-    {
-        if (!m_length)
-            return emptyAtom;
-
-        // If the buffer is sufficiently over-allocated, make a new AtomicString from a copy so its buffer is not so large.
-        if (canShrink()) {
-            if (is8Bit())
-                return AtomicString(characters8(), length());
-            return AtomicString(characters16(), length());
-        }
+  void append(char c) { append(static_cast<LChar>(c)); }
 
-        if (!m_string.isNull())
-            return AtomicString(m_string);
-
-        ASSERT(m_buffer);
-        return AtomicString(m_buffer.get(), 0, m_length);
+  void append(UChar32 c) {
+    if (U_IS_BMP(c)) {
+      append(static_cast<UChar>(c));
+      return;
     }
-
-    unsigned length() const
-    {
-        return m_length;
+    append(U16_LEAD(c));
+    append(U16_TRAIL(c));
+  }
+
+  template <unsigned charactersCount>
+  ALWAYS_INLINE void appendLiteral(const char (&characters)[charactersCount]) {
+    append(characters, charactersCount - 1);
+  }
+
+  void appendNumber(int);
+  void appendNumber(unsigned);
+  void appendNumber(long);
+  void appendNumber(unsigned long);
+  void appendNumber(long long);
+  void appendNumber(unsigned long long);
+  void appendNumber(double,
+                    unsigned precision = 6,
+                    TrailingZerosTruncatingPolicy = TruncateTrailingZeros);
+
+  String toString() {
+    shrinkToFit();
+    if (m_string.isNull())
+      reifyString();
+    return m_string;
+  }
+
+  String substring(unsigned position, unsigned length) const {
+    if (!m_length)
+      return emptyString();
+    if (!m_string.isNull())
+      return m_string.substring(position, length);
+    return reifySubstring(position, length);
+  }
+
+  AtomicString toAtomicString() const {
+    if (!m_length)
+      return emptyAtom;
+
+    // If the buffer is sufficiently over-allocated, make a new AtomicString from a copy so its buffer is not so large.
+    if (canShrink()) {
+      if (is8Bit())
+        return AtomicString(characters8(), length());
+      return AtomicString(characters16(), length());
     }
 
-    bool isEmpty() const { return !m_length; }
-
-    void reserveCapacity(unsigned newCapacity);
+    if (!m_string.isNull())
+      return AtomicString(m_string);
 
-    unsigned capacity() const
-    {
-        return m_buffer ? m_buffer->length() : m_length;
-    }
-
-    void resize(unsigned newSize);
+    ASSERT(m_buffer);
+    return AtomicString(m_buffer.get(), 0, m_length);
+  }
 
-    bool canShrink() const;
+  unsigned length() const { return m_length; }
 
-    void shrinkToFit();
+  bool isEmpty() const { return !m_length; }
 
-    UChar operator[](unsigned i) const
-    {
-        ASSERT_WITH_SECURITY_IMPLICATION(i < m_length);
-        if (m_is8Bit)
-            return characters8()[i];
-        return characters16()[i];
-    }
+  void reserveCapacity(unsigned newCapacity);
 
-    const LChar* characters8() const
-    {
-        ASSERT(m_is8Bit);
-        if (!m_length)
-            return 0;
-        if (!m_string.isNull())
-            return m_string.characters8();
-        ASSERT(m_buffer);
-        return m_buffer->characters8();
-    }
+  unsigned capacity() const { return m_buffer ? m_buffer->length() : m_length; }
 
-    const UChar* characters16() const
-    {
-        ASSERT(!m_is8Bit);
-        if (!m_length)
-            return 0;
-        if (!m_string.isNull())
-            return m_string.characters16();
-        ASSERT(m_buffer);
-        return m_buffer->characters16();
-    }
+  void resize(unsigned newSize);
 
-    bool is8Bit() const { return m_is8Bit; }
+  bool canShrink() const;
 
-    void clear()
-    {
-        m_length = 0;
-        m_string = String();
-        m_buffer = nullptr;
-        m_bufferCharacters8 = 0;
-        m_is8Bit = true;
-    }
+  void shrinkToFit();
 
-    void swap(StringBuilder& stringBuilder)
-    {
-        std::swap(m_length, stringBuilder.m_length);
-        m_string.swap(stringBuilder.m_string);
-        m_buffer.swap(stringBuilder.m_buffer);
-        std::swap(m_is8Bit, stringBuilder.m_is8Bit);
-        std::swap(m_bufferCharacters8, stringBuilder.m_bufferCharacters8);
-    }
+  UChar operator[](unsigned i) const {
+    ASSERT_WITH_SECURITY_IMPLICATION(i < m_length);
+    if (m_is8Bit)
+      return characters8()[i];
+    return characters16()[i];
+  }
 
-private:
-    void allocateBuffer(const LChar* currentCharacters, unsigned requiredLength);
-    void allocateBuffer(const UChar* currentCharacters, unsigned requiredLength);
-    void allocateBufferUpConvert(const LChar* currentCharacters, unsigned requiredLength);
-    template <typename CharType>
-    void reallocateBuffer(unsigned requiredLength);
-    template <typename CharType>
-    ALWAYS_INLINE CharType* appendUninitialized(unsigned length);
-    template <typename CharType>
-    CharType* appendUninitializedSlow(unsigned length);
-    template <typename CharType>
-    ALWAYS_INLINE CharType * getBufferCharacters();
-    void reifyString();
-    String reifySubstring(unsigned position, unsigned length) const;
-
-    String m_string; // Pointers first: crbug.com/232031
-    RefPtr<StringImpl> m_buffer;
-    union {
-        LChar* m_bufferCharacters8;
-        UChar* m_bufferCharacters16;
-    };
-    unsigned m_length;
-    bool m_is8Bit;
+  const LChar* characters8() const {
+    ASSERT(m_is8Bit);
+    if (!m_length)
+      return 0;
+    if (!m_string.isNull())
+      return m_string.characters8();
+    ASSERT(m_buffer);
+    return m_buffer->characters8();
+  }
+
+  const UChar* characters16() const {
+    ASSERT(!m_is8Bit);
+    if (!m_length)
+      return 0;
+    if (!m_string.isNull())
+      return m_string.characters16();
+    ASSERT(m_buffer);
+    return m_buffer->characters16();
+  }
+
+  bool is8Bit() const { return m_is8Bit; }
+
+  void clear() {
+    m_length = 0;
+    m_string = String();
+    m_buffer = nullptr;
+    m_bufferCharacters8 = 0;
+    m_is8Bit = true;
+  }
+
+  void swap(StringBuilder& stringBuilder) {
+    std::swap(m_length, stringBuilder.m_length);
+    m_string.swap(stringBuilder.m_string);
+    m_buffer.swap(stringBuilder.m_buffer);
+    std::swap(m_is8Bit, stringBuilder.m_is8Bit);
+    std::swap(m_bufferCharacters8, stringBuilder.m_bufferCharacters8);
+  }
+
+ private:
+  void allocateBuffer(const LChar* currentCharacters, unsigned requiredLength);
+  void allocateBuffer(const UChar* currentCharacters, unsigned requiredLength);
+  void allocateBufferUpConvert(const LChar* currentCharacters,
+                               unsigned requiredLength);
+  template <typename CharType>
+  void reallocateBuffer(unsigned requiredLength);
+  template <typename CharType>
+  ALWAYS_INLINE CharType* appendUninitialized(unsigned length);
+  template <typename CharType>
+  CharType* appendUninitializedSlow(unsigned length);
+  template <typename CharType>
+  ALWAYS_INLINE CharType* getBufferCharacters();
+  void reifyString();
+  String reifySubstring(unsigned position, unsigned length) const;
+
+  String m_string;  // Pointers first: crbug.com/232031
+  RefPtr<StringImpl> m_buffer;
+  union {
+    LChar* m_bufferCharacters8;
+    UChar* m_bufferCharacters16;
+  };
+  unsigned m_length;
+  bool m_is8Bit;
 };
 
 template <>
-ALWAYS_INLINE LChar* StringBuilder::getBufferCharacters<LChar>()
-{
-    ASSERT(m_is8Bit);
-    return m_bufferCharacters8;
+ALWAYS_INLINE LChar* StringBuilder::getBufferCharacters<LChar>() {
+  ASSERT(m_is8Bit);
+  return m_bufferCharacters8;
 }
 
 template <>
-ALWAYS_INLINE UChar* StringBuilder::getBufferCharacters<UChar>()
-{
-    ASSERT(!m_is8Bit);
-    return m_bufferCharacters16;
+ALWAYS_INLINE UChar* StringBuilder::getBufferCharacters<UChar>() {
+  ASSERT(!m_is8Bit);
+  return m_bufferCharacters16;
 }
 
 template <typename CharType>
-bool equal(const StringBuilder& s, const CharType* buffer, unsigned length)
-{
-    if (s.length() != length)
-        return false;
+bool equal(const StringBuilder& s, const CharType* buffer, unsigned length) {
+  if (s.length() != length)
+    return false;
 
-    if (s.is8Bit())
-        return equal(s.characters8(), buffer, length);
+  if (s.is8Bit())
+    return equal(s.characters8(), buffer, length);
 
-    return equal(s.characters16(), buffer, length);
+  return equal(s.characters16(), buffer, length);
 }
 
-template<typename CharType>
-bool equalIgnoringCase(const StringBuilder& s, const CharType* buffer, unsigned length)
-{
-    if (s.length() != length)
-        return false;
+template <typename CharType>
+bool equalIgnoringCase(const StringBuilder& s,
+                       const CharType* buffer,
+                       unsigned length) {
+  if (s.length() != length)
+    return false;
 
-    if (s.is8Bit())
-        return equalIgnoringCase(s.characters8(), buffer, length);
+  if (s.is8Bit())
+    return equalIgnoringCase(s.characters8(), buffer, length);
 
-    return equalIgnoringCase(s.characters16(), buffer, length);
+  return equalIgnoringCase(s.characters16(), buffer, length);
 }
 
-inline bool equalIgnoringCase(const StringBuilder& s, const char* string)
-{
-    return equalIgnoringCase(s, reinterpret_cast<const LChar*>(string), strlen(string));
+inline bool equalIgnoringCase(const StringBuilder& s, const char* string) {
+  return equalIgnoringCase(s, reinterpret_cast<const LChar*>(string),
+                           strlen(string));
 }
 
 template <typename StringType>
-bool equal(const StringBuilder& a, const StringType& b)
-{
-    if (a.length() != b.length())
-        return false;
-
-    if (!a.length())
-        return true;
-
-    if (a.is8Bit()) {
-        if (b.is8Bit())
-            return equal(a.characters8(), b.characters8(), a.length());
-        return equal(a.characters8(), b.characters16(), a.length());
-    }
+bool equal(const StringBuilder& a, const StringType& b) {
+  if (a.length() != b.length())
+    return false;
+
+  if (!a.length())
+    return true;
 
+  if (a.is8Bit()) {
     if (b.is8Bit())
-        return equal(a.characters16(), b.characters8(), a.length());
-    return equal(a.characters16(), b.characters16(), a.length());
+      return equal(a.characters8(), b.characters8(), a.length());
+    return equal(a.characters8(), b.characters16(), a.length());
+  }
+
+  if (b.is8Bit())
+    return equal(a.characters16(), b.characters8(), a.length());
+  return equal(a.characters16(), b.characters16(), a.length());
 }
 
 template <typename StringType>
-bool equalIgnoringCase(const StringBuilder& a, const StringType& b)
-{
-    if (a.length() != b.length())
-        return false;
-
-    if (!a.length())
-        return true;
-
-    if (a.is8Bit()) {
-        if (b.is8Bit())
-            return equalIgnoringCase(a.characters8(), b.characters8(), a.length());
-        return equalIgnoringCase(a.characters8(), b.characters16(), a.length());
-    }
+bool equalIgnoringCase(const StringBuilder& a, const StringType& b) {
+  if (a.length() != b.length())
+    return false;
+
+  if (!a.length())
+    return true;
 
+  if (a.is8Bit()) {
     if (b.is8Bit())
-        return equalIgnoringCase(a.characters16(), b.characters8(), a.length());
-    return equalIgnoringCase(a.characters16(), b.characters16(), a.length());
+      return equalIgnoringCase(a.characters8(), b.characters8(), a.length());
+    return equalIgnoringCase(a.characters8(), b.characters16(), a.length());
+  }
+
+  if (b.is8Bit())
+    return equalIgnoringCase(a.characters16(), b.characters8(), a.length());
+  return equalIgnoringCase(a.characters16(), b.characters16(), a.length());
 }
 
-inline bool operator==(const StringBuilder& a, const StringBuilder& b) { return equal(a, b); }
-inline bool operator!=(const StringBuilder& a, const StringBuilder& b) { return !equal(a, b); }
-inline bool operator==(const StringBuilder& a, const String& b) { return equal(a, b); }
-inline bool operator!=(const StringBuilder& a, const String& b) { return !equal(a, b); }
-inline bool operator==(const String& a, const StringBuilder& b) { return equal(b, a); }
-inline bool operator!=(const String& a, const StringBuilder& b) { return !equal(b, a); }
+inline bool operator==(const StringBuilder& a, const StringBuilder& b) {
+  return equal(a, b);
+}
+inline bool operator!=(const StringBuilder& a, const StringBuilder& b) {
+  return !equal(a, b);
+}
+inline bool operator==(const StringBuilder& a, const String& b) {
+  return equal(a, b);
+}
+inline bool operator!=(const StringBuilder& a, const String& b) {
+  return !equal(a, b);
+}
+inline bool operator==(const String& a, const StringBuilder& b) {
+  return equal(b, a);
+}
+inline bool operator!=(const String& a, const StringBuilder& b) {
+  return !equal(b, a);
+}
 
-} // namespace WTF
+}  // namespace WTF
 
 using WTF::StringBuilder;
 
-#endif // StringBuilder_h
+#endif  // StringBuilder_h