Define a variable to distinguish system_icu from bundled_icu in Blink

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 53 matching lines @@
     // We register Hebrew with logical ordering using a separate name.
     // Otherwise, this would share the same canonical name as the
     // visual ordering case, and then TextEncoding could not tell them
     // apart; ICU treats these names as synonyms.
     registrar("ISO-8859-8-I", "ISO-8859-8-I");
 
     int32_t numEncodings = ucnv_countAvailable();
     for (int32_t i = 0; i < numEncodings; ++i) {
         const char* name = ucnv_getAvailableName(i);
         UErrorCode error = U_ZERO_ERROR;
-        // Try MIME before trying IANA to pick up commonly used names like
-        // 'EUC-JP' instead of horrendously long names like
-        // 'Extended_UNIX_Code_Packed_Format_for_Japanese'.
-        const char* standardName = ucnv_getStandardName(name, "MIME", &error);
-        if (!U_SUCCESS(error) || !standardName) {
+#if !defined(USING_SYSTEM_ICU)
+        const char* primaryStandard = "HTML";
+        const char* secondaryStandard = "MIME";
+#else
+        const char* primaryStandard = "MIME";
+        const char* secondaryStandard = "IANA";
+#endif
+        const char* standardName = ucnv_getStandardName(name, primaryStandard, &error);
+        if (U_FAILURE(error) || !standardName) {
             error = U_ZERO_ERROR;
             // Try IANA to pick up 'windows-12xx' and other names
             // which are not preferred MIME names but are widely used.
-            standardName = ucnv_getStandardName(name, "IANA", &error);
-            if (!U_SUCCESS(error) || !standardName)
+            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.
+#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.
             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))
             for (uint16_t j = 0; j < numAliases; ++j) {
                 error = U_ZERO_ERROR;
                 const char* alias = ucnv_getAlias(name, j, &error);
                 ASSERT(U_SUCCESS(error));
                 if (U_SUCCESS(error) && alias != standardName)
                     registrar(alias, standardName);
             }
     }
 
+    // These two entries have to be added here because ICU's converter table
+    // cannot have both ISO-8859-8-I and ISO-8859-8.
+    registrar("csISO88598I", "ISO-8859-8-I");
+    registrar("logical", "ISO-8859-8-I");
+
+#if defined(USING_SYSTEM_ICU)
     // Additional alias for MacCyrillic not present in ICU.
     registrar("maccyrillic", "x-mac-cyrillic");
 
     // Additional aliases that historically were present in the encoding
     // table in WebKit on Macintosh that don't seem to be present in ICU.
     // Perhaps we can prove these are not used on the web and remove them.
     // Or perhaps we can get them added to ICU.
     registrar("x-mac-roman", "macintosh");
     registrar("x-mac-ukrainian", "x-mac-cyrillic");
     registrar("cn-big5", "Big5");
     registrar("x-x-big5", "Big5");
     registrar("cn-gb", "GBK");
     registrar("csgb231280", "GBK");
     registrar("x-euc-cn", "GBK");
     registrar("x-gbk", "GBK");
-    registrar("csISO88598I", "ISO-8859-8-I");
     registrar("koi", "KOI8-R");
-    registrar("logical", "ISO-8859-8-I");
     registrar("visual", "ISO-8859-8");
     registrar("winarabic", "windows-1256");
     registrar("winbaltic", "windows-1257");
     registrar("wincyrillic", "windows-1251");
     registrar("iso-8859-11", "windows-874");
     registrar("iso8859-11", "windows-874");
     registrar("dos-874", "windows-874");
     registrar("wingreek", "windows-1253");
     registrar("winhebrew", "windows-1255");
     registrar("winlatin2", "windows-1250");
@@ skipping 22 matching lines @@
     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/ ).
 
     // 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.
-    // FIXME: We may introduce SYSTEM_ICU and enclose this block
-    // with |#if SYSTEM_ICU| because Chromium's ICU has them all.
     registrar("csiso58gb231280", "GBK");
     registrar("csiso88596e", "ISO-8859-6");
     registrar("csiso88596i", "ISO-8859-6");
     registrar("csiso88598e", "ISO-8859-8");
     registrar("gb_2312", "GBK");
     registrar("iso88592", "ISO-8859-2");
     registrar("iso88593", "ISO-8859-3");
     registrar("iso88594", "ISO-8859-4");
     registrar("iso88595", "ISO-8859-5");
     registrar("iso88596", "ISO-8859-6");
@@ skipping 14 matching lines @@
     registrar("iso_8859-8", "ISO-8859-8");
     registrar("iso_8859-9", "windows-1254");
     registrar("iso_8859-15", "ISO-8859-15");
     registrar("koi8_r", "KOI8-R");
     registrar("x-cp1253", "windows-1253");
     registrar("x-cp1254", "windows-1254");
     registrar("x-cp1255", "windows-1255");
     registrar("x-cp1256", "windows-1256");
     registrar("x-cp1257", "windows-1257");
     registrar("x-cp1258", "windows-1258");
+#endif
 }
 
 void TextCodecICU::registerCodecs(TextCodecRegistrar registrar)
 {
     // See comment above in registerEncodingNames.
     registrar("ISO-8859-8-I", create, 0);
 
     int32_t numEncodings = ucnv_countAvailable();
     for (int32_t i = 0; i < numEncodings; ++i) {
         const char* name = ucnv_getAvailableName(i);
         UErrorCode error = U_ZERO_ERROR;
         const char* standardName = ucnv_getStandardName(name, "MIME", &error);
         if (!U_SUCCESS(error) || !standardName) {
             error = U_ZERO_ERROR;
             standardName = ucnv_getStandardName(name, "IANA", &error);
             if (!U_SUCCESS(error) || !standardName)
                 continue;
         }
         registrar(standardName, create, 0);
     }
 }
 
 TextCodecICU::TextCodecICU(const TextEncoding& encoding)
     : m_encoding(encoding)
     , m_converterICU(0)
+#if defined(USING_SYSTEM_ICU)
     , m_needsGBKFallbacks(false)
+#endif
 {
 }
 
 TextCodecICU::~TextCodecICU()
 {
     releaseICUConverter();
 }
 
 void TextCodecICU::releaseICUConverter() const
 {
     if (m_converterICU) {
         UConverter*& cachedConverter = cachedConverterICU();
         if (cachedConverter)
             ucnv_close(cachedConverter);
         cachedConverter = m_converterICU;
         m_converterICU = 0;
     }
 }
 
 void TextCodecICU::createICUConverter() const
 {
     ASSERT(!m_converterICU);
 
+#if defined(USING_SYSTEM_ICU)
     const char* name = m_encoding.name();
     m_needsGBKFallbacks = name[0] == 'G' && name[1] == 'B' && name[2] == 'K' && !name[3];
+#endif
 
     UErrorCode err;
 
     UConverter*& cachedConverter = cachedConverterICU();
     if (cachedConverter) {
         err = U_ZERO_ERROR;
         const char* cachedName = ucnv_getName(cachedConverter, &err);
         if (U_SUCCESS(err) && m_encoding == cachedName) {
             m_converterICU = cachedConverter;
             cachedConverter = 0;
@@ skipping 84 matching lines @@
     } 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 {
             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.
-    if (!strcmp(m_encoding.name(), "GBK") || !strcasecmp(m_encoding.name(), "gb18030"))
-        resultString.replace(0xE5E5, ideographicSpaceCharacter);
+    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
 }
 
-// We need to apply these fallbacks ourselves as they are not currently supported by ICU and
-// they were provided by the old TEC encoding path. Needed to fix <rdar://problem/4708689>.
+#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;
+        return 0xE7C8; // mapped to xA8xBF by ICU.
     case 0x1E3F:
-        return 0xE7C7;
-    case 0x22EF:
-        return 0x2026;
-    case 0x301C:
-        return 0xFF5E;
+        return 0xE7C7; // mapped to xA8xBC by ICU.
     }
     return 0;
 }
+#endif
 
 // Invalid character handler when writing escaped entities 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)
 {
     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
         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;
         *err = U_ZERO_ERROR;
         ucnv_cbFromUWriteUChars(fromUArgs, &source, source + 1, 0, err);
         return;
@@ skipping 23 matching lines @@
 {
     UChar outChar;
     if (reason == UCNV_UNASSIGNED && (outChar = fallbackForGBK(codePoint))) {
         const UChar* source = &outChar;
         *err = U_ZERO_ERROR;
         ucnv_cbFromUWriteUChars(fromUArgs, &source, source + 1, 0, err);
         return;
     }
     UCNV_FROM_U_CALLBACK_SUBSTITUTE(context, fromUArgs, codeUnits, length, codePoint, reason, err);
 }
+#endif // USING_SYSTEM_ICU
 
 class TextCodecInput {
 public:
     TextCodecInput(const TextEncoding& encoding, const UChar* characters, size_t length)
         : m_begin(characters)
         , m_end(characters + length)
     { }
 
     TextCodecInput(const TextEncoding& encoding, const LChar* characters, size_t length)
     {
@@ skipping 16 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);
+#if !defined(USING_SYSTEM_ICU)
+            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);
+#endif
             break;
         case EntitiesForUnencodables:
+#if !defined(USING_SYSTEM_ICU)
+            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);
+#endif
             break;
         case URLEncodedEntitiesForUnencodables:
+#if !defined(USING_SYSTEM_ICU)
+            ucnv_setFromUCallBack(m_converterICU, urlEscapedEntityCallback, 0, 0, 0, &err);
+#else
             ucnv_setFromUCallBack(m_converterICU, m_needsGBKFallbacks ? gbkUrlEscapedEntityCallack : urlEscapedEntityCallback, 0, 0, 0, &err);
+#endif
             break;
     }
 
     ASSERT(U_SUCCESS(err));
     if (U_FAILURE(err))
         return CString();
 
     Vector<char> result;
     size_t size = 0;
     do {
@@ skipping 30 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