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 COMPUTER, 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 COMPUTER, 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 "wtf/text/TextCodecICU.h"
29
30 #include <unicode/ucnv.h>
31 #include <unicode/ucnv_cb.h>
32 #include "wtf/Assertions.h"
33 #include "wtf/StringExtras.h"
34 #include "wtf/Threading.h"
35 #include "wtf/WTFThreadData.h"
36 #include "wtf/text/CString.h"
37 #include "wtf/text/StringBuilder.h"
38 #include "wtf/unicode/CharacterNames.h"
39
40 using std::min;
41
42 namespace WTF {
43
44 const size_t ConversionBufferSize = 16384;
45
~ICUConverterWrapper()46 ICUConverterWrapper::~ICUConverterWrapper()
47 {
48 if (converter)
49 ucnv_close(converter);
50 }
51
cachedConverterICU()52 static UConverter*& cachedConverterICU()
53 {
54 return wtfThreadData().cachedConverterICU().converter;
55 }
56
create(const TextEncoding & encoding,const void *)57 PassOwnPtr<TextCodec> TextCodecICU::create(const TextEncoding& encoding, const void*)
58 {
59 return adoptPtr(new TextCodecICU(encoding));
60 }
61
registerEncodingNames(EncodingNameRegistrar registrar)62 void TextCodecICU::registerEncodingNames(EncodingNameRegistrar registrar)
63 {
64 // We register Hebrew with logical ordering using a separate name.
65 // Otherwise, this would share the same canonical name as the
66 // visual ordering case, and then TextEncoding could not tell them
67 // apart; ICU treats these names as synonyms.
68 registrar("ISO-8859-8-I", "ISO-8859-8-I");
69
70 int32_t numEncodings = ucnv_countAvailable();
71 for (int32_t i = 0; i < numEncodings; ++i) {
72 const char* name = ucnv_getAvailableName(i);
73 UErrorCode error = U_ZERO_ERROR;
74 // Try MIME before trying IANA to pick up commonly used names like
75 // 'EUC-JP' instead of horrendously long names like
76 // 'Extended_UNIX_Code_Packed_Format_for_Japanese'.
77 const char* standardName = ucnv_getStandardName(name, "MIME", &error);
78 if (!U_SUCCESS(error) || !standardName) {
79 error = U_ZERO_ERROR;
80 // Try IANA to pick up 'windows-12xx' and other names
81 // which are not preferred MIME names but are widely used.
82 standardName = ucnv_getStandardName(name, "IANA", &error);
83 if (!U_SUCCESS(error) || !standardName)
84 continue;
85 }
86
87 // A number of these aliases are handled in Chrome's copy of ICU, but
88 // Chromium can be compiled with the system ICU.
89
90 // 1. Treat GB2312 encoding as GBK (its more modern superset), to match other browsers.
91 // 2. On the Web, GB2312 is encoded as EUC-CN or HZ, while ICU provides a native encoding
92 // for encoding GB_2312-80 and several others. So, we need to override this behavior, too.
93 if (!strcmp(standardName, "GB2312") || !strcmp(standardName, "GB_2312-80"))
94 standardName = "GBK";
95 // Similarly, EUC-KR encodings all map to an extended version, but
96 // per HTML5, the canonical name still should be EUC-KR.
97 else if (!strcmp(standardName, "EUC-KR") || !strcmp(standardName, "KSC_5601") || !strcmp(standardName, "cp1363"))
98 standardName = "EUC-KR";
99 // And so on.
100 else if (!strcasecmp(standardName, "iso-8859-9")) // This name is returned in different case by ICU 3.2 and 3.6.
101 standardName = "windows-1254";
102 else if (!strcmp(standardName, "TIS-620"))
103 standardName = "windows-874";
104
105 registrar(standardName, standardName);
106
107 uint16_t numAliases = ucnv_countAliases(name, &error);
108 ASSERT(U_SUCCESS(error));
109 if (U_SUCCESS(error))
110 for (uint16_t j = 0; j < numAliases; ++j) {
111 error = U_ZERO_ERROR;
112 const char* alias = ucnv_getAlias(name, j, &error);
113 ASSERT(U_SUCCESS(error));
114 if (U_SUCCESS(error) && alias != standardName)
115 registrar(alias, standardName);
116 }
117 }
118
119 // Additional aliases.
120 // These are present in modern versions of ICU, but not in ICU 3.2 (shipped with Mac OS X 10.4).
121 registrar("macroman", "macintosh");
122 registrar("maccyrillic", "x-mac-cyrillic");
123
124 // Additional aliases that historically were present in the encoding
125 // table in WebKit on Macintosh that don't seem to be present in ICU.
126 // Perhaps we can prove these are not used on the web and remove them.
127 // Or perhaps we can get them added to ICU.
128 registrar("x-mac-roman", "macintosh");
129 registrar("x-mac-ukrainian", "x-mac-cyrillic");
130 registrar("cn-big5", "Big5");
131 registrar("x-x-big5", "Big5");
132 registrar("cn-gb", "GBK");
133 registrar("csgb231280", "GBK");
134 registrar("x-euc-cn", "GBK");
135 registrar("x-gbk", "GBK");
136 registrar("csISO88598I", "ISO-8859-8-I");
137 registrar("koi", "KOI8-R");
138 registrar("logical", "ISO-8859-8-I");
139 registrar("visual", "ISO-8859-8");
140 registrar("winarabic", "windows-1256");
141 registrar("winbaltic", "windows-1257");
142 registrar("wincyrillic", "windows-1251");
143 registrar("iso-8859-11", "windows-874");
144 registrar("iso8859-11", "windows-874");
145 registrar("dos-874", "windows-874");
146 registrar("wingreek", "windows-1253");
147 registrar("winhebrew", "windows-1255");
148 registrar("winlatin2", "windows-1250");
149 registrar("winturkish", "windows-1254");
150 registrar("winvietnamese", "windows-1258");
151 registrar("x-cp1250", "windows-1250");
152 registrar("x-cp1251", "windows-1251");
153 registrar("x-euc", "EUC-JP");
154 registrar("x-windows-949", "EUC-KR");
155 registrar("KSC5601", "EUC-KR");
156 registrar("x-uhc", "EUC-KR");
157 registrar("shift-jis", "Shift_JIS");
158
159 // These aliases are present in modern versions of ICU, but use different codecs, and have no standard names.
160 // They are not present in ICU 3.2.
161 registrar("dos-720", "cp864");
162 registrar("jis7", "ISO-2022-JP");
163
164 // Alternative spelling of ISO encoding names.
165 registrar("ISO8859-1", "ISO-8859-1");
166 registrar("ISO8859-2", "ISO-8859-2");
167 registrar("ISO8859-3", "ISO-8859-3");
168 registrar("ISO8859-4", "ISO-8859-4");
169 registrar("ISO8859-5", "ISO-8859-5");
170 registrar("ISO8859-6", "ISO-8859-6");
171 registrar("ISO8859-7", "ISO-8859-7");
172 registrar("ISO8859-8", "ISO-8859-8");
173 registrar("ISO8859-8-I", "ISO-8859-8-I");
174 registrar("ISO8859-9", "ISO-8859-9");
175 registrar("ISO8859-10", "ISO-8859-10");
176 registrar("ISO8859-13", "ISO-8859-13");
177 registrar("ISO8859-14", "ISO-8859-14");
178 registrar("ISO8859-15", "ISO-8859-15");
179 // Not registering ISO8859-16, because Firefox (as of version 3.6.6) doesn't know this particular alias,
180 // and because older versions of ICU don't support ISO-8859-16 encoding at all.
181
182 // Additional aliases present in the WHATWG Encoding Standard (http://encoding.spec.whatwg.org/)
183 // and Firefox (24), but not in ICU 4.6.
184 registrar("csiso58gb231280", "GBK");
185 registrar("csiso88596e", "ISO-8859-6");
186 registrar("csiso88596i", "ISO-8859-6");
187 registrar("csiso88598e", "ISO-8859-8");
188 registrar("gb_2312", "GBK");
189 registrar("iso88591", "windows-1252");
190 registrar("iso88592", "ISO-8859-2");
191 registrar("iso88593", "ISO-8859-3");
192 registrar("iso88594", "ISO-8859-4");
193 registrar("iso88595", "ISO-8859-5");
194 registrar("iso88596", "ISO-8859-6");
195 registrar("iso88597", "ISO-8859-7");
196 registrar("iso88598", "ISO-8859-8");
197 registrar("iso88599", "windows-1254");
198 registrar("iso885910", "ISO-8859-10");
199 registrar("iso885911", "windows-874");
200 registrar("iso885913", "ISO-8859-13");
201 registrar("iso885914", "ISO-8859-14");
202 registrar("iso885915", "ISO-8859-15");
203 registrar("iso_8859-1", "windows-1252");
204 registrar("iso_8859-2", "ISO-8859-2");
205 registrar("iso_8859-3", "ISO-8859-3");
206 registrar("iso_8859-4", "ISO-8859-4");
207 registrar("iso_8859-5", "ISO-8859-5");
208 registrar("iso_8859-6", "ISO-8859-6");
209 registrar("iso_8859-7", "ISO-8859-7");
210 registrar("iso_8859-8", "ISO-8859-8");
211 registrar("iso_8859-9", "windows-1254");
212 registrar("iso_8859-15", "ISO-8859-15");
213 registrar("koi8_r", "KOI8-R");
214 registrar("x-cp1252", "windows-1252");
215 registrar("x-cp1253", "windows-1253");
216 registrar("x-cp1254", "windows-1254");
217 registrar("x-cp1255", "windows-1255");
218 registrar("x-cp1256", "windows-1256");
219 registrar("x-cp1257", "windows-1257");
220 registrar("x-cp1258", "windows-1258");
221 }
222
registerCodecs(TextCodecRegistrar registrar)223 void TextCodecICU::registerCodecs(TextCodecRegistrar registrar)
224 {
225 // See comment above in registerEncodingNames.
226 registrar("ISO-8859-8-I", create, 0);
227
228 int32_t numEncodings = ucnv_countAvailable();
229 for (int32_t i = 0; i < numEncodings; ++i) {
230 const char* name = ucnv_getAvailableName(i);
231 UErrorCode error = U_ZERO_ERROR;
232 const char* standardName = ucnv_getStandardName(name, "MIME", &error);
233 if (!U_SUCCESS(error) || !standardName) {
234 error = U_ZERO_ERROR;
235 standardName = ucnv_getStandardName(name, "IANA", &error);
236 if (!U_SUCCESS(error) || !standardName)
237 continue;
238 }
239 registrar(standardName, create, 0);
240 }
241 }
242
TextCodecICU(const TextEncoding & encoding)243 TextCodecICU::TextCodecICU(const TextEncoding& encoding)
244 : m_encoding(encoding)
245 , m_converterICU(0)
246 , m_needsGBKFallbacks(false)
247 {
248 }
249
~TextCodecICU()250 TextCodecICU::~TextCodecICU()
251 {
252 releaseICUConverter();
253 }
254
releaseICUConverter() const255 void TextCodecICU::releaseICUConverter() const
256 {
257 if (m_converterICU) {
258 UConverter*& cachedConverter = cachedConverterICU();
259 if (cachedConverter)
260 ucnv_close(cachedConverter);
261 cachedConverter = m_converterICU;
262 m_converterICU = 0;
263 }
264 }
265
createICUConverter() const266 void TextCodecICU::createICUConverter() const
267 {
268 ASSERT(!m_converterICU);
269
270 const char* name = m_encoding.name();
271 m_needsGBKFallbacks = name[0] == 'G' && name[1] == 'B' && name[2] == 'K' && !name[3];
272
273 UErrorCode err;
274
275 UConverter*& cachedConverter = cachedConverterICU();
276 if (cachedConverter) {
277 err = U_ZERO_ERROR;
278 const char* cachedName = ucnv_getName(cachedConverter, &err);
279 if (U_SUCCESS(err) && m_encoding == cachedName) {
280 m_converterICU = cachedConverter;
281 cachedConverter = 0;
282 return;
283 }
284 }
285
286 err = U_ZERO_ERROR;
287 m_converterICU = ucnv_open(m_encoding.name(), &err);
288 #if !LOG_DISABLED
289 if (err == U_AMBIGUOUS_ALIAS_WARNING)
290 WTF_LOG_ERROR("ICU ambiguous alias warning for encoding: %s", m_encoding.name());
291 #endif
292 if (m_converterICU)
293 ucnv_setFallback(m_converterICU, TRUE);
294 }
295
decodeToBuffer(UChar * target,UChar * targetLimit,const char * & source,const char * sourceLimit,int32_t * offsets,bool flush,UErrorCode & err)296 int TextCodecICU::decodeToBuffer(UChar* target, UChar* targetLimit, const char*& source, const char* sourceLimit, int32_t* offsets, bool flush, UErrorCode& err)
297 {
298 UChar* targetStart = target;
299 err = U_ZERO_ERROR;
300 ucnv_toUnicode(m_converterICU, &target, targetLimit, &source, sourceLimit, offsets, flush, &err);
301 return target - targetStart;
302 }
303
304 class ErrorCallbackSetter {
305 public:
ErrorCallbackSetter(UConverter * converter,bool stopOnError)306 ErrorCallbackSetter(UConverter* converter, bool stopOnError)
307 : m_converter(converter)
308 , m_shouldStopOnEncodingErrors(stopOnError)
309 {
310 if (m_shouldStopOnEncodingErrors) {
311 UErrorCode err = U_ZERO_ERROR;
312 ucnv_setToUCallBack(m_converter, UCNV_TO_U_CALLBACK_SUBSTITUTE,
313 UCNV_SUB_STOP_ON_ILLEGAL, &m_savedAction,
314 &m_savedContext, &err);
315 ASSERT(err == U_ZERO_ERROR);
316 }
317 }
~ErrorCallbackSetter()318 ~ErrorCallbackSetter()
319 {
320 if (m_shouldStopOnEncodingErrors) {
321 UErrorCode err = U_ZERO_ERROR;
322 const void* oldContext;
323 UConverterToUCallback oldAction;
324 ucnv_setToUCallBack(m_converter, m_savedAction,
325 m_savedContext, &oldAction,
326 &oldContext, &err);
327 ASSERT(oldAction == UCNV_TO_U_CALLBACK_SUBSTITUTE);
328 ASSERT(!strcmp(static_cast<const char*>(oldContext), UCNV_SUB_STOP_ON_ILLEGAL));
329 ASSERT(err == U_ZERO_ERROR);
330 }
331 }
332
333 private:
334 UConverter* m_converter;
335 bool m_shouldStopOnEncodingErrors;
336 const void* m_savedContext;
337 UConverterToUCallback m_savedAction;
338 };
339
decode(const char * bytes,size_t length,bool flush,bool stopOnError,bool & sawError)340 String TextCodecICU::decode(const char* bytes, size_t length, bool flush, bool stopOnError, bool& sawError)
341 {
342 // Get a converter for the passed-in encoding.
343 if (!m_converterICU) {
344 createICUConverter();
345 ASSERT(m_converterICU);
346 if (!m_converterICU) {
347 WTF_LOG_ERROR("error creating ICU encoder even though encoding was in table");
348 return String();
349 }
350 }
351
352 ErrorCallbackSetter callbackSetter(m_converterICU, stopOnError);
353
354 StringBuilder result;
355
356 UChar buffer[ConversionBufferSize];
357 UChar* bufferLimit = buffer + ConversionBufferSize;
358 const char* source = reinterpret_cast<const char*>(bytes);
359 const char* sourceLimit = source + length;
360 int32_t* offsets = NULL;
361 UErrorCode err = U_ZERO_ERROR;
362
363 do {
364 int ucharsDecoded = decodeToBuffer(buffer, bufferLimit, source, sourceLimit, offsets, flush, err);
365 result.append(buffer, ucharsDecoded);
366 } while (err == U_BUFFER_OVERFLOW_ERROR);
367
368 if (U_FAILURE(err)) {
369 // flush the converter so it can be reused, and not be bothered by this error.
370 do {
371 decodeToBuffer(buffer, bufferLimit, source, sourceLimit, offsets, true, err);
372 } while (source < sourceLimit);
373 sawError = true;
374 }
375
376 String resultString = result.toString();
377
378 // <http://bugs.webkit.org/show_bug.cgi?id=17014>
379 // Simplified Chinese pages use the code A3A0 to mean "full-width space", but ICU decodes it as U+E5E5.
380 if (!strcmp(m_encoding.name(), "GBK") || !strcasecmp(m_encoding.name(), "gb18030"))
381 resultString.replace(0xE5E5, ideographicSpace);
382
383 return resultString;
384 }
385
386 // We need to apply these fallbacks ourselves as they are not currently supported by ICU and
387 // they were provided by the old TEC encoding path. Needed to fix <rdar://problem/4708689>.
fallbackForGBK(UChar32 character)388 static UChar fallbackForGBK(UChar32 character)
389 {
390 switch (character) {
391 case 0x01F9:
392 return 0xE7C8;
393 case 0x1E3F:
394 return 0xE7C7;
395 case 0x22EF:
396 return 0x2026;
397 case 0x301C:
398 return 0xFF5E;
399 }
400 return 0;
401 }
402
403 // Invalid character handler when writing escaped entities for unrepresentable
404 // characters. See the declaration of TextCodec::encode for more.
urlEscapedEntityCallback(const void * context,UConverterFromUnicodeArgs * fromUArgs,const UChar * codeUnits,int32_t length,UChar32 codePoint,UConverterCallbackReason reason,UErrorCode * err)405 static void urlEscapedEntityCallback(const void* context, UConverterFromUnicodeArgs* fromUArgs, const UChar* codeUnits, int32_t length,
406 UChar32 codePoint, UConverterCallbackReason reason, UErrorCode* err)
407 {
408 if (reason == UCNV_UNASSIGNED) {
409 *err = U_ZERO_ERROR;
410
411 UnencodableReplacementArray entity;
412 int entityLen = TextCodec::getUnencodableReplacement(codePoint, URLEncodedEntitiesForUnencodables, entity);
413 ucnv_cbFromUWriteBytes(fromUArgs, entity, entityLen, 0, err);
414 } else
415 UCNV_FROM_U_CALLBACK_ESCAPE(context, fromUArgs, codeUnits, length, codePoint, reason, err);
416 }
417
418 // Substitutes special GBK characters, escaping all other unassigned entities.
gbkCallbackEscape(const void * context,UConverterFromUnicodeArgs * fromUArgs,const UChar * codeUnits,int32_t length,UChar32 codePoint,UConverterCallbackReason reason,UErrorCode * err)419 static void gbkCallbackEscape(const void* context, UConverterFromUnicodeArgs* fromUArgs, const UChar* codeUnits, int32_t length,
420 UChar32 codePoint, UConverterCallbackReason reason, UErrorCode* err)
421 {
422 UChar outChar;
423 if (reason == UCNV_UNASSIGNED && (outChar = fallbackForGBK(codePoint))) {
424 const UChar* source = &outChar;
425 *err = U_ZERO_ERROR;
426 ucnv_cbFromUWriteUChars(fromUArgs, &source, source + 1, 0, err);
427 return;
428 }
429 UCNV_FROM_U_CALLBACK_ESCAPE(context, fromUArgs, codeUnits, length, codePoint, reason, err);
430 }
431
432 // Combines both gbkUrlEscapedEntityCallback and GBK character substitution.
gbkUrlEscapedEntityCallack(const void * context,UConverterFromUnicodeArgs * fromUArgs,const UChar * codeUnits,int32_t length,UChar32 codePoint,UConverterCallbackReason reason,UErrorCode * err)433 static void gbkUrlEscapedEntityCallack(const void* context, UConverterFromUnicodeArgs* fromUArgs, const UChar* codeUnits, int32_t length,
434 UChar32 codePoint, UConverterCallbackReason reason, UErrorCode* err)
435 {
436 if (reason == UCNV_UNASSIGNED) {
437 if (UChar outChar = fallbackForGBK(codePoint)) {
438 const UChar* source = &outChar;
439 *err = U_ZERO_ERROR;
440 ucnv_cbFromUWriteUChars(fromUArgs, &source, source + 1, 0, err);
441 return;
442 }
443 urlEscapedEntityCallback(context, fromUArgs, codeUnits, length, codePoint, reason, err);
444 return;
445 }
446 UCNV_FROM_U_CALLBACK_ESCAPE(context, fromUArgs, codeUnits, length, codePoint, reason, err);
447 }
448
gbkCallbackSubstitute(const void * context,UConverterFromUnicodeArgs * fromUArgs,const UChar * codeUnits,int32_t length,UChar32 codePoint,UConverterCallbackReason reason,UErrorCode * err)449 static void gbkCallbackSubstitute(const void* context, UConverterFromUnicodeArgs* fromUArgs, const UChar* codeUnits, int32_t length,
450 UChar32 codePoint, UConverterCallbackReason reason, UErrorCode* err)
451 {
452 UChar outChar;
453 if (reason == UCNV_UNASSIGNED && (outChar = fallbackForGBK(codePoint))) {
454 const UChar* source = &outChar;
455 *err = U_ZERO_ERROR;
456 ucnv_cbFromUWriteUChars(fromUArgs, &source, source + 1, 0, err);
457 return;
458 }
459 UCNV_FROM_U_CALLBACK_SUBSTITUTE(context, fromUArgs, codeUnits, length, codePoint, reason, err);
460 }
461
462 class TextCodecInput {
463 public:
TextCodecInput(const TextEncoding & encoding,const UChar * characters,size_t length)464 TextCodecInput(const TextEncoding& encoding, const UChar* characters, size_t length)
465 : m_begin(characters)
466 , m_end(characters + length)
467 { }
468
TextCodecInput(const TextEncoding & encoding,const LChar * characters,size_t length)469 TextCodecInput(const TextEncoding& encoding, const LChar* characters, size_t length)
470 {
471 m_buffer.reserveInitialCapacity(length);
472 for (size_t i = 0; i < length; ++i)
473 m_buffer.append(characters[i]);
474 m_begin = m_buffer.data();
475 m_end = m_begin + m_buffer.size();
476 }
477
begin() const478 const UChar* begin() const { return m_begin; }
end() const479 const UChar* end() const { return m_end; }
480
481 private:
482 const UChar* m_begin;
483 const UChar* m_end;
484 Vector<UChar> m_buffer;
485 };
486
encodeInternal(const TextCodecInput & input,UnencodableHandling handling)487 CString TextCodecICU::encodeInternal(const TextCodecInput& input, UnencodableHandling handling)
488 {
489 const UChar* source = input.begin();
490 const UChar* end = input.end();
491
492 UErrorCode err = U_ZERO_ERROR;
493
494 switch (handling) {
495 case QuestionMarksForUnencodables:
496 ucnv_setSubstChars(m_converterICU, "?", 1, &err);
497 ucnv_setFromUCallBack(m_converterICU, m_needsGBKFallbacks ? gbkCallbackSubstitute : UCNV_FROM_U_CALLBACK_SUBSTITUTE, 0, 0, 0, &err);
498 break;
499 case EntitiesForUnencodables:
500 ucnv_setFromUCallBack(m_converterICU, m_needsGBKFallbacks ? gbkCallbackEscape : UCNV_FROM_U_CALLBACK_ESCAPE, UCNV_ESCAPE_XML_DEC, 0, 0, &err);
501 break;
502 case URLEncodedEntitiesForUnencodables:
503 ucnv_setFromUCallBack(m_converterICU, m_needsGBKFallbacks ? gbkUrlEscapedEntityCallack : urlEscapedEntityCallback, 0, 0, 0, &err);
504 break;
505 }
506
507 ASSERT(U_SUCCESS(err));
508 if (U_FAILURE(err))
509 return CString();
510
511 Vector<char> result;
512 size_t size = 0;
513 do {
514 char buffer[ConversionBufferSize];
515 char* target = buffer;
516 char* targetLimit = target + ConversionBufferSize;
517 err = U_ZERO_ERROR;
518 ucnv_fromUnicode(m_converterICU, &target, targetLimit, &source, end, 0, true, &err);
519 size_t count = target - buffer;
520 result.grow(size + count);
521 memcpy(result.data() + size, buffer, count);
522 size += count;
523 } while (err == U_BUFFER_OVERFLOW_ERROR);
524
525 return CString(result.data(), size);
526 }
527
528 template<typename CharType>
encodeCommon(const CharType * characters,size_t length,UnencodableHandling handling)529 CString TextCodecICU::encodeCommon(const CharType* characters, size_t length, UnencodableHandling handling)
530 {
531 if (!length)
532 return "";
533
534 if (!m_converterICU)
535 createICUConverter();
536 if (!m_converterICU)
537 return CString();
538
539 TextCodecInput input(m_encoding, characters, length);
540 return encodeInternal(input, handling);
541 }
542
encode(const UChar * characters,size_t length,UnencodableHandling handling)543 CString TextCodecICU::encode(const UChar* characters, size_t length, UnencodableHandling handling)
544 {
545 return encodeCommon(characters, length, handling);
546 }
547
encode(const LChar * characters,size_t length,UnencodableHandling handling)548 CString TextCodecICU::encode(const LChar* characters, size_t length, UnencodableHandling handling)
549 {
550 return encodeCommon(characters, length, handling);
551 }
552
553 } // namespace WTF
554