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

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

 /*
  * Copyright (C) 2004, 2006, 2008, 2011 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 13 matching lines @@
  */
 
 #include "config.h"
 #include "wtf/text/TextCodecUTF8.h"
 
 #include "wtf/text/CString.h"
 #include "wtf/text/CharacterNames.h"
 #include "wtf/text/StringBuffer.h"
 #include "wtf/text/TextCodecASCIIFastPath.h"
 
-using namespace WTF;
+namespace WTF {
+
 using namespace WTF::Unicode;
-using namespace std;
-
-namespace WTF {
 
 const int nonCharacter = -1;
 
 PassOwnPtr<TextCodec> TextCodecUTF8::create(const TextEncoding&, const void*)
 {
     return adoptPtr(new TextCodecUTF8);
 }
 
 void TextCodecUTF8::registerEncodingNames(EncodingNameRegistrar registrar)
 {
@@ skipping 90 matching lines @@
         return nonCharacter;
     if (sequence[3] < 0x80 || sequence[3] > 0xBF)
         return nonCharacter;
     return ((sequence[0] << 18) + (sequence[1] << 12) + (sequence[2] << 6) + sequence[3]) - 0x03C82080;
 }
 
 static inline UChar* appendCharacter(UChar* destination, int character)
 {
     ASSERT(character != nonCharacter);
     ASSERT(!U_IS_SURROGATE(character));
-    if (U_IS_BMP(character))
+    if (U_IS_BMP(character)) {
         *destination++ = static_cast<UChar>(character);
-    else {
+    } else {
         *destination++ = U16_LEAD(character);
         *destination++ = U16_TRAIL(character);
     }
     return destination;
 }
 
 void TextCodecUTF8::consumePartialSequenceByte()
 {
     --m_partialSequenceSize;
     memmove(m_partialSequence, m_partialSequence + 1, m_partialSequenceSize);
@@ skipping 147 matching lines @@
                     if (source == end)
                         break;
                     if (!isASCII(*source))
                         continue;
                 }
                 *destination++ = *source++;
                 continue;
             }
             int count = nonASCIISequenceLength(*source);
             int character;
-            if (!count)
+            if (count == 0) {
                 character = nonCharacter;
-            else {
+            } else {
                 if (count > end - source) {
                     ASSERT_WITH_SECURITY_IMPLICATION(end - source < static_cast<ptrdiff_t>(sizeof(m_partialSequence)));
                     ASSERT(!m_partialSequenceSize);
                     m_partialSequenceSize = end - source;
                     memcpy(m_partialSequence, source, m_partialSequenceSize);
                     source = end;
                     break;
                 }
                 character = decodeNonASCIISequence(source, count);
             }
@@ skipping 54 matching lines @@
                     if (source == end)
                         break;
                     if (!isASCII(*source))
                         continue;
                 }
                 *destination16++ = *source++;
                 continue;
             }
             int count = nonASCIISequenceLength(*source);
             int character;
-            if (!count)
+            if (count == 0) {
                 character = nonCharacter;
-            else {
+            } else {
                 if (count > end - source) {
                     ASSERT_WITH_SECURITY_IMPLICATION(end - source < static_cast<ptrdiff_t>(sizeof(m_partialSequence)));
                     ASSERT(!m_partialSequenceSize);
                     m_partialSequenceSize = end - source;
                     memcpy(m_partialSequence, source, m_partialSequenceSize);
                     source = end;
                     break;
                 }
                 character = decodeNonASCIISequence(source, count);
             }
@@ skipping 15 matching lines @@
 
     return String::adopt(buffer16);
 }
 
 template<typename CharType>
 CString TextCodecUTF8::encodeCommon(const CharType* characters, size_t length)
 {
     // The maximum number of UTF-8 bytes needed per UTF-16 code unit is 3.
     // BMP characters take only one UTF-16 code unit and can take up to 3 bytes (3x).
     // Non-BMP characters take two UTF-16 code units and can take up to 4 bytes (2x).
-    if (length > numeric_limits<size_t>::max() / 3)
+    if (length > std::numeric_limits<size_t>::max() / 3)
         CRASH();
     Vector<uint8_t> bytes(length * 3);
 
     size_t i = 0;
     size_t bytesWritten = 0;
     while (i < length) {
         UChar32 character;
         U16_NEXT(characters, i, length, character);
         // U16_NEXT will simply emit a surrogate code point if an unmatched surrogate
         // is encountered; we must convert it to a U+FFFD (REPLACEMENT CHARACTER) here.
         if (0xD800 <= character && character <= 0xDFFF)
             character = replacementCharacter;
         U8_APPEND_UNSAFE(bytes.data(), bytesWritten, character);
     }
 
     return CString(reinterpret_cast<char*>(bytes.data()), bytesWritten);
 }
 
 CString TextCodecUTF8::encode(const UChar* characters, size_t length, UnencodableHandling)
 {
     return encodeCommon(characters, length);
 }
 
 CString TextCodecUTF8::encode(const LChar* characters, size_t length, UnencodableHandling)
 {
     return encodeCommon(characters, length);
 }
 
 } // namespace WTF