reflow comments in 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 70 matching lines @@
       // Try IANA to pick up 'windows-12xx' and other names
       // which are not preferred MIME names but are widely used.
       standardName = ucnv_getStandardName(name, secondaryStandard, &error);
       if (U_FAILURE(error) || !standardName)
         continue;
     }
 
 // A number of these aliases are handled in Chrome's copy of ICU, but
 // Chromium can be compiled with the system ICU.
 
-// 1. Treat GB2312 encoding as GBK (its more modern superset), to match other browsers.
-// 2. On the Web, GB2312 is encoded as EUC-CN or HZ, while ICU provides a native encoding
-//    for encoding GB_2312-80 and several others. So, we need to override this behavior, too.
+// 1. Treat GB2312 encoding as GBK (its more modern superset), to match other
+//    browsers.
+// 2. On the Web, GB2312 is encoded as EUC-CN or HZ, while ICU provides a native
+//    encoding for encoding GB_2312-80 and several others. So, we need to
+//    override this behavior, too.
 #if defined(USING_SYSTEM_ICU)
     if (!strcmp(standardName, "GB2312") || !strcmp(standardName, "GB_2312-80"))
       standardName = "GBK";
     // Similarly, EUC-KR encodings all map to an extended version, but
     // per HTML5, the canonical name still should be EUC-KR.
     else if (!strcmp(standardName, "EUC-KR") ||
              !strcmp(standardName, "KSC_5601") ||
              !strcmp(standardName, "cp1363"))
       standardName = "EUC-KR";
     // And so on.
-    else if (
-        !strcasecmp(
-            standardName,
-            "iso-8859-9"))  // This name is returned in different case by ICU 3.2 and 3.6.
+    else if (!strcasecmp(standardName, "iso-8859-9"))
+      // This name is returned in different case by ICU 3.2 and 3.6.
       standardName = "windows-1254";
     else if (!strcmp(standardName, "TIS-620"))
       standardName = "windows-874";
 #endif
 
     registrar(standardName, standardName);
 
     uint16_t numAliases = ucnv_countAliases(name, &error);
     ASSERT(U_SUCCESS(error));
     if (U_SUCCESS(error))
@@ skipping 57 matching lines @@
   registrar("ISO8859-6", "ISO-8859-6");
   registrar("ISO8859-7", "ISO-8859-7");
   registrar("ISO8859-8", "ISO-8859-8");
   registrar("ISO8859-8-I", "ISO-8859-8-I");
   registrar("ISO8859-9", "ISO-8859-9");
   registrar("ISO8859-10", "ISO-8859-10");
   registrar("ISO8859-13", "ISO-8859-13");
   registrar("ISO8859-14", "ISO-8859-14");
   registrar("ISO8859-15", "ISO-8859-15");
   // No need to have an entry for ISO8859-16. ISO-8859-16 has just one label
-  // listed in WHATWG Encoding Living Standard (http://encoding.spec.whatwg.org/ ).
+  // listed in WHATWG Encoding Living Standard, http://encoding.spec.whatwg.org/
 
   // Additional aliases present in the WHATWG Encoding Standard
   // and Firefox (as of Oct 2014), but not in the upstream ICU.
   // Three entries for windows-1252 need not be listed here because
   // TextCodecLatin1 registers them.
   registrar("csiso58gb231280", "GBK");
   registrar("csiso88596e", "ISO-8859-6");
   registrar("csiso88596i", "ISO-8859-6");
   registrar("csiso88598e", "ISO-8859-8");
   registrar("gb_2312", "GBK");
@@ skipping 176 matching lines @@
   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.
+    // flush the converter so it can be reused, and not be bothered by this
+    // error.
     do {
       decodeToBuffer(buffer, bufferLimit, source, sourceLimit, offsets, true,
                      err);
     } while (source < sourceLimit);
     sawError = true;
   }
 
 #if !defined(USING_SYSTEM_ICU)
   // Chrome's copy of ICU does not have the issue described below.
   return result.toString();
 #else
   String resultString = result.toString();
 
   // <http://bugs.webkit.org/show_bug.cgi?id=17014>
-  // Simplified Chinese pages use the code A3A0 to mean "full-width space", but ICU decodes it as U+E5E5.
+  // Simplified Chinese pages use the code A3A0 to mean "full-width space", but
+  // ICU decodes it as U+E5E5.
   if (!strcmp(m_encoding.name(), "GBK")) {
     if (!strcasecmp(m_encoding.name(), "gb18030"))
       resultString.replace(0xE5E5, ideographicSpaceCharacter);
     // Make GBK compliant to the encoding spec and align with GB18030
     resultString.replace(0x01F9, 0xE7C8);
     // FIXME: Once https://www.w3.org/Bugs/Public/show_bug.cgi?id=28740#c3
     // 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) {
   switch (character) {
     case 0x01F9:
       return 0xE7C8;  // mapped to xA8xBF by ICU.
     case 0x1E3F:
       return 0xE7C7;  // mapped to xA8xBC by ICU.
   }
   return 0;
 }
 #endif
 
-// Generic helper for writing escaped entities using the specfied UnencodableHandling.
+// Generic helper for writing escaped entities using the specfied
+// UnencodableHandling.
 static void formatEscapedEntityCallback(const void* context,
                                         UConverterFromUnicodeArgs* fromUArgs,
                                         const UChar* codeUnits,
                                         int32_t length,
                                         UChar32 codePoint,
                                         UConverterCallbackReason reason,
                                         UErrorCode* err,
                                         UnencodableHandling handling) {
   if (reason == UCNV_UNASSIGNED) {
     *err = U_ZERO_ERROR;
@@ skipping 13 matching lines @@
                                   const UChar* codeUnits,
                                   int32_t length,
                                   UChar32 codePoint,
                                   UConverterCallbackReason reason,
                                   UErrorCode* err) {
   formatEscapedEntityCallback(context, fromUArgs, codeUnits, length, codePoint,
                               reason, err, EntitiesForUnencodables);
 }
 
 // Invalid character handler when writing escaped entities in CSS encoding for
-// unrepresentable characters. See the declaration of TextCodec::encode for more.
+// unrepresentable characters. See the declaration of TextCodec::encode for
+// more.
 static void cssEscapedEntityCallback(const void* context,
                                      UConverterFromUnicodeArgs* fromUArgs,
                                      const UChar* codeUnits,
                                      int32_t length,
                                      UChar32 codePoint,
                                      UConverterCallbackReason reason,
                                      UErrorCode* err) {
   formatEscapedEntityCallback(context, fromUArgs, codeUnits, length, codePoint,
                               reason, err, CSSEncodedEntitiesForUnencodables);
 }
 
-// Invalid character handler when writing escaped entities in HTML/XML encoding for
-// unrepresentable characters. See the declaration of TextCodec::encode for more.
+// Invalid character handler when writing escaped entities in HTML/XML encoding
+// for unrepresentable 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) {
   formatEscapedEntityCallback(context, fromUArgs, codeUnits, length, codePoint,
                               reason, err, URLEncodedEntitiesForUnencodables);
 }
@@ skipping 210 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