Reviewed by Eric.
[WebKit-https.git] / WebCore / loader / Decoder.cpp
1 /*
2     This file is part of the KDE libraries
3
4     Copyright (C) 1999 Lars Knoll (knoll@mpi-hd.mpg.de)
5     Copyright (C) 2003, 2004, 2005, 2006 Apple Computer, Inc.
6     Copyright (C) 2005, 2006 Alexey Proskuryakov (ap@nypop.com)
7
8     This library is free software; you can redistribute it and/or
9     modify it under the terms of the GNU Library General Public
10     License as published by the Free Software Foundation; either
11     version 2 of the License, or (at your option) any later version.
12
13     This library is distributed in the hope that it will be useful,
14     but WITHOUT ANY WARRANTY; without even the implied warranty of
15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16     Library General Public License for more details.
17
18     You should have received a copy of the GNU Library General Public License
19     along with this library; see the file COPYING.LIB.  If not, write to
20     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21     Boston, MA 02111-1307, USA.
22 */
23
24
25 #include "config.h"
26 #include "Decoder.h"
27
28 #include "DOMImplementation.h"
29 #include "HTMLNames.h"
30 #include "StreamingTextDecoder.h"
31 #include "RegularExpression.h"
32
33 using namespace WebCore;
34 using namespace HTMLNames;
35
36 class KanjiCode
37 {
38 public:
39     enum Type { ASCII, JIS, EUC, SJIS, UTF16, UTF8 };
40     static enum Type judge(const char *str, int length);
41     static const int ESC;
42     static const int _SS2_;
43     static const unsigned char kanji_map_sjis[];
44     static int ISkanji(int code)
45     {
46         if (code >= 0x100)
47                     return 0;
48         return (kanji_map_sjis[code & 0xff] & 1);
49     }
50
51     static int ISkana(int code)
52     {
53         if (code >= 0x100)
54                     return 0;
55         return (kanji_map_sjis[code & 0xff] & 2);
56     }
57
58 };
59
60 const int KanjiCode::ESC = 0x1b;
61 const int KanjiCode::_SS2_ = 0x8e;
62
63 const unsigned char KanjiCode::kanji_map_sjis[] =
64 {
65     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
66     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
67     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
68     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
69     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
70     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
71     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
72     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
73     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
74     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
75     0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
76     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
77     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
78     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
79     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
80     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0
81 };
82
83 /*
84  * EUC-JP is
85  *     [0xa1 - 0xfe][0xa1 - 0xfe]
86  *     0x8e[0xa1 - 0xfe](SS2)
87  *     0x8f[0xa1 - 0xfe][0xa1 - 0xfe](SS3)
88  *
89  * Shift_Jis is
90  *     [0x81 - 0x9f, 0xe0 - 0xef(0xfe?)][0x40 - 0x7e, 0x80 - 0xfc]
91  *
92  * Shift_Jis Hankaku Kana is
93  *     [0xa1 - 0xdf]
94  */
95
96 /*
97  * KanjiCode::judge() is based on judge_jcode() from jvim
98  *     http://hp.vector.co.jp/authors/VA003457/vim/
99  *
100  * Special Thanks to Kenichi Tsuchida
101  */
102
103 enum KanjiCode::Type KanjiCode::judge(const char *str, int size)
104 {
105     enum Type code;
106     int i;
107     int bfr = false;            /* Kana Moji */
108     int bfk = 0;                /* EUC Kana */
109     int sjis = 0;
110     int euc = 0;
111
112     const unsigned char *ptr = (const unsigned char *) str;
113
114     code = ASCII;
115
116     i = 0;
117     while (i < size) {
118         if (ptr[i] == ESC && (size - i >= 3)) {
119             if ((ptr[i + 1] == '$' && ptr[i + 2] == 'B')
120             || (ptr[i + 1] == '(' && ptr[i + 2] == 'B')) {
121                 code = JIS;
122                 goto breakBreak;
123             } else if ((ptr[i + 1] == '$' && ptr[i + 2] == '@')
124                     || (ptr[i + 1] == '(' && ptr[i + 2] == 'J')) {
125                 code = JIS;
126                 goto breakBreak;
127             } else if (ptr[i + 1] == '(' && ptr[i + 2] == 'I') {
128                 code = JIS;
129                 i += 3;
130             } else if (ptr[i + 1] == ')' && ptr[i + 2] == 'I') {
131                 code = JIS;
132                 i += 3;
133             } else {
134                 i++;
135             }
136             bfr = false;
137             bfk = 0;
138         } else {
139             if (ptr[i] < 0x20) {
140                 bfr = false;
141                 bfk = 0;
142                 /* ?? check kudokuten ?? && ?? hiragana ?? */
143                 if ((i >= 2) && (ptr[i - 2] == 0x81)
144                         && (0x41 <= ptr[i - 1] && ptr[i - 1] <= 0x49)) {
145                     code = SJIS;
146                     sjis += 100;        /* kudokuten */
147                 } else if ((i >= 2) && (ptr[i - 2] == 0xa1)
148                         && (0xa2 <= ptr[i - 1] && ptr[i - 1] <= 0xaa)) {
149                     code = EUC;
150                     euc += 100;         /* kudokuten */
151                 } else if ((i >= 2) && (ptr[i - 2] == 0x82) && (0xa0 <= ptr[i - 1])) {
152                     sjis += 40;         /* hiragana */
153                 } else if ((i >= 2) && (ptr[i - 2] == 0xa4) && (0xa0 <= ptr[i - 1])) {
154                     euc += 40;          /* hiragana */
155                 }
156             } else {
157                 /* ?? check hiragana or katana ?? */
158                 if ((size - i > 1) && (ptr[i] == 0x82) && (0xa0 <= ptr[i + 1])) {
159                     sjis++;     /* hiragana */
160                 } else if ((size - i > 1) && (ptr[i] == 0x83)
161                          && (0x40 <= ptr[i + 1] && ptr[i + 1] <= 0x9f)) {
162                     sjis++;     /* katakana */
163                 } else if ((size - i > 1) && (ptr[i] == 0xa4) && (0xa0 <= ptr[i + 1])) {
164                     euc++;      /* hiragana */
165                 } else if ((size - i > 1) && (ptr[i] == 0xa5) && (0xa0 <= ptr[i + 1])) {
166                     euc++;      /* katakana */
167                 }
168                 if (bfr) {
169                     if ((i >= 1) && (0x40 <= ptr[i] && ptr[i] <= 0xa0) && ISkanji(ptr[i - 1])) {
170                         code = SJIS;
171                         goto breakBreak;
172                     } else if ((i >= 1) && (0x81 <= ptr[i - 1] && ptr[i - 1] <= 0x9f) && ((0x40 <= ptr[i] && ptr[i] < 0x7e) || (0x7e < ptr[i] && ptr[i] <= 0xfc))) {
173                         code = SJIS;
174                         goto breakBreak;
175                     } else if ((i >= 1) && (0xfd <= ptr[i] && ptr[i] <= 0xfe) && (0xa1 <= ptr[i - 1] && ptr[i - 1] <= 0xfe)) {
176                         code = EUC;
177                         goto breakBreak;
178                     } else if ((i >= 1) && (0xfd <= ptr[i - 1] && ptr[i - 1] <= 0xfe) && (0xa1 <= ptr[i] && ptr[i] <= 0xfe)) {
179                         code = EUC;
180                         goto breakBreak;
181                     } else if ((i >= 1) && (ptr[i] < 0xa0 || 0xdf < ptr[i]) && (0x8e == ptr[i - 1])) {
182                         code = SJIS;
183                         goto breakBreak;
184                     } else if (ptr[i] <= 0x7f) {
185                         code = SJIS;
186                         goto breakBreak;
187                     } else {
188                         if (0xa1 <= ptr[i] && ptr[i] <= 0xa6) {
189                             euc++;      /* sjis hankaku kana kigo */
190                         } else if (0xa1 <= ptr[i] && ptr[i] <= 0xdf) {
191                             ;           /* sjis hankaku kana */
192                         } else if (0xa1 <= ptr[i] && ptr[i] <= 0xfe) {
193                             euc++;
194                         } else if (0x8e == ptr[i]) {
195                             euc++;
196                         } else if (0x20 <= ptr[i] && ptr[i] <= 0x7f) {
197                             sjis++;
198                         }
199                         bfr = false;
200                         bfk = 0;
201                     }
202                 } else if (0x8e == ptr[i]) {
203                     if (size - i <= 1) {
204                         ;
205                     } else if (0xa1 <= ptr[i + 1] && ptr[i + 1] <= 0xdf) {
206                         /* EUC KANA or SJIS KANJI */
207                         if (bfk == 1) {
208                             euc += 100;
209                         }
210                         bfk++;
211                         i++;
212                     } else {
213                         /* SJIS only */
214                         code = SJIS;
215                         goto breakBreak;
216                     }
217                 } else if (0x81 <= ptr[i] && ptr[i] <= 0x9f) {
218                     /* SJIS only */
219                     code = SJIS;
220                     if ((size - i >= 1)
221                             && ((0x40 <= ptr[i + 1] && ptr[i + 1] <= 0x7e)
222                             || (0x80 <= ptr[i + 1] && ptr[i + 1] <= 0xfc))) {
223                         goto breakBreak;
224                     }
225                 } else if (0xfd <= ptr[i] && ptr[i] <= 0xfe) {
226                     /* EUC only */
227                     code = EUC;
228                     if ((size - i >= 1)
229                             && (0xa1 <= ptr[i + 1] && ptr[i + 1] <= 0xfe)) {
230                         goto breakBreak;
231                     }
232                 } else if (ptr[i] <= 0x7f) {
233                     ;
234                 } else {
235                     bfr = true;
236                     bfk = 0;
237                 }
238             }
239             i++;
240         }
241     }
242     if (code == ASCII) {
243         if (sjis > euc) {
244             code = SJIS;
245         } else if (sjis < euc) {
246             code = EUC;
247         }
248     }
249 breakBreak:
250     return (code);
251 }
252
253 Decoder::Decoder(const String& mimeType, const String& defaultEncodingName)
254   : m_encoding(defaultEncodingName.isNull() ? "iso8859-1" : defaultEncodingName.ascii().data())
255   , m_encodingName(defaultEncodingName.isNull() ? "iso8859-1" : defaultEncodingName.ascii().data())
256   , m_type(DefaultEncoding)
257   , m_reachedBody(false)
258   , m_checkedForCSSCharset(false)
259   , m_checkedForBOM(false)
260 {
261     if (mimeType == "text/css")
262         m_contentType = CSS;
263     else if (mimeType == "text/html")
264         m_contentType = HTML;
265     else if (DOMImplementation::isXMLMIMEType(mimeType)) {
266         m_contentType = XML;
267         // Despite 8.5 "Text/xml with Omitted Charset" of RFC 3023, we do not assume us-ascii 
268         // for text/xml, to match Firefox.
269         m_encoding = TextEncoding(UTF8Encoding);
270         m_encodingName = "UTF-8";
271     } else
272         m_contentType = PlainText;
273
274     m_decoder.set(StreamingTextDecoder::create(m_encoding));
275 }
276
277 Decoder::~Decoder()
278 {
279 }
280
281 void Decoder::setEncodingName(const char* encodingName, EncodingSource type)
282 {
283     m_encodingName = encodingName;
284     m_encodingName = m_encodingName.lower();
285
286     if (m_encodingName.isEmpty())
287         return;
288
289     bool eightBitOnly = type == EncodingFromMetaTag || type == EncodingFromXMLHeader || type == EncodingFromCSSCharset;
290     TextEncoding encoding = TextEncoding(m_encodingName, eightBitOnly);
291
292     // in case the encoding didn't exist, we keep the old one (fixes some sites specifying invalid encodings)
293     if (encoding.isValid()) {
294         m_encodingName = encoding.name();
295         m_encoding = encoding;
296         m_type = type;
297         m_decoder.set(StreamingTextDecoder::create(m_encoding));
298     }
299 }
300
301 const char* Decoder::encodingName() const
302 {
303     return m_encodingName;
304 }
305
306 // Other browsers allow comments in the head section, so we need to also.
307 // It's important not to look for tags inside the comments.
308 static void skipComment(const char *&ptr, const char *pEnd)
309 {
310     const char *p = ptr;
311     // Allow <!-->; other browsers do.
312     if (*p == '>') {
313         p++;
314     } else {
315         while (p != pEnd) {
316             if (*p == '-') {
317                 // This is the real end of comment, "-->".
318                 if (p[1] == '-' && p[2] == '>') {
319                     p += 3;
320                     break;
321                 }
322                 // This is the incorrect end of comment that other browsers allow, "--!>".
323                 if (p[1] == '-' && p[2] == '!' && p[3] == '>') {
324                     p += 4;
325                     break;
326                 }
327             }
328             p++;
329         }
330     }
331     ptr = p;
332 }
333
334 // Returns the position of the encoding string.
335 static int findXMLEncoding(const DeprecatedCString &str, int &encodingLength)
336 {
337     int len = str.length();
338
339     int pos = str.find("encoding");
340     if (pos == -1)
341         return -1;
342     pos += 8;
343     
344     // Skip spaces and stray control characters.
345     while (str[pos] <= ' ' && pos != len)
346         ++pos;
347
348     // Skip equals sign.
349     if (str[pos] != '=')
350         return -1;
351     ++pos;
352
353     // Skip spaces and stray control characters.
354     while (str[pos] <= ' ' && pos != len)
355         ++pos;
356
357     // Skip quotation mark.
358     char quoteMark = str[pos];
359     if (quoteMark != '"' && quoteMark != '\'')
360         return -1;
361     ++pos;
362
363     // Find the trailing quotation mark.
364     int end = pos;
365     while (str[end] != quoteMark)
366         ++end;
367
368     if (end == len)
369         return -1;
370     
371     encodingLength = end - pos;
372     return pos;
373 }
374
375 // true if there is more to parse
376 static inline bool skipWhitespace(const char*& pos, const char* dataEnd)
377 {
378     while (pos < dataEnd && (*pos == '\t' || *pos == ' '))
379         ++pos;
380     return pos != dataEnd;
381 }
382
383 DeprecatedString Decoder::decode(const char *data, int len)
384 {
385     // Check for UTF-16 or UTF-8 BOM mark at the beginning, which is a sure sign of a Unicode encoding.
386     int bufferLength = m_buffer.length();
387     const int maximumBOMLength = 3;
388     if (!m_checkedForBOM && bufferLength + len >= maximumBOMLength) {
389         if (m_type != UserChosenEncoding) {
390             // Extract the first three bytes.
391             // Handle the case where some of bytes are already in the buffer.
392             // The last byte is always guaranteed to not be in the buffer.
393             const unsigned char *udata = (const unsigned char *)data;
394             unsigned char c1 = bufferLength >= 1 ? m_buffer[0].unicode() : *udata++;
395             unsigned char c2 = bufferLength >= 2 ? m_buffer[1].unicode() : *udata++;
396             ASSERT(bufferLength < 3);
397             unsigned char c3 = *udata;
398
399             // Check for the BOM.
400             const char *autoDetectedEncoding;
401             if ((c1 == 0xFE && c2 == 0xFF) || (c1 == 0xFF && c2 == 0xFE)) {
402                 autoDetectedEncoding = "ISO-10646-UCS-2";
403             } else if (c1 == 0xEF && c2 == 0xBB && c3 == 0xBF) {
404                 autoDetectedEncoding = "UTF-8";
405             } else {
406                 autoDetectedEncoding = 0;
407             }
408
409             // If we found a BOM, use the encoding it implies.
410             if (autoDetectedEncoding != 0) {
411                 m_type = AutoDetectedEncoding;
412                 m_encoding = TextEncoding(autoDetectedEncoding);
413                 ASSERT(m_encoding.isValid());
414                 m_encodingName = m_encoding.name();
415                 m_decoder.set(StreamingTextDecoder::create(m_encoding));
416             }
417         }
418         m_checkedForBOM = true;
419     }
420     
421     bool currentChunkInBuffer = false;
422     
423     if (m_type == DefaultEncoding && m_contentType == CSS && !m_checkedForCSSCharset) {
424         m_buffer.append(data, len);
425         currentChunkInBuffer = true;
426
427         if (len > 8) { // strlen("@charset") == 8
428             const char* dataStart = m_buffer.latin1();
429             const char* dataEnd = dataStart + m_buffer.length();
430
431             if (dataStart[0] == '@' && dataStart[1] == 'c' && dataStart[2] == 'h' && dataStart[3] == 'a' && dataStart[4] == 'r' && 
432                 dataStart[5] == 's' && dataStart[6] == 'e' && dataStart[7] == 't') {
433         
434                 dataStart += 8;
435                 const char* pos = dataStart;
436                 if (!skipWhitespace(pos, dataEnd))
437                     return DeprecatedString::null;
438
439                 if (*pos == '"' || *pos == '\'') {
440                     char quotationMark = *pos;
441                     ++pos;
442                     dataStart = pos;
443                 
444                     while (pos < dataEnd && *pos != quotationMark)
445                         ++pos;
446                     if (pos == dataEnd)
447                         return DeprecatedString::null;
448
449                     DeprecatedCString encodingName(dataStart, pos - dataStart + 1);
450                     
451                     ++pos;
452                     if (!skipWhitespace(pos, dataEnd))
453                         return DeprecatedString::null;
454
455                     if (*pos == ';')
456                         setEncodingName(encodingName, EncodingFromCSSCharset);
457                 }
458             }
459             m_checkedForCSSCharset = true;
460         }
461         return DeprecatedString::null;
462
463     } else if (m_type == DefaultEncoding && m_contentType != PlainText && !m_reachedBody) { // HTML and XML
464         // this is not completely efficient, since the function might go
465         // through the html head several times...
466     
467         m_buffer.append(data, len);
468         currentChunkInBuffer = true;
469         
470         // we still don't have an encoding, and are in the head
471         // the following tags are allowed in <head>:
472         // SCRIPT|STYLE|META|LINK|OBJECT|TITLE|BASE
473         
474         // We stop scanning when a tag that is not permitted in <head>
475         // is seen, rather when </head> is seen, because that more closely
476         // matches behavior in other browsers; more details in
477         // <http://bugzilla.opendarwin.org/show_bug.cgi?id=3590>.
478         
479         // Additionally, we ignore things that looks like tags in <title>; see
480         // <http://bugzilla.opendarwin.org/show_bug.cgi?id=4560>.
481         
482         bool withinTitle = false;
483
484         const char *ptr = m_buffer.latin1();
485         const char *pEnd = ptr + m_buffer.length();
486         while (ptr != pEnd) {
487             if (*ptr == '<') {
488                 bool end = false;
489                 ptr++;
490
491                 // Handle comments.
492                 if (ptr[0] == '!' && ptr[1] == '-' && ptr[2] == '-') {
493                     ptr += 3;
494                     skipComment(ptr, pEnd);
495                     continue;
496                 }
497                 
498                 // Handle XML declaration, which can have encoding in it.
499                 // This encoding is honored even for HTML documents.
500                 if (ptr[0] == '?' && ptr[1] == 'x' && ptr[2] == 'm' && ptr[3] == 'l') {
501                     const char *end = ptr;
502                     while (*end != '>' && *end != '\0')
503                         end++;
504                     if (*end == '\0')
505                         break;
506                     DeprecatedCString str(ptr, end - ptr);
507                     int len;
508                     int pos = findXMLEncoding(str, len);
509                     if (pos != -1)
510                         setEncodingName(str.mid(pos, len), EncodingFromXMLHeader);
511                     // continue looking for a charset - it may be specified in an HTTP-Equiv meta
512                 } else if (ptr[0] == 0 && ptr[1] == '?' && ptr[2] == 0 && ptr[3] == 'x' && ptr[4] == 0 && ptr[5] == 'm' && ptr[6] == 0 && ptr[7] == 'l') {
513                     // UTF-16 without BOM
514                     setEncodingName(((ptr - m_buffer.latin1()) % 2) ? "UTF-16LE" : "UTF-16BE", AutoDetectedEncoding);
515                     goto found;
516                 }
517                 
518                 // the HTTP-EQUIV meta has no effect on XHTML
519                 if (m_contentType == XML)
520                     goto found;
521
522                 if (*ptr == '/') {
523                     ++ptr;
524                     end=true;
525                 }
526
527                 char tmp[20];
528                 int len = 0;
529                 while (
530                     ((*ptr >= 'a') && (*ptr <= 'z') ||
531                      (*ptr >= 'A') && (*ptr <= 'Z') ||
532                      (*ptr >= '0') && (*ptr <= '9'))
533                     && len < 19 )
534                 {
535                     tmp[len] = tolower(*ptr);
536                     ptr++;
537                     len++;
538                 }
539                 tmp[len] = 0;
540                 AtomicString tag(tmp);
541                 
542                 if (tag == titleTag)
543                     withinTitle = !end;
544                 
545                 if (!end && tag == metaTag) {
546                     const char* end = ptr;
547                     while (*end != '>' && *end != '\0')
548                         end++;
549                     if (*end == '\0')
550                         break;
551                     DeprecatedCString str(ptr, (end-ptr)+1);
552                     str = str.lower();
553                     int pos = 0;
554                     while (pos < (int)str.length()) {
555                         if ((pos = str.find("charset", pos, false)) == -1)
556                             break;
557                         pos += 7;
558                         // skip whitespace..
559                         while (pos < (int)str.length() && str[pos] <= ' ')
560                             pos++;
561                         if (pos == (int)str.length())
562                             break;
563                         if (str[pos++] != '=')
564                             continue;
565                         while (pos < (int)str.length() &&
566                                 (str[pos] <= ' ') || str[pos] == '=' || str[pos] == '"' || str[pos] == '\'')
567                             pos++;
568
569                         // end ?
570                         if (pos == (int)str.length())
571                             break;
572                         unsigned endpos = pos;
573                         while (endpos < str.length() &&
574                                str[endpos] != ' ' && str[endpos] != '"' && str[endpos] != '\'' &&
575                                str[endpos] != ';' && str[endpos] != '>')
576                             endpos++;
577                         setEncodingName(str.mid(pos, endpos-pos), EncodingFromMetaTag);
578                         if (m_type == EncodingFromMetaTag)
579                             goto found;
580
581                         if (endpos >= str.length() || str[endpos] == '/' || str[endpos] == '>')
582                             break;
583
584                         pos = endpos + 1;
585                     }
586                 } else if (tag != scriptTag && tag != noscriptTag && tag != styleTag &&
587                            tag != linkTag && tag != metaTag && tag != objectTag &&
588                            tag != titleTag && tag != baseTag && 
589                            (end || tag != htmlTag) && !withinTitle &&
590                            (tag != headTag) && isalpha(tmp[0])) {
591                     m_reachedBody = true;
592                     goto found;
593                 }
594             }
595             else
596                 ptr++;
597         }
598         return DeprecatedString::null;
599     }
600
601  found:
602     // Do the auto-detect if our default encoding is one of the Japanese ones.
603     if (m_type != UserChosenEncoding && m_type != AutoDetectedEncoding && m_encoding.isJapanese()) {
604         const char *autoDetectedEncoding;
605         switch (KanjiCode::judge(data, len)) {
606             case KanjiCode::JIS:
607                 autoDetectedEncoding = "jis7";
608                 break;
609             case KanjiCode::EUC:
610                 autoDetectedEncoding = "eucjp";
611                 break;
612             case KanjiCode::SJIS:
613                 autoDetectedEncoding = "sjis";
614                 break;
615             default:
616                 autoDetectedEncoding = NULL;
617                 break;
618         }
619         if (autoDetectedEncoding)
620             setEncodingName(autoDetectedEncoding, AutoDetectedEncoding);
621     }
622
623     // If we still haven't found an encoding, assume latin1
624     // (this can happen if an empty name is passed from outside).
625     if (m_encodingName.isEmpty() || !m_encoding.isValid()) {
626         m_encodingName = "iso8859-1";
627         m_encoding = TextEncoding(Latin1Encoding);
628     }
629     m_decoder.set(StreamingTextDecoder::create(m_encoding));
630
631     DeprecatedString out;
632
633     if (!m_buffer.isEmpty()) {
634         if (!currentChunkInBuffer)
635             m_buffer.append(data, len);
636         out = m_decoder->toUnicode(m_buffer.latin1(), m_buffer.length());
637         m_buffer.truncate(0);
638     } else
639         out = m_decoder->toUnicode(data, len);
640
641     return out;
642 }
643
644 DeprecatedString Decoder::flush() const
645 {
646     return m_decoder->toUnicode(m_buffer.latin1(), m_buffer.length(), true);
647 }
648
649 // -----------------------------------------------------------------------------