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

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

 /*
  * Copyright (C) 2004, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov <ap@nypop.com>
  *
  * 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
@@ skipping 19 matching lines @@
 #include "wtf/Assertions.h"
 #include "wtf/StringExtras.h"
 #include "wtf/Threading.h"
 #include "wtf/WTFThreadData.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/CharacterNames.h"
 #include "wtf/text/StringBuilder.h"
 #include <unicode/ucnv.h>
 #include <unicode/ucnv_cb.h>
 
-using std::min;
-
 namespace WTF {
 
 const size_t ConversionBufferSize = 16384;
 
 ICUConverterWrapper::~ICUConverterWrapper()
 {
     if (converter)
         ucnv_close(converter);
 }
 
@@ skipping 258 matching lines @@
 
 class ErrorCallbackSetter {
 public:
     ErrorCallbackSetter(UConverter* converter, bool stopOnError)
         : m_converter(converter)
         , m_shouldStopOnEncodingErrors(stopOnError)
     {
         if (m_shouldStopOnEncodingErrors) {
             UErrorCode err = U_ZERO_ERROR;
             ucnv_setToUCallBack(m_converter, UCNV_TO_U_CALLBACK_SUBSTITUTE,
-                           UCNV_SUB_STOP_ON_ILLEGAL, &m_savedAction,
-                           &m_savedContext, &err);
+                UCNV_SUB_STOP_ON_ILLEGAL, &m_savedAction,
+                &m_savedContext, &err);
             ASSERT(err == U_ZERO_ERROR);
         }
     }
     ~ErrorCallbackSetter()
     {
         if (m_shouldStopOnEncodingErrors) {
             UErrorCode err = U_ZERO_ERROR;
             const void* oldContext;
             UConverterToUCallback oldAction;
-            ucnv_setToUCallBack(m_converter, m_savedAction,
-                   m_savedContext, &oldAction,
-                   &oldContext, &err);
+            ucnv_setToUCallBack(m_converter, m_savedAction, m_savedContext, &oldAction, &oldContext, &err);
             ASSERT(oldAction == UCNV_TO_U_CALLBACK_SUBSTITUTE);
             ASSERT(!strcmp(static_cast<const char*>(oldContext), UCNV_SUB_STOP_ON_ILLEGAL));
             ASSERT(err == U_ZERO_ERROR);
         }
     }
 
 private:
     UConverter* m_converter;
     bool m_shouldStopOnEncodingErrors;
     const void* m_savedContext;
@@ skipping 13 matching lines @@
     }
 
     ErrorCallbackSetter callbackSetter(m_converterICU, stopOnError);
 
     StringBuilder result;
 
     UChar buffer[ConversionBufferSize];
     UChar* bufferLimit = buffer + ConversionBufferSize;
     const char* source = reinterpret_cast<const char*>(bytes);
     const char* sourceLimit = source + length;
-    int32_t* offsets = NULL;
+    int32_t* offsets = nullptr;
     UErrorCode err = U_ZERO_ERROR;
 
     do {
         int ucharsDecoded = decodeToBuffer(buffer, bufferLimit, source, sourceLimit, offsets, flush != DoNotFlush, err);
         result.append(buffer, ucharsDecoded);
     } while (err == U_BUFFER_OVERFLOW_ERROR);
 
     if (U_FAILURE(err)) {
         // flush the converter so it can be reused, and not be bothered by this error.
         do {
@@ skipping 42 matching lines @@
 // characters. See the declaration of TextCodec::encode for more.
 static void urlEscapedEntityCallback(const void* context, UConverterFromUnicodeArgs* fromUArgs, const UChar* codeUnits, int32_t length,
     UChar32 codePoint, UConverterCallbackReason reason, UErrorCode* err)
 {
     if (reason == UCNV_UNASSIGNED) {
         *err = U_ZERO_ERROR;
 
         UnencodableReplacementArray entity;
         int entityLen = TextCodec::getUnencodableReplacement(codePoint, URLEncodedEntitiesForUnencodables, entity);
         ucnv_cbFromUWriteBytes(fromUArgs, entity, entityLen, 0, err);
-    } else
+    } else {
         UCNV_FROM_U_CALLBACK_ESCAPE(context, fromUArgs, codeUnits, length, codePoint, reason, err);
+    }
 }
 
 #if defined(USING_SYSTEM_ICU)
 // Substitutes special GBK characters, escaping all other unassigned entities.
 static void gbkCallbackEscape(const void* context, UConverterFromUnicodeArgs* fromUArgs, const UChar* codeUnits, int32_t length,
     UChar32 codePoint, UConverterCallbackReason reason, UErrorCode* err)
 {
     UChar outChar;
     if (reason == UCNV_UNASSIGNED && (outChar = fallbackForGBK(codePoint))) {
         const UChar* source = &outChar;
@@ skipping 61 matching lines @@
 };
 
 CString TextCodecICU::encodeInternal(const TextCodecInput& input, UnencodableHandling handling)
 {
     const UChar* source = input.begin();
     const UChar* end = input.end();
 
     UErrorCode err = U_ZERO_ERROR;
 
     switch (handling) {
-        case QuestionMarksForUnencodables:
-            ucnv_setSubstChars(m_converterICU, "?", 1, &err);
+    case QuestionMarksForUnencodables:
+        ucnv_setSubstChars(m_converterICU, "?", 1, &err);
 #if !defined(USING_SYSTEM_ICU)
-            ucnv_setFromUCallBack(m_converterICU, UCNV_FROM_U_CALLBACK_SUBSTITUTE, 0, 0, 0, &err);
+        ucnv_setFromUCallBack(m_converterICU, UCNV_FROM_U_CALLBACK_SUBSTITUTE, 0, 0, 0, &err);
 #else
-            ucnv_setFromUCallBack(m_converterICU, m_needsGBKFallbacks ? gbkCallbackSubstitute : UCNV_FROM_U_CALLBACK_SUBSTITUTE, 0, 0, 0, &err);
+        ucnv_setFromUCallBack(m_converterICU, m_needsGBKFallbacks ? gbkCallbackSubstitute : UCNV_FROM_U_CALLBACK_SUBSTITUTE, 0, 0, 0, &err);
 #endif
-            break;
-        case EntitiesForUnencodables:
+        break;
+    case EntitiesForUnencodables:
 #if !defined(USING_SYSTEM_ICU)
-            ucnv_setFromUCallBack(m_converterICU, UCNV_FROM_U_CALLBACK_ESCAPE, UCNV_ESCAPE_XML_DEC, 0, 0, &err);
+        ucnv_setFromUCallBack(m_converterICU, UCNV_FROM_U_CALLBACK_ESCAPE, UCNV_ESCAPE_XML_DEC, 0, 0, &err);
 #else
-            ucnv_setFromUCallBack(m_converterICU, m_needsGBKFallbacks ? gbkCallbackEscape : UCNV_FROM_U_CALLBACK_ESCAPE, UCNV_ESCAPE_XML_DEC, 0, 0, &err);
+        ucnv_setFromUCallBack(m_converterICU, m_needsGBKFallbacks ? gbkCallbackEscape : UCNV_FROM_U_CALLBACK_ESCAPE, UCNV_ESCAPE_XML_DEC, 0, 0, &err);
 #endif
-            break;
-        case URLEncodedEntitiesForUnencodables:
+        break;
+    case URLEncodedEntitiesForUnencodables:
 #if !defined(USING_SYSTEM_ICU)
-            ucnv_setFromUCallBack(m_converterICU, urlEscapedEntityCallback, 0, 0, 0, &err);
+        ucnv_setFromUCallBack(m_converterICU, urlEscapedEntityCallback, 0, 0, 0, &err);
 #else
-            ucnv_setFromUCallBack(m_converterICU, m_needsGBKFallbacks ? gbkUrlEscapedEntityCallack : urlEscapedEntityCallback, 0, 0, 0, &err);
+        ucnv_setFromUCallBack(m_converterICU, m_needsGBKFallbacks ? gbkUrlEscapedEntityCallack : urlEscapedEntityCallback, 0, 0, 0, &err);
 #endif
-            break;
+        break;
     }
 
     ASSERT(U_SUCCESS(err));
     if (U_FAILURE(err))
         return CString();
 
     Vector<char> result;
     size_t size = 0;
     do {
         char buffer[ConversionBufferSize];
@@ skipping 29 matching lines @@
 {
     return encodeCommon(characters, length, handling);
 }
 
 CString TextCodecICU::encode(const LChar* characters, size_t length, UnencodableHandling handling)
 {
     return encodeCommon(characters, length, handling);
 }
 
 } // namespace WTF