d98f9ac5fa008a1626b0dcea4fe599067853dad2
[WebKit-https.git] / Source / WebCore / platform / text / TextCodecICU.cpp
1 /*
2  * Copyright (C) 2004, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
3  * Copyright (C) 2006 Alexey Proskuryakov <ap@nypop.com>
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #include "config.h"
28 #include "TextCodecICU.h"
29
30 #include "TextEncoding.h"
31 #include "TextEncodingRegistry.h"
32 #include "ThreadGlobalData.h"
33 #include <unicode/ucnv.h>
34 #include <unicode/ucnv_cb.h>
35 #include <wtf/Assertions.h>
36 #include <wtf/StringExtras.h>
37 #include <wtf/Threading.h>
38 #include <wtf/text/CString.h>
39 #include <wtf/text/StringBuilder.h>
40 #include <wtf/unicode/CharacterNames.h>
41
42 namespace WebCore {
43
44 const size_t ConversionBufferSize = 16384;
45
46 #if PLATFORM(IOS)
47 static const char* textCodecMacAliases[] = {
48     "macos-7_3-10.2", // xmaccyrillic, maccyrillic
49     "macos-6_2-10.4", // xmacgreek
50     "macos-6-10.2",   // macgreek
51     "macos-29-10.2",  // xmaccentraleurroman, maccentraleurroman
52     "macos-35-10.2",  // xmacturkish, macturkish
53     "softbank-sjis",  // softbanksjis
54     nullptr
55 };
56 #endif
57
58 ICUConverterWrapper::~ICUConverterWrapper()
59 {
60     if (converter)
61         ucnv_close(converter);
62 }
63
64 static UConverter*& cachedConverterICU()
65 {
66     return threadGlobalData().cachedConverterICU().converter;
67 }
68
69 PassOwnPtr<TextCodec> TextCodecICU::create(const TextEncoding& encoding, const void* additionalData)
70 {
71     // Name strings are persistently kept in TextEncodingRegistry maps, so they are never deleted.
72     return adoptPtr(new TextCodecICU(encoding.name(), static_cast<const char*>(additionalData)));
73 }
74
75 void TextCodecICU::registerEncodingNames(EncodingNameRegistrar registrar)
76 {
77     // We register Hebrew with logical ordering using a separate name.
78     // Otherwise, this would share the same canonical name as the
79     // visual ordering case, and then TextEncoding could not tell them
80     // apart; ICU treats these names as synonyms.
81     registrar("ISO-8859-8-I", "ISO-8859-8-I");
82
83     int32_t numConverters = ucnv_countAvailable();
84     for (int32_t i = 0; i < numConverters; ++i) {
85         const char* canonicalConverterName = ucnv_getAvailableName(i);
86         UErrorCode error = U_ZERO_ERROR;
87         // Try MIME before trying IANA to pick up commonly used names like
88         // 'EUC-JP' instead of horrendously long names like 
89         // 'Extended_UNIX_Code_Packed_Format_for_Japanese'. 
90         const char* webStandardName = ucnv_getStandardName(canonicalConverterName, "MIME", &error);
91         if (!U_SUCCESS(error) || !webStandardName) {
92             error = U_ZERO_ERROR;
93             // Try IANA to pick up 'windows-12xx' and other names
94             // which are not preferred MIME names but are widely used. 
95             webStandardName = ucnv_getStandardName(canonicalConverterName, "IANA", &error);
96             if (!U_SUCCESS(error) || !webStandardName)
97                 continue;
98         }
99
100         // Any standard encoding overrides should match checks in registerCodecs() below.
101
102         // 1. Treat GB2312 encoding as GBK (its more modern superset), to match other browsers.
103         // 2. On the Web, GB2312 is encoded as EUC-CN or HZ, while ICU provides a native encoding
104         //    for encoding GB_2312-80 and several others. So, we need to override this behavior, too.
105         if (strcmp(webStandardName, "GB2312") == 0 || strcmp(webStandardName, "GB_2312-80") == 0)
106             webStandardName = "GBK";
107         // Similarly, EUC-KR encodings all map to an extended version.
108         else if (strcmp(webStandardName, "KSC_5601") == 0 || strcmp(webStandardName, "EUC-KR") == 0 || strcmp(webStandardName, "cp1363") == 0)
109             webStandardName = "windows-949";
110         // And so on.
111         // FIXME: strcasecmp is locale sensitive, we should not be using it.
112         else if (strcasecmp(webStandardName, "iso-8859-9") == 0) // This name is returned in different case by ICU 3.2 and 3.6.
113             webStandardName = "windows-1254";
114         else if (strcmp(webStandardName, "TIS-620") == 0)
115             webStandardName = "windows-874";
116
117         registrar(webStandardName, webStandardName);
118
119         uint16_t numAliases = ucnv_countAliases(canonicalConverterName, &error);
120         ASSERT(U_SUCCESS(error));
121         if (U_SUCCESS(error))
122             for (uint16_t j = 0; j < numAliases; ++j) {
123                 error = U_ZERO_ERROR;
124                 const char* alias = ucnv_getAlias(canonicalConverterName, j, &error);
125                 ASSERT(U_SUCCESS(error));
126                 if (U_SUCCESS(error) && alias != webStandardName)
127                     registrar(alias, webStandardName);
128             }
129     }
130
131     // Additional aliases.
132     // macroman is present in modern versions of ICU, but not in ICU 3.2 (shipped with Mac OS X 10.4).
133     // FIXME: Do any ports still use such old versions?
134     registrar("macroman", "macintosh");
135
136     // Additional aliases that historically were present in the encoding
137     // table in WebKit on Macintosh that don't seem to be present in ICU.
138     // Perhaps we can prove these are not used on the web and remove them.
139     // Or perhaps we can get them added to ICU.
140     registrar("x-mac-roman", "macintosh");
141     registrar("maccyrillic", "x-mac-cyrillic");
142     registrar("x-mac-ukrainian", "x-mac-cyrillic");
143     registrar("cn-big5", "Big5");
144     registrar("x-x-big5", "Big5");
145     registrar("cn-gb", "GBK");
146     registrar("csgb231280", "GBK");
147     registrar("x-euc-cn", "GBK");
148     registrar("x-gbk", "GBK");
149     registrar("csISO88598I", "ISO-8859-8-I");
150     registrar("koi", "KOI8-R");
151     registrar("logical", "ISO-8859-8-I");
152     registrar("visual", "ISO-8859-8");
153     registrar("winarabic", "windows-1256");
154     registrar("winbaltic", "windows-1257");
155     registrar("wincyrillic", "windows-1251");
156     registrar("iso-8859-11", "windows-874");
157     registrar("iso8859-11", "windows-874");
158     registrar("dos-874", "windows-874");
159     registrar("wingreek", "windows-1253");
160     registrar("winhebrew", "windows-1255");
161     registrar("winlatin2", "windows-1250");
162     registrar("winturkish", "windows-1254");
163     registrar("winvietnamese", "windows-1258");
164     registrar("x-cp1250", "windows-1250");
165     registrar("x-cp1251", "windows-1251");
166     registrar("x-euc", "EUC-JP");
167     registrar("x-windows-949", "windows-949");
168     registrar("KSC5601", "windows-949");
169     registrar("x-uhc", "windows-949");
170     registrar("shift-jis", "Shift_JIS");
171
172     // These aliases are present in modern versions of ICU, but use different codecs, and have no standard names.
173     // They are not present in ICU 3.2.
174     registrar("dos-720", "cp864");
175     registrar("jis7", "ISO-2022-JP");
176
177     // Alternative spelling of ISO encoding names.
178     registrar("ISO8859-1", "ISO-8859-1");
179     registrar("ISO8859-2", "ISO-8859-2");
180     registrar("ISO8859-3", "ISO-8859-3");
181     registrar("ISO8859-4", "ISO-8859-4");
182     registrar("ISO8859-5", "ISO-8859-5");
183     registrar("ISO8859-6", "ISO-8859-6");
184     registrar("ISO8859-7", "ISO-8859-7");
185     registrar("ISO8859-8", "ISO-8859-8");
186     registrar("ISO8859-8-I", "ISO-8859-8-I");
187     registrar("ISO8859-9", "windows-1254");
188     registrar("ISO8859-10", "ISO-8859-10");
189     registrar("ISO8859-13", "ISO-8859-13");
190     registrar("ISO8859-14", "ISO-8859-14");
191     registrar("ISO8859-15", "ISO-8859-15");
192     // Not registering ISO8859-16, because Firefox (as of version 3.6.6) doesn't know this particular alias,
193     // and because older versions of ICU don't support ISO-8859-16 encoding at all.
194
195 #if PLATFORM(IOS)
196     // A.B. adding a few more Mac encodings missing 'cause we don't have TextCodecMac right now
197     // luckily, they are supported in ICU, just need to alias them.
198     // this handles encodings that OS X uses TEC (TextCodecMac)
199     // <http://publib.boulder.ibm.com/infocenter/wmbhelp/v6r0m0/index.jsp?topic=/com.ibm.etools.mft.eb.doc/ac00408_.htm>
200     int32_t i = 0;
201     for (const char* macAlias = textCodecMacAliases[i]; macAlias; macAlias = textCodecMacAliases[++i]) {
202         registrar(macAlias, macAlias);
203
204         UErrorCode error = U_ZERO_ERROR;
205         uint16_t numAliases = ucnv_countAliases(macAlias, &error);
206         ASSERT(U_SUCCESS(error));
207         if (U_SUCCESS(error))
208             for (uint16_t j = 0; j < numAliases; ++j) {
209                 error = U_ZERO_ERROR;
210                 const char* alias = ucnv_getAlias(macAlias, j, &error);
211                 ASSERT(U_SUCCESS(error));
212                 if (U_SUCCESS(error) && strcmp(alias, macAlias))
213                     registrar(alias, macAlias);
214             }
215     }
216 #endif
217 }
218
219 void TextCodecICU::registerCodecs(TextCodecRegistrar registrar)
220 {
221     // See comment above in registerEncodingNames.
222     UErrorCode error = U_ZERO_ERROR;
223     const char* canonicalConverterName = ucnv_getCanonicalName("ISO-8859-8-I", "IANA", &error);
224     ASSERT(U_SUCCESS(error));
225     registrar("ISO-8859-8-I", create, canonicalConverterName);
226
227     int32_t numConverters = ucnv_countAvailable();
228     for (int32_t i = 0; i < numConverters; ++i) {
229         canonicalConverterName = ucnv_getAvailableName(i);
230         error = U_ZERO_ERROR;
231         const char* webStandardName = ucnv_getStandardName(canonicalConverterName, "MIME", &error);
232         if (!U_SUCCESS(error) || !webStandardName) {
233             error = U_ZERO_ERROR;
234             webStandardName = ucnv_getStandardName(canonicalConverterName, "IANA", &error);
235             if (!U_SUCCESS(error) || !webStandardName)
236                 continue;
237         }
238
239         // Don't register codecs for overridden encodings.
240         if (strcmp(webStandardName, "GB2312") == 0 || strcmp(webStandardName, "GB_2312-80") == 0
241             || strcmp(webStandardName, "KSC_5601") == 0 || strcmp(webStandardName, "EUC-KR") == 0
242             || strcmp(webStandardName, "cp1363") == 0
243             || strcasecmp(webStandardName, "iso-8859-9") == 0
244             || strcmp(webStandardName, "TIS-620") == 0)
245             continue;
246
247         registrar(webStandardName, create, fastStrDup(canonicalConverterName));
248     }
249
250     // These encodings currently don't have standard names, so we need to register encoders manually.
251     // FIXME: Is there a good way to determine the most up to date variant programmatically?
252     registrar("windows-874", create, "windows-874-2000");
253     registrar("windows-949", create, "windows-949-2000");
254
255 #if PLATFORM(IOS)
256     // See comment above in registerEncodingNames().
257     int32_t i = 0;
258     for (const char* alias = textCodecMacAliases[i]; alias; alias = textCodecMacAliases[++i])
259         registrar(alias, create, 0);
260 #endif
261 }
262
263 TextCodecICU::TextCodecICU(const char* encoding, const char* canonicalConverterName)
264     : m_encodingName(encoding)
265     , m_canonicalConverterName(canonicalConverterName)
266     , m_converterICU(0)
267     , m_needsGBKFallbacks(false)
268 {
269 }
270
271 TextCodecICU::~TextCodecICU()
272 {
273     releaseICUConverter();
274 }
275
276 void TextCodecICU::releaseICUConverter() const
277 {
278     if (m_converterICU) {
279         UConverter*& cachedConverter = cachedConverterICU();
280         if (cachedConverter)
281             ucnv_close(cachedConverter);
282         ucnv_reset(m_converterICU);
283         cachedConverter = m_converterICU;
284         m_converterICU = 0;
285     }
286 }
287
288 void TextCodecICU::createICUConverter() const
289 {
290     ASSERT(!m_converterICU);
291
292     UErrorCode err;
293
294     m_needsGBKFallbacks = !strcmp(m_encodingName, "GBK");
295
296     UConverter*& cachedConverter = cachedConverterICU();
297     if (cachedConverter) {
298         err = U_ZERO_ERROR;
299         const char* cachedConverterName = ucnv_getName(cachedConverter, &err);
300         if (U_SUCCESS(err) && !strcmp(m_canonicalConverterName, cachedConverterName)) {
301             m_converterICU = cachedConverter;
302             cachedConverter = 0;
303             return;
304         }
305     }
306
307     err = U_ZERO_ERROR;
308     m_converterICU = ucnv_open(m_canonicalConverterName, &err);
309     ASSERT(U_SUCCESS(err));
310     if (m_converterICU)
311         ucnv_setFallback(m_converterICU, TRUE);
312 }
313
314 int TextCodecICU::decodeToBuffer(UChar* target, UChar* targetLimit, const char*& source, const char* sourceLimit, int32_t* offsets, bool flush, UErrorCode& err)
315 {
316     UChar* targetStart = target;
317     err = U_ZERO_ERROR;
318     ucnv_toUnicode(m_converterICU, &target, targetLimit, &source, sourceLimit, offsets, flush, &err);
319     return target - targetStart;
320 }
321
322 class ErrorCallbackSetter {
323 public:
324     ErrorCallbackSetter(UConverter* converter, bool stopOnError)
325         : m_converter(converter)
326         , m_shouldStopOnEncodingErrors(stopOnError)
327     {
328         if (m_shouldStopOnEncodingErrors) {
329             UErrorCode err = U_ZERO_ERROR;
330             ucnv_setToUCallBack(m_converter, UCNV_TO_U_CALLBACK_SUBSTITUTE,
331                            UCNV_SUB_STOP_ON_ILLEGAL, &m_savedAction,
332                            &m_savedContext, &err);
333             ASSERT(err == U_ZERO_ERROR);
334         }
335     }
336     ~ErrorCallbackSetter()
337     {
338         if (m_shouldStopOnEncodingErrors) {
339             UErrorCode err = U_ZERO_ERROR;
340             const void* oldContext;
341             UConverterToUCallback oldAction;
342             ucnv_setToUCallBack(m_converter, m_savedAction,
343                    m_savedContext, &oldAction,
344                    &oldContext, &err);
345             ASSERT(oldAction == UCNV_TO_U_CALLBACK_SUBSTITUTE);
346             ASSERT(!strcmp(static_cast<const char*>(oldContext), UCNV_SUB_STOP_ON_ILLEGAL));
347             ASSERT(err == U_ZERO_ERROR);
348         }
349     }
350
351 private:
352     UConverter* m_converter;
353     bool m_shouldStopOnEncodingErrors;
354     const void* m_savedContext;
355     UConverterToUCallback m_savedAction;
356 };
357
358 String TextCodecICU::decode(const char* bytes, size_t length, bool flush, bool stopOnError, bool& sawError)
359 {
360     // Get a converter for the passed-in encoding.
361     if (!m_converterICU) {
362         createICUConverter();
363         ASSERT(m_converterICU);
364         if (!m_converterICU) {
365             LOG_ERROR("error creating ICU encoder even though encoding was in table");
366             return String();
367         }
368     }
369     
370     ErrorCallbackSetter callbackSetter(m_converterICU, stopOnError);
371
372     StringBuilder result;
373
374     UChar buffer[ConversionBufferSize];
375     UChar* bufferLimit = buffer + ConversionBufferSize;
376     const char* source = reinterpret_cast<const char*>(bytes);
377     const char* sourceLimit = source + length;
378     int32_t* offsets = NULL;
379     UErrorCode err = U_ZERO_ERROR;
380
381     do {
382         int ucharsDecoded = decodeToBuffer(buffer, bufferLimit, source, sourceLimit, offsets, flush, err);
383         result.append(buffer, ucharsDecoded);
384     } while (err == U_BUFFER_OVERFLOW_ERROR);
385
386     if (U_FAILURE(err)) {
387         // flush the converter so it can be reused, and not be bothered by this error.
388         do {
389             decodeToBuffer(buffer, bufferLimit, source, sourceLimit, offsets, true, err);
390         } while (source < sourceLimit);
391         sawError = true;
392     }
393
394     String resultString = result.toString();
395
396     // <http://bugs.webkit.org/show_bug.cgi?id=17014>
397     // Simplified Chinese pages use the code A3A0 to mean "full-width space", but ICU decodes it as U+E5E5.
398     // FIXME: strcasecmp is locale sensitive, we should not be using it.
399     if (strcmp(m_encodingName, "GBK") == 0 || strcasecmp(m_encodingName, "gb18030") == 0)
400         resultString.replace(0xE5E5, ideographicSpace);
401
402     return resultString;
403 }
404
405 // We need to apply these fallbacks ourselves as they are not currently supported by ICU and
406 // they were provided by the old TEC encoding path. Needed to fix <rdar://problem/4708689>.
407 static UChar fallbackForGBK(UChar32 character)
408 {
409     switch (character) {
410     case 0x01F9:
411         return 0xE7C8;
412     case 0x1E3F:
413         return 0xE7C7;
414     case 0x22EF:
415         return 0x2026;
416     case 0x301C:
417         return 0xFF5E;
418     }
419     return 0;
420 }
421
422 // Invalid character handler when writing escaped entities for unrepresentable
423 // characters. See the declaration of TextCodec::encode for more.
424 static void urlEscapedEntityCallback(const void* context, UConverterFromUnicodeArgs* fromUArgs, const UChar* codeUnits, int32_t length,
425     UChar32 codePoint, UConverterCallbackReason reason, UErrorCode* err)
426 {
427     if (reason == UCNV_UNASSIGNED) {
428         *err = U_ZERO_ERROR;
429
430         UnencodableReplacementArray entity;
431         int entityLen = TextCodec::getUnencodableReplacement(codePoint, URLEncodedEntitiesForUnencodables, entity);
432         ucnv_cbFromUWriteBytes(fromUArgs, entity, entityLen, 0, err);
433     } else
434         UCNV_FROM_U_CALLBACK_ESCAPE(context, fromUArgs, codeUnits, length, codePoint, reason, err);
435 }
436
437 // Substitutes special GBK characters, escaping all other unassigned entities.
438 static void gbkCallbackEscape(const void* context, UConverterFromUnicodeArgs* fromUArgs, const UChar* codeUnits, int32_t length,
439     UChar32 codePoint, UConverterCallbackReason reason, UErrorCode* err) 
440 {
441     UChar outChar;
442     if (reason == UCNV_UNASSIGNED && (outChar = fallbackForGBK(codePoint))) {
443         const UChar* source = &outChar;
444         *err = U_ZERO_ERROR;
445         ucnv_cbFromUWriteUChars(fromUArgs, &source, source + 1, 0, err);
446         return;
447     }
448     UCNV_FROM_U_CALLBACK_ESCAPE(context, fromUArgs, codeUnits, length, codePoint, reason, err);
449 }
450
451 // Combines both gbkUrlEscapedEntityCallback and GBK character substitution.
452 static void gbkUrlEscapedEntityCallack(const void* context, UConverterFromUnicodeArgs* fromUArgs, const UChar* codeUnits, int32_t length,
453     UChar32 codePoint, UConverterCallbackReason reason, UErrorCode* err) 
454 {
455     if (reason == UCNV_UNASSIGNED) {
456         if (UChar outChar = fallbackForGBK(codePoint)) {
457             const UChar* source = &outChar;
458             *err = U_ZERO_ERROR;
459             ucnv_cbFromUWriteUChars(fromUArgs, &source, source + 1, 0, err);
460             return;
461         }
462         urlEscapedEntityCallback(context, fromUArgs, codeUnits, length, codePoint, reason, err);
463         return;
464     }
465     UCNV_FROM_U_CALLBACK_ESCAPE(context, fromUArgs, codeUnits, length, codePoint, reason, err);
466 }
467
468 static void gbkCallbackSubstitute(const void* context, UConverterFromUnicodeArgs* fromUArgs, const UChar* codeUnits, int32_t length,
469     UChar32 codePoint, UConverterCallbackReason reason, UErrorCode* err) 
470 {
471     UChar outChar;
472     if (reason == UCNV_UNASSIGNED && (outChar = fallbackForGBK(codePoint))) {
473         const UChar* source = &outChar;
474         *err = U_ZERO_ERROR;
475         ucnv_cbFromUWriteUChars(fromUArgs, &source, source + 1, 0, err);
476         return;
477     }
478     UCNV_FROM_U_CALLBACK_SUBSTITUTE(context, fromUArgs, codeUnits, length, codePoint, reason, err);
479 }
480
481 CString TextCodecICU::encode(const UChar* characters, size_t length, UnencodableHandling handling)
482 {
483     if (!length)
484         return "";
485
486     if (!m_converterICU)
487         createICUConverter();
488     if (!m_converterICU)
489         return CString();
490
491     // FIXME: We should see if there is "force ASCII range" mode in ICU;
492     // until then, we change the backslash into a yen sign.
493     // Encoding will change the yen sign back into a backslash.
494     Vector<UChar> copy;
495     const UChar* source = characters;
496     if (shouldShowBackslashAsCurrencySymbolIn(m_encodingName)) {
497         for (size_t i = 0; i < length; ++i) {
498             if (characters[i] == '\\') {
499                 copy.reserveInitialCapacity(length);
500                 for (size_t j = 0; j < i; ++j)
501                     copy.uncheckedAppend(characters[j]);
502                 for (size_t j = i; j < length; ++j) {
503                     UChar character = characters[j];
504                     if (character == '\\')
505                         character = yenSign;
506                     copy.uncheckedAppend(character);
507                 }
508                 source = copy.data();
509                 break;
510             }
511         }
512     }
513     const UChar* sourceLimit = source + length;
514
515     UErrorCode err = U_ZERO_ERROR;
516
517     switch (handling) {
518         case QuestionMarksForUnencodables:
519             ucnv_setSubstChars(m_converterICU, "?", 1, &err);
520             ucnv_setFromUCallBack(m_converterICU, m_needsGBKFallbacks ? gbkCallbackSubstitute : UCNV_FROM_U_CALLBACK_SUBSTITUTE, 0, 0, 0, &err);
521             break;
522         case EntitiesForUnencodables:
523             ucnv_setFromUCallBack(m_converterICU, m_needsGBKFallbacks ? gbkCallbackEscape : UCNV_FROM_U_CALLBACK_ESCAPE, UCNV_ESCAPE_XML_DEC, 0, 0, &err);
524             break;
525         case URLEncodedEntitiesForUnencodables:
526             ucnv_setFromUCallBack(m_converterICU, m_needsGBKFallbacks ? gbkUrlEscapedEntityCallack : urlEscapedEntityCallback, 0, 0, 0, &err);
527             break;
528     }
529
530     ASSERT(U_SUCCESS(err));
531     if (U_FAILURE(err))
532         return CString();
533
534     Vector<char> result;
535     size_t size = 0;
536     do {
537         char buffer[ConversionBufferSize];
538         char* target = buffer;
539         char* targetLimit = target + ConversionBufferSize;
540         err = U_ZERO_ERROR;
541         ucnv_fromUnicode(m_converterICU, &target, targetLimit, &source, sourceLimit, 0, true, &err);
542         size_t count = target - buffer;
543         result.grow(size + count);
544         memcpy(result.data() + size, buffer, count);
545         size += count;
546     } while (err == U_BUFFER_OVERFLOW_ERROR);
547
548     return CString(result.data(), size);
549 }
550
551 } // namespace WebCore