Fix check-webkit-style errors in Source/wtf/text/.

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

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 45 matching lines @@
 
 WTF_EXPORT int charactersToInt(const LChar*, size_t, bool* ok = 0); // ignores trailing garbage
 WTF_EXPORT int charactersToInt(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
 WTF_EXPORT unsigned charactersToUInt(const LChar*, size_t, bool* ok = 0); // ignores trailing garbage
 WTF_EXPORT unsigned charactersToUInt(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
 WTF_EXPORT int64_t charactersToInt64(const LChar*, size_t, bool* ok = 0); // ignores trailing garbage
 WTF_EXPORT int64_t charactersToInt64(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
 WTF_EXPORT uint64_t charactersToUInt64(const LChar*, size_t, bool* ok = 0); // ignores trailing garbage
 WTF_EXPORT uint64_t charactersToUInt64(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
 
-// FIXME: Like the strict functions above, these give false for "ok" when there is trailing garbage.
-// Like the non-strict functions above, these return the value when there is trailing garbage.
-// It would be better if these were more consistent with the above functions instead.
+// FIXME: Like the strict functions above, these give false for "ok" when there
+// is trailing garbage.  Like the non-strict functions above, these return the
+// value when there is trailing garbage.  It would be better if these were more
+// consistent with the above functions instead.
 WTF_EXPORT double charactersToDouble(const LChar*, size_t, bool* ok = 0);
 WTF_EXPORT double charactersToDouble(const UChar*, size_t, bool* ok = 0);
 WTF_EXPORT float charactersToFloat(const LChar*, size_t, bool* ok = 0);
 WTF_EXPORT float charactersToFloat(const UChar*, size_t, bool* ok = 0);
 WTF_EXPORT float charactersToFloat(const LChar*, size_t, size_t& parsedLength);
 WTF_EXPORT float charactersToFloat(const UChar*, size_t, size_t& parsedLength);
 
 enum TrailingZerosTruncatingPolicy {
     KeepTrailingZeros,
     TruncateTrailingZeros
@@ skipping 112 matching lines @@
     static String number(unsigned long);
     static String number(long long);
     static String number(unsigned long long);
 
     static String number(double, unsigned precision = 6, TrailingZerosTruncatingPolicy = TruncateTrailingZeros);
 
     // Number to String conversion following the ECMAScript definition.
     static String numberToStringECMAScript(double);
     static String numberToStringFixedWidth(double, unsigned decimalPlaces);
 
-    // Find a single character or string, also with match function & latin1 forms.
+    // Find a single character or string, also with match function & latin1
+    // forms.
     size_t find(UChar c, unsigned start = 0) const
         { return m_impl ? m_impl->find(c, start) : kNotFound; }
     size_t find(LChar c, unsigned start = 0) const
         { return m_impl ? m_impl->find(c, start) : kNotFound; }
     size_t find(char c, unsigned start = 0) const { return find(static_cast<LChar>(c), start); }
 
     size_t find(const String& str) const
         { return m_impl ? m_impl->find(str.impl()) : kNotFound; }
     size_t find(const String& str, unsigned start) const
         { return m_impl ? m_impl->find(str.impl(), start) : kNotFound; }
@@ skipping 66 matching lines @@
     void append(LChar);
     void append(char c) { append(static_cast<LChar>(c)); }
     void append(UChar);
     void append(const LChar*, unsigned length);
     void append(const char* charactersToAppend, unsigned length) { append(reinterpret_cast<const LChar*>(charactersToAppend), length); }
     void append(const UChar*, unsigned length);
     void insert(const String&, unsigned pos);
     void insert(const LChar*, unsigned length, unsigned pos);
     void insert(const UChar*, unsigned length, unsigned pos);
 
-    String& replace(UChar a, UChar b) { if (m_impl) m_impl = m_impl->replace(a, b); return *this; }
-    String& replace(UChar a, const String& b) { if (m_impl) m_impl = m_impl->replace(a, b.impl()); return *this; }
-    String& replace(const String& a, const String& b) { if (m_impl) m_impl = m_impl->replace(a.impl(), b.impl()); return *this; }
-    String& replace(unsigned index, unsigned len, const String& b) { if (m_impl) m_impl = m_impl->replace(index, len, b.impl()); return *this; }
+    String& replace(UChar a, UChar b)
+    {
+        if (m_impl)
+            m_impl = m_impl->replace(a, b);
+        return *this;
+    }
+    String& replace(UChar a, const String& b)
+    {
+        if (m_impl)
+            m_impl = m_impl->replace(a, b.impl());
+        return *this;
+    }
+    String& replace(const String& a, const String& b)
+    {
+        if (m_impl)
+            m_impl = m_impl->replace(a.impl(), b.impl());
+        return *this;
+    }
+    String& replace(unsigned index, unsigned len, const String& b)
+    {
+        if (m_impl)
+            m_impl = m_impl->replace(index, len, b.impl());
+        return *this;
+    }
 
     template<unsigned charactersCount>
     ALWAYS_INLINE String& replaceWithLiteral(UChar a, const char (&characters)[charactersCount])
     {
         if (m_impl)
             m_impl = m_impl->replace(a, characters, charactersCount - 1);
 
         return *this;
     }
 
-    void fill(UChar c) { if (m_impl) m_impl = m_impl->fill(c); }
+    void fill(UChar c)
+    {
+        if (m_impl)
+            m_impl = m_impl->fill(c);
+    }
 
     void ensure16Bit();
 
     void truncate(unsigned len);
     void remove(unsigned pos, int len = 1);
 
     String substring(unsigned pos, unsigned len = UINT_MAX) const;
     String left(unsigned len) const { return substring(0, len); }
     String right(unsigned len) const { return substring(length() - len, len); }
 
     StringView createView() const { return StringView(impl()); }
     StringView createView(unsigned offset, unsigned length) const { return StringView(impl(), offset, length); }
 
     // Returns a lowercase/uppercase version of the string
     String lower() const;
     String upper() const;
 
     String lower(const AtomicString& localeIdentifier) const;
     String upper(const AtomicString& localeIdentifier) const;
 
     String stripWhiteSpace() const;
     String stripWhiteSpace(IsWhiteSpaceFunctionPtr) const;
-    String simplifyWhiteSpace(StripBehavior stripBehavior = StripExtraWhiteSpace) const;
-    String simplifyWhiteSpace(IsWhiteSpaceFunctionPtr, StripBehavior stripBehavior = StripExtraWhiteSpace) const;
+    String simplifyWhiteSpace(StripBehavior = StripExtraWhiteSpace) const;
+    String simplifyWhiteSpace(IsWhiteSpaceFunctionPtr, StripBehavior = StripExtraWhiteSpace) const;
 
     String removeCharacters(CharacterMatchFunctionPtr) const;
     template<bool isSpecialCharacter(UChar)> bool isAllSpecialCharacters() const;
 
     // Return the string with case folded for case insensitive comparison.
     String foldCase() const;
 
     static String format(const char *, ...) WTF_ATTRIBUTE_PRINTF(1, 2);
 
     // Returns an uninitialized string. The characters needs to be written
@@ skipping 16 matching lines @@
     int toIntStrict(bool* ok = 0, int base = 10) const;
     unsigned toUIntStrict(bool* ok = 0, int base = 10) const;
     int64_t toInt64Strict(bool* ok = 0, int base = 10) const;
     uint64_t toUInt64Strict(bool* ok = 0, int base = 10) const;
 
     int toInt(bool* ok = 0) const;
     unsigned toUInt(bool* ok = 0) const;
     int64_t toInt64(bool* ok = 0) const;
     uint64_t toUInt64(bool* ok = 0) const;
 
-    // FIXME: Like the strict functions above, these give false for "ok" when there is trailing garbage.
-    // Like the non-strict functions above, these return the value when there is trailing garbage.
-    // It would be better if these were more consistent with the above functions instead.
+    // FIXME: Like the strict functions above, these give false for "ok" when
+    // there is trailing garbage.  Like the non-strict functions above, these
+    // return the value when there is trailing garbage.  It would be better if
+    // these were more consistent with the above functions instead.
     double toDouble(bool* ok = 0) const;
     float toFloat(bool* ok = 0) const;
 
     String isolatedCopy() const;
     bool isSafeToSendToAnotherThread() const;
 
 #if USE(CF)
     String(CFStringRef);
     RetainPtr<CFStringRef> createCFString() const;
 #endif
 
 #ifdef __OBJC__
     String(NSString*);
 
-    // This conversion maps NULL to "", which loses the meaning of NULL, but we
-    // need this mapping because AppKit crashes when passed nil NSStrings.
-    operator NSString*() const { if (!m_impl) return @""; return *m_impl; }
+    // This conversion maps null string to "", which loses the meaning of null
+    // string, but we need this mapping because AppKit crashes when passed nil
+    // NSStrings.
+    operator NSString*() const
+    {
+        if (!m_impl)
+            return @"";
+        return *m_impl;
+    }
 #endif
 
     static String make8BitFrom16BitSource(const UChar*, size_t);
     template<size_t inlineCapacity>
     static String make8BitFrom16BitSource(const Vector<UChar, inlineCapacity>& buffer)
     {
         return make8BitFrom16BitSource(buffer.data(), buffer.size());
     }
 
     static String make16BitFrom8BitSource(const LChar*, size_t);
 
     // String::fromUTF8 will return a null string if
     // the input data contains invalid UTF-8 sequences.
     static String fromUTF8(const LChar*, size_t);
     static String fromUTF8(const LChar*);
     static String fromUTF8(const char* s, size_t length) { return fromUTF8(reinterpret_cast<const LChar*>(s), length); }
     static String fromUTF8(const char* s) { return fromUTF8(reinterpret_cast<const LChar*>(s)); }
     static String fromUTF8(const CString&);
 
-    // Tries to convert the passed in string to UTF-8, but will fall back to Latin-1 if the string is not valid UTF-8.
+    // Tries to convert the passed in string to UTF-8, but will fall back to
+    // Latin-1 if the string is not valid UTF-8.
     static String fromUTF8WithLatin1Fallback(const LChar*, size_t);
     static String fromUTF8WithLatin1Fallback(const char* s, size_t length) { return fromUTF8WithLatin1Fallback(reinterpret_cast<const LChar*>(s), length); }
 
     bool containsOnlyASCII() const;
     bool containsOnlyLatin1() const;
     bool containsOnlyWhitespace() const { return !m_impl || m_impl->containsOnlyWhitespace(); }
 
-    // Hash table deleted values, which are only constructed and never copied or destroyed.
+    // Hash table deleted values, which are only constructed and never copied or
+    // destroyed.
     String(WTF::HashTableDeletedValueType) : m_impl(WTF::HashTableDeletedValue) { }
     bool isHashTableDeletedValue() const { return m_impl.isHashTableDeletedValue(); }
 
 #ifndef NDEBUG
     void show() const;
 #endif
 
     // Workaround for a compiler bug. Use operator[] instead.
     UChar characterAt(unsigned index) const
     {
@@ skipping 242 matching lines @@
 using WTF::charactersToFloat;
 using WTF::equal;
 using WTF::equalIgnoringCase;
 using WTF::find;
 using WTF::isAllSpecialCharacters;
 using WTF::isSpaceOrNewline;
 using WTF::reverseFind;
 
 #include "wtf/text/AtomicString.h"
 #endif // WTFString_h