Attempt to move USING_SYSTEM_ICU version of TextCodecICU to new blink style.

third_party/WebKit/Source/platform/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 229 matching lines @@
       error = U_ZERO_ERROR;
       standard_name = ucnv_getStandardName(name, "IANA", &error);
       if (!U_SUCCESS(error) || !standard_name)
         continue;
     }
     registrar(standard_name, Create, 0);
   }
 }
 
 TextCodecICU::TextCodecICU(const TextEncoding& encoding)
-    : encoding_(encoding),
-      converter_icu_(0)
-#if defined(USING_SYSTEM_ICU)
-      ,
-      m_needsGBKFallbacks(false)
-#endif
-{
-}
+    : encoding_(encoding) {}
 
 TextCodecICU::~TextCodecICU() {
   ReleaseICUConverter();
 }
 
 void TextCodecICU::ReleaseICUConverter() const {
   if (converter_icu_) {
     UConverter*& cached_converter = CachedConverterICU();
     if (cached_converter)
       ucnv_close(cached_converter);
     cached_converter = converter_icu_;
-    converter_icu_ = 0;
+    converter_icu_ = nullptr;
   }
 }
 
 void TextCodecICU::CreateICUConverter() const {
   DCHECK(!converter_icu_);
 
 #if defined(USING_SYSTEM_ICU)
   const char* name = encoding_.GetName();
-  m_needsGBKFallbacks =
+  needs_gbk_fallbacks_ =
       name[0] == 'G' && name[1] == 'B' && name[2] == 'K' && !name[3];
 #endif
 
   UErrorCode err;
 
   UConverter*& cached_converter = CachedConverterICU();
   if (cached_converter) {
     err = U_ZERO_ERROR;
     const char* cached_name = ucnv_getName(cached_converter, &err);
     if (U_SUCCESS(err) && encoding_ == cached_name) {
@@ skipping 120 matching lines @@
     // is resolved, add U+1E3F => 0xE7C7.
   }
 
   return resultString;
 #endif
 }
 
 #if defined(USING_SYSTEM_ICU)
 // U+01F9 and U+1E3F have to be mapped to xA8xBF and xA8xBC per the encoding
 // spec, but ICU converter does not have them.
-static UChar fallbackForGBK(UChar32 character) {
+static UChar FallbackForGBK(UChar32 character) {
   switch (character) {
     case 0x01F9:
       return 0xE7C8;  // mapped to xA8xBF by ICU.
     case 0x1E3F:
       return 0xE7C7;  // mapped to xA8xBC by ICU.
   }
   return 0;
 }
 #endif
 
@@ skipping 57 matching lines @@
                                      UChar32 code_point,
                                      UConverterCallbackReason reason,
                                      UErrorCode* err) {
   FormatEscapedEntityCallback(context, from_u_args, code_units, length,
                               code_point, reason, err,
                               kURLEncodedEntitiesForUnencodables);
 }
 
 #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,
+static void GbkCallbackEscape(const void* context,
+                              UConverterFromUnicodeArgs* from_unicode_args,
+                              const UChar* code_units,
                               int32_t length,
-                              UChar32 codePoint,
+                              UChar32 code_point,
                               UConverterCallbackReason reason,
                               UErrorCode* err) {
-  UChar outChar;
-  if (reason == UCNV_UNASSIGNED && (outChar = fallbackForGBK(codePoint))) {
-    const UChar* source = &outChar;
+  UChar out_char;
+  if (reason == UCNV_UNASSIGNED && (out_char = FallbackForGBK(code_point))) {
+    const UChar* source = &out_char;
     *err = U_ZERO_ERROR;
-    ucnv_cbFromUWriteUChars(fromUArgs, &source, source + 1, 0, err);
+    ucnv_cbFromUWriteUChars(from_unicode_args, &source, source + 1, 0, err);
     return;
   }
-  NumericEntityCallback(context, fromUArgs, codeUnits, length, codePoint,
-                        reason, err);
+  NumericEntityCallback(context, from_unicode_args, code_units, length,
+                        code_point, reason, err);
 }
 
 // Combines both gbkCssEscapedEntityCallback and GBK character substitution.
-static void gbkCssEscapedEntityCallack(const void* context,
-                                       UConverterFromUnicodeArgs* fromUArgs,
-                                       const UChar* codeUnits,
-                                       int32_t length,
-                                       UChar32 codePoint,
-                                       UConverterCallbackReason reason,
-                                       UErrorCode* err) {
+static void GbkCssEscapedEntityCallack(
+    const void* context,
+    UConverterFromUnicodeArgs* from_unicode_args,
+    const UChar* code_units,
+    int32_t length,
+    UChar32 code_point,
+    UConverterCallbackReason reason,
+    UErrorCode* err) {
   if (reason == UCNV_UNASSIGNED) {
-    if (UChar outChar = fallbackForGBK(codePoint)) {
-      const UChar* source = &outChar;
+    if (UChar out_char = FallbackForGBK(code_point)) {
+      const UChar* source = &out_char;
       *err = U_ZERO_ERROR;
-      ucnv_cbFromUWriteUChars(fromUArgs, &source, source + 1, 0, err);
+      ucnv_cbFromUWriteUChars(from_unicode_args, &source, source + 1, 0, err);
       return;
     }
-    CssEscapedEntityCallback(context, fromUArgs, codeUnits, length, codePoint,
-                             reason, err);
+    CssEscapedEntityCallback(context, from_unicode_args, code_units, length,
+                             code_point, reason, err);
     return;
   }
-  UCNV_FROM_U_CALLBACK_ESCAPE(context, fromUArgs, codeUnits, length, codePoint,
-                              reason, err);
+  UCNV_FROM_U_CALLBACK_ESCAPE(context, from_unicode_args, code_units, length,
+                              code_point, reason, err);
 }
 
 // Combines both gbkUrlEscapedEntityCallback and GBK character substitution.
-static void gbkUrlEscapedEntityCallack(const void* context,
-                                       UConverterFromUnicodeArgs* fromUArgs,
-                                       const UChar* codeUnits,
-                                       int32_t length,
-                                       UChar32 codePoint,
-                                       UConverterCallbackReason reason,
-                                       UErrorCode* err) {
+static void GbkUrlEscapedEntityCallack(
+    const void* context,
+    UConverterFromUnicodeArgs* from_unicode_args,
+    const UChar* code_units,
+    int32_t length,
+    UChar32 code_point,
+    UConverterCallbackReason reason,
+    UErrorCode* err) {
   if (reason == UCNV_UNASSIGNED) {
-    if (UChar outChar = fallbackForGBK(codePoint)) {
-      const UChar* source = &outChar;
+    if (UChar out_char = FallbackForGBK(code_point)) {
+      const UChar* source = &out_char;
       *err = U_ZERO_ERROR;
-      ucnv_cbFromUWriteUChars(fromUArgs, &source, source + 1, 0, err);
+      ucnv_cbFromUWriteUChars(from_unicode_args, &source, source + 1, 0, err);
       return;
     }
-    UrlEscapedEntityCallback(context, fromUArgs, codeUnits, length, codePoint,
-                             reason, err);
+    UrlEscapedEntityCallback(context, from_unicode_args, code_units, length,
+                             code_point, reason, err);
     return;
   }
-  UCNV_FROM_U_CALLBACK_ESCAPE(context, fromUArgs, codeUnits, length, codePoint,
-                              reason, err);
+  UCNV_FROM_U_CALLBACK_ESCAPE(context, from_unicode_args, code_units, length,
+                              code_point, reason, err);
 }
 
-static void gbkCallbackSubstitute(const void* context,
-                                  UConverterFromUnicodeArgs* fromUArgs,
-                                  const UChar* codeUnits,
+static void GbkCallbackSubstitute(const void* context,
+                                  UConverterFromUnicodeArgs* from_unicode_args,
+                                  const UChar* code_units,
                                   int32_t length,
-                                  UChar32 codePoint,
+                                  UChar32 code_point,
                                   UConverterCallbackReason reason,
                                   UErrorCode* err) {
-  UChar outChar;
-  if (reason == UCNV_UNASSIGNED && (outChar = fallbackForGBK(codePoint))) {
-    const UChar* source = &outChar;
+  UChar out_char;
+  if (reason == UCNV_UNASSIGNED && (out_char = FallbackForGBK(code_point))) {
+    const UChar* source = &out_char;
     *err = U_ZERO_ERROR;
-    ucnv_cbFromUWriteUChars(fromUArgs, &source, source + 1, 0, err);
+    ucnv_cbFromUWriteUChars(from_unicode_args, &source, source + 1, 0, err);
     return;
   }
-  UCNV_FROM_U_CALLBACK_SUBSTITUTE(context, fromUArgs, codeUnits, length,
-                                  codePoint, reason, err);
+  UCNV_FROM_U_CALLBACK_SUBSTITUTE(context, from_unicode_args, code_units,
+                                  length, code_point, reason, err);
 }
 #endif  // USING_SYSTEM_ICU
 
 class TextCodecInput final {
   STACK_ALLOCATED();
 
  public:
   TextCodecInput(const TextEncoding& encoding,
                  const UChar* characters,
                  size_t length)
@@ skipping 29 matching lines @@
     case kQuestionMarksForUnencodables:
       // Non-byte-based encodings (i.e. UTF-16/32) don't need substitutions
       // since they can encode any code point, and ucnv_setSubstChars would
       // require a multi-byte substitution anyway.
       if (!encoding_.IsNonByteBasedEncoding())
         ucnv_setSubstChars(converter_icu_, "?", 1, &err);
 #if !defined(USING_SYSTEM_ICU)
       ucnv_setFromUCallBack(converter_icu_, UCNV_FROM_U_CALLBACK_SUBSTITUTE, 0,
                             0, 0, &err);
 #else
-      ucnv_setFromUCallBack(
-          converter_icu_, m_needsGBKFallbacks ? gbkCallbackSubstitute
-                                              : UCNV_FROM_U_CALLBACK_SUBSTITUTE,
-          0, 0, 0, &err);
+      ucnv_setFromUCallBack(converter_icu_,
+                            needs_gbk_fallbacks_
+                                ? GbkCallbackSubstitute
+                                : UCNV_FROM_U_CALLBACK_SUBSTITUTE,
+                            0, 0, 0, &err);
 #endif
       break;
     case kEntitiesForUnencodables:
 #if !defined(USING_SYSTEM_ICU)
       ucnv_setFromUCallBack(converter_icu_, NumericEntityCallback, 0, 0, 0,
                             &err);
 #else
       ucnv_setFromUCallBack(
           converter_icu_,
-          m_needsGBKFallbacks ? gbkCallbackEscape : NumericEntityCallback, 0, 0,
-          0, &err);
+          needs_gbk_fallbacks_ ? GbkCallbackEscape : NumericEntityCallback, 0,
+          0, 0, &err);
 #endif
       break;
     case kURLEncodedEntitiesForUnencodables:
 #if !defined(USING_SYSTEM_ICU)
       ucnv_setFromUCallBack(converter_icu_, UrlEscapedEntityCallback, 0, 0, 0,
                             &err);
 #else
       ucnv_setFromUCallBack(converter_icu_,
-                            m_needsGBKFallbacks ? gbkUrlEscapedEntityCallack
-                                                : UrlEscapedEntityCallback,
+                            needs_gbk_fallbacks_ ? GbkUrlEscapedEntityCallack
+                                                 : UrlEscapedEntityCallback,
                             0, 0, 0, &err);
 #endif
       break;
     case kCSSEncodedEntitiesForUnencodables:
 #if !defined(USING_SYSTEM_ICU)
       ucnv_setFromUCallBack(converter_icu_, CssEscapedEntityCallback, 0, 0, 0,
                             &err);
 #else
       ucnv_setFromUCallBack(converter_icu_,
-                            m_needsGBKFallbacks ? gbkCssEscapedEntityCallack
-                                                : CssEscapedEntityCallback,
+                            needs_gbk_fallbacks_ ? GbkCssEscapedEntityCallack
+                                                 : CssEscapedEntityCallback,
                             0, 0, 0, &err);
 #endif
       break;
   }
 
   DCHECK(U_SUCCESS(err));
   if (U_FAILURE(err))
     return CString();
 
   Vector<char> result;
@@ skipping 36 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