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

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

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007-2009 Torch Mobile, Inc.
  *
  * 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.
  *
@@ skipping 18 matching lines @@
 #include "wtf/MathExtras.h"
 #include "wtf/StringExtras.h"
 #include "wtf/Vector.h"
 #include "wtf/dtoa.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/CharacterNames.h"
 #include "wtf/text/UTF8.h"
 #include "wtf/text/Unicode.h"
 #include <stdarg.h>
 
-using namespace std;
-
 namespace WTF {
 
 using namespace Unicode;
-using namespace std;
 
 // Construct a string with UTF-16 data.
 String::String(const UChar* characters, unsigned length)
     : m_impl(characters ? StringImpl::create(characters, length) : nullptr)
 {
 }
 
 // Construct a string with UTF-16 data, from a null-terminated source.
 String::String(const UChar* str)
 {
@@ skipping 26 matching lines @@
 
 void String::append(const String& string)
 {
     if (string.isEmpty())
         return;
     if (!m_impl) {
         m_impl = string.m_impl;
         return;
     }
 
-    // FIXME: This is extremely inefficient. So much so that we might want to take this
-    // out of String's API. We can make it better by optimizing the case where exactly
-    // one String is pointing at this StringImpl, but even then it's going to require a
-    // call into the allocator every single time.
+    // FIXME: This is extremely inefficient. So much so that we might want to
+    // take this out of String's API. We can make it better by optimizing the
+    // case where exactly one String is pointing at this StringImpl, but even
+    // then it's going to require a call into the allocator every single time.
 
     if (m_impl->is8Bit() && string.m_impl->is8Bit()) {
         LChar* data;
-        RELEASE_ASSERT(string.length() <= numeric_limits<unsigned>::max() - m_impl->length());
+        RELEASE_ASSERT(string.length() <= std::numeric_limits<unsigned>::max() - m_impl->length());
         RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(m_impl->length() + string.length(), data);
         memcpy(data, m_impl->characters8(), m_impl->length() * sizeof(LChar));
         memcpy(data + m_impl->length(), string.characters8(), string.length() * sizeof(LChar));
         m_impl = newImpl.release();
         return;
     }
 
     UChar* data;
-    RELEASE_ASSERT(string.length() <= numeric_limits<unsigned>::max() - m_impl->length());
+    RELEASE_ASSERT(string.length() <= std::numeric_limits<unsigned>::max() - m_impl->length());
     RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(m_impl->length() + string.length(), data);
 
     if (m_impl->is8Bit())
         StringImpl::copyChars(data, m_impl->characters8(), m_impl->length());
     else
         StringImpl::copyChars(data, m_impl->characters16(), m_impl->length());
 
     if (string.impl()->is8Bit())
         StringImpl::copyChars(data + m_impl->length(), string.impl()->characters8(), string.impl()->length());
     else
         StringImpl::copyChars(data + m_impl->length(), string.impl()->characters16(), string.impl()->length());
 
     m_impl = newImpl.release();
 }
 
 template <typename CharacterType>
 inline void String::appendInternal(CharacterType c)
 {
-    // FIXME: This is extremely inefficient. So much so that we might want to take this
-    // out of String's API. We can make it better by optimizing the case where exactly
-    // one String is pointing at this StringImpl, but even then it's going to require a
-    // call into the allocator every single time.
+    // FIXME: This is extremely inefficient. So much so that we might want to
+    // take this out of String's API. We can make it better by optimizing the
+    // case where exactly one String is pointing at this StringImpl, but even
+    // then it's going to require a call into the allocator every single time.
     if (!m_impl) {
         m_impl = StringImpl::create(&c, 1);
         return;
     }
 
-    UChar* data; // FIXME: We should be able to create an 8 bit string via this code path.
-    RELEASE_ASSERT(m_impl->length() < numeric_limits<unsigned>::max());
+    // FIXME: We should be able to create an 8 bit string via this code path.
+    UChar* data;
+    RELEASE_ASSERT(m_impl->length() < std::numeric_limits<unsigned>::max());
     RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(m_impl->length() + 1, data);
     if (m_impl->is8Bit())
         StringImpl::copyChars(data, m_impl->characters8(), m_impl->length());
     else
         StringImpl::copyChars(data, m_impl->characters16(), m_impl->length());
     data[m_impl->length()] = c;
     m_impl = newImpl.release();
 }
 
 void String::append(LChar c)
@@ skipping 37 matching lines @@
     }
 
     if (!lengthToAppend)
         return;
 
     ASSERT(charactersToAppend);
 
     unsigned strLength = m_impl->length();
 
     if (m_impl->is8Bit()) {
-        RELEASE_ASSERT(lengthToAppend <= numeric_limits<unsigned>::max() - strLength);
+        RELEASE_ASSERT(lengthToAppend <= std::numeric_limits<unsigned>::max() - strLength);
         LChar* data;
         RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(strLength + lengthToAppend, data);
         StringImpl::copyChars(data, m_impl->characters8(), strLength);
         StringImpl::copyChars(data + strLength, charactersToAppend, lengthToAppend);
         m_impl = newImpl.release();
         return;
     }
 
-    RELEASE_ASSERT(lengthToAppend <= numeric_limits<unsigned>::max() - strLength);
+    RELEASE_ASSERT(lengthToAppend <= std::numeric_limits<unsigned>::max() - strLength);
     UChar* data;
     RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(length() + lengthToAppend, data);
     StringImpl::copyChars(data, m_impl->characters16(), strLength);
     StringImpl::copyChars(data + strLength, charactersToAppend, lengthToAppend);
     m_impl = newImpl.release();
 }
 
 void String::append(const UChar* charactersToAppend, unsigned lengthToAppend)
 {
     if (!m_impl) {
         if (!charactersToAppend)
             return;
         m_impl = StringImpl::create(charactersToAppend, lengthToAppend);
         return;
     }
 
     if (!lengthToAppend)
         return;
 
     unsigned strLength = m_impl->length();
 
     ASSERT(charactersToAppend);
-    RELEASE_ASSERT(lengthToAppend <= numeric_limits<unsigned>::max() - strLength);
+    RELEASE_ASSERT(lengthToAppend <= std::numeric_limits<unsigned>::max() - strLength);
     UChar* data;
     RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(strLength + lengthToAppend, data);
     if (m_impl->is8Bit())
         StringImpl::copyChars(data, characters8(), strLength);
     else
         StringImpl::copyChars(data, characters16(), strLength);
     StringImpl::copyChars(data + strLength, charactersToAppend, lengthToAppend);
     m_impl = newImpl.release();
 }
 
 template<typename CharType>
 PassRefPtr<StringImpl> insertInternal(PassRefPtr<StringImpl> impl, const CharType* charactersToInsert, unsigned lengthToInsert, unsigned position)
 {
     if (!lengthToInsert)
         return impl;
 
     ASSERT(charactersToInsert);
     UChar* data; // FIXME: We should be able to create an 8 bit string here.
-    RELEASE_ASSERT(lengthToInsert <= numeric_limits<unsigned>::max() - impl->length());
+    RELEASE_ASSERT(lengthToInsert <= std::numeric_limits<unsigned>::max() - impl->length());
     RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(impl->length() + lengthToInsert, data);
 
     if (impl->is8Bit())
         StringImpl::copyChars(data, impl->characters8(), position);
     else
         StringImpl::copyChars(data, impl->characters16(), position);
 
     StringImpl::copyChars(data + position, charactersToInsert, lengthToInsert);
 
     if (impl->is8Bit())
@@ skipping 510 matching lines @@
     // Allocate a buffer big enough to hold all the characters
     // (an individual UTF-16 UChar can only expand to 3 UTF-8 bytes).
     // Optimization ideas, if we find this function is hot:
     //  * We could speculatively create a CStringBuffer to contain 'length'
     //    characters, and resize if necessary (i.e. if the buffer contains
     //    non-ascii characters). (Alternatively, scan the buffer first for
     //    ascii characters, so we know this will be sufficient).
     //  * We could allocate a CStringBuffer with an appropriate size to
     //    have a good chance of being able to write the string into the
     //    buffer without reallocing (say, 1.5 x length).
-    if (length > numeric_limits<unsigned>::max() / 3)
+    if (length > std::numeric_limits<unsigned>::max() / 3)
         return CString();
     Vector<char, 1024> bufferVector(length * 3);
 
     char* buffer = bufferVector.data();
 
     if (is8Bit()) {
         const LChar* characters = this->characters8();
 
         ConversionResult result = convertLatin1ToUTF8(&characters, characters + length, &buffer, buffer + bufferVector.size());
         ASSERT_UNUSED(result, result != targetExhausted); // (length * 3) should be sufficient for any conversion
     } else {
         const UChar* characters = this->characters16();
 
         if (mode == StrictUTF8ConversionReplacingUnpairedSurrogatesWithFFFD) {
             const UChar* charactersEnd = characters + length;
             char* bufferEnd = buffer + bufferVector.size();
             while (characters < charactersEnd) {
                 // Use strict conversion to detect unpaired surrogates.
                 ConversionResult result = convertUTF16ToUTF8(&characters, charactersEnd, &buffer, bufferEnd, true);
                 ASSERT(result != targetExhausted);
-                // Conversion fails when there is an unpaired surrogate.
-                // Put replacement character (U+FFFD) instead of the unpaired surrogate.
+                // Conversion fails when there is an unpaired surrogate.  Put
+                // replacement character (U+FFFD) instead of the unpaired
+                // surrogate.
                 if (result != conversionOK) {
                     ASSERT((0xD800 <= *characters && *characters <= 0xDFFF));
-                    // There should be room left, since one UChar hasn't been converted.
+                    // There should be room left, since one UChar hasn't been
+                    // converted.
                     ASSERT((buffer + 3) <= bufferEnd);
                     putUTF8Triple(buffer, replacementCharacter);
                     ++characters;
                 }
             }
         } else {
             bool strict = mode == StrictUTF8Conversion;
             ConversionResult result = convertUTF16ToUTF8(&characters, characters + length, &buffer, buffer + bufferVector.size(), strict);
             ASSERT(result != targetExhausted); // (length * 3) should be sufficient for any conversion
 
             // Only produced from strict conversion.
             if (result == sourceIllegal) {
                 ASSERT(strict);
                 return CString();
             }
 
             // Check for an unconverted high surrogate.
             if (result == sourceExhausted) {
                 if (strict)
                     return CString();
                 // This should be one unpaired high surrogate. Treat it the same
                 // was as an unpaired high surrogate would have been handled in
                 // the middle of a string with non-strict conversion - which is
                 // to say, simply encode it to UTF-8.
                 ASSERT((characters + 1) == (this->characters16() + length));
                 ASSERT((*characters >= 0xD800) && (*characters <= 0xDBFF));
-                // There should be room left, since one UChar hasn't been converted.
+                // There should be room left, since one UChar hasn't been
+                // converted.
                 ASSERT((buffer + 3) <= (buffer + bufferVector.size()));
                 putUTF8Triple(buffer, *characters);
             }
         }
     }
 
     return CString(bufferVector.data(), buffer - bufferVector.data());
 }
 
 String String::make8BitFrom16BitSource(const UChar* source, size_t length)
@@ skipping 17 matching lines @@
     UChar* destination;
     String result = String::createUninitialized(length, destination);
 
     StringImpl::copyChars(destination, source, length);
 
     return result;
 }
 
 String String::fromUTF8(const LChar* stringStart, size_t length)
 {
-    RELEASE_ASSERT(length <= numeric_limits<unsigned>::max());
+    RELEASE_ASSERT(length <= std::numeric_limits<unsigned>::max());
 
     if (!stringStart)
         return String();
 
     if (!length)
         return emptyString();
 
     if (charactersAreAllASCII(stringStart, length))
         return StringImpl::create(stringStart, length);
 
@@ skipping 43 matching lines @@
             base = 36;
         return (c >= 'a' && c < 'a' + base - 10)
             || (c >= 'A' && c < 'A' + base - 10);
     }
     return false;
 }
 
 template <typename IntegralType, typename CharType>
 static inline IntegralType toIntegralType(const CharType* data, size_t length, bool* ok, int base)
 {
-    static const IntegralType integralMax = numeric_limits<IntegralType>::max();
-    static const bool isSigned = numeric_limits<IntegralType>::is_signed;
+    static const IntegralType integralMax = std::numeric_limits<IntegralType>::max();
+    static const bool isSigned = std::numeric_limits<IntegralType>::is_signed;
     const IntegralType maxMultiplier = integralMax / base;
 
     IntegralType value = 0;
     bool isOk = false;
     bool isNegative = false;
 
     if (!data)
         goto bye;
 
     // skip leading whitespace
@@ skipping 191 matching lines @@
 }
 
 double charactersToDouble(const UChar* data, size_t length, bool* ok)
 {
     size_t parsedLength;
     return toDoubleType<UChar, DisallowTrailingJunk>(data, length, ok, parsedLength);
 }
 
 float charactersToFloat(const LChar* data, size_t length, bool* ok)
 {
-    // FIXME: This will return ok even when the string fits into a double but not a float.
+    // FIXME: This will return ok even when the string fits into a double but
+    // not a float.
     size_t parsedLength;
     return static_cast<float>(toDoubleType<LChar, DisallowTrailingJunk>(data, length, ok, parsedLength));
 }
 
 float charactersToFloat(const UChar* data, size_t length, bool* ok)
 {
-    // FIXME: This will return ok even when the string fits into a double but not a float.
+    // FIXME: This will return ok even when the string fits into a double but
+    // not a float.
     size_t parsedLength;
     return static_cast<float>(toDoubleType<UChar, DisallowTrailingJunk>(data, length, ok, parsedLength));
 }
 
 float charactersToFloat(const LChar* data, size_t length, size_t& parsedLength)
 {
-    // FIXME: This will return ok even when the string fits into a double but not a float.
+    // FIXME: This will return ok even when the string fits into a double but
+    // not a float.
     return static_cast<float>(toDoubleType<LChar, AllowTrailingJunk>(data, length, 0, parsedLength));
 }
 
 float charactersToFloat(const UChar* data, size_t length, size_t& parsedLength)
 {
-    // FIXME: This will return ok even when the string fits into a double but not a float.
+    // FIXME: This will return ok even when the string fits into a double but
+    // not a float.
     return static_cast<float>(toDoubleType<UChar, AllowTrailingJunk>(data, length, 0, parsedLength));
 }
 
 const String& emptyString()
 {
     DEFINE_STATIC_LOCAL(String, emptyString, (StringImpl::empty()));
     return emptyString;
 }
 
 const String& emptyString16Bit()
 {
     DEFINE_STATIC_LOCAL(String, emptyString, (StringImpl::empty16Bit()));
     return emptyString;
 }
 
 } // namespace WTF
 
 #ifndef NDEBUG
 // For use in the debugger
 String* string(const char*);
-Vector<char> asciiDebug(StringImpl* impl);
-Vector<char> asciiDebug(String& string);
+Vector<char> asciiDebug(StringImpl*);
+Vector<char> asciiDebug(String&);
 
 void String::show() const
 {
     dataLogF("%s\n", asciiDebug(impl()).data());
 }
 
 String* string(const char* s)
 {
     // leaks memory!
     return new String(s);
@@ skipping 20 matching lines @@
     buffer.append('\0');
     return buffer;
 }
 
 Vector<char> asciiDebug(String& string)
 {
     return asciiDebug(string.impl());
 }
 
 #endif