Move TextResourceDecoder from loader/ to fetch/

Source/core/fetch/TextResourceDecoder.cpp

 /*
     Copyright (C) 1999 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc. All rights reserved.
     Copyright (C) 2005, 2006, 2007 Alexey Proskuryakov (ap@nypop.com)
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 
 #include "config.h"
-#include "core/loader/TextResourceDecoder.h"
+#include "core/fetch/TextResourceDecoder.h"
 
 #include "HTMLNames.h"
 #include "core/dom/DOMImplementation.h"
 #include "core/html/parser/HTMLMetaCharsetParser.h"
 #include "core/platform/text/TextEncodingDetector.h"
 #include "wtf/StringExtras.h"
 #include "wtf/text/TextCodec.h"
 #include "wtf/text/TextEncoding.h"
 #include "wtf/text/TextEncodingRegistry.h"
 
@@ skipping 133 matching lines @@
     int euc = 0;
 
     const unsigned char* ptr = reinterpret_cast<const unsigned char*>(str);
 
     code = ASCII;
 
     i = 0;
     while (i < size) {
         if (ptr[i] == ESC && (size - i >= 3)) {
             if (bytesEqual(str + i + 1, '$', 'B')
-                    || bytesEqual(str + i + 1, '(', 'B')
-                    || bytesEqual(str + i + 1, '$', '@')
-                    || bytesEqual(str + i + 1, '(', 'J')) {
+                || bytesEqual(str + i + 1, '(', 'B')
+                || bytesEqual(str + i + 1, '$', '@')
+                || bytesEqual(str + i + 1, '(', 'J')) {
                 code = JIS;
                 goto breakBreak;
             }
             if (bytesEqual(str + i + 1, '(', 'I') || bytesEqual(str + i + 1, ')', 'I')) {
                 code = JIS;
                 i += 3;
             } else {
                 i++;
             }
             bfr = false;
             bfk = 0;
         } else {
             if (ptr[i] < 0x20) {
                 bfr = false;
                 bfk = 0;
                 /* ?? check kudokuten ?? && ?? hiragana ?? */
                 if ((i >= 2) && (ptr[i - 2] == 0x81)
-                        && (0x41 <= ptr[i - 1] && ptr[i - 1] <= 0x49)) {
+                    && (0x41 <= ptr[i - 1] && ptr[i - 1] <= 0x49)) {
                     code = SJIS;
                     sjis += 100;        /* kudokuten */
-                } else if ((i >= 2) && (ptr[i - 2] == 0xa1)
-                        && (0xa2 <= ptr[i - 1] && ptr[i - 1] <= 0xaa)) {
+                } else if ((i >= 2) && (ptr[i - 2] == 0xa1) && (0xa2 <= ptr[i - 1] && ptr[i - 1] <= 0xaa)) {
                     code = EUC;
                     euc += 100;         /* kudokuten */
                 } else if ((i >= 2) && (ptr[i - 2] == 0x82) && (0xa0 <= ptr[i - 1])) {
                     sjis += 40;         /* hiragana */
                 } else if ((i >= 2) && (ptr[i - 2] == 0xa4) && (0xa0 <= ptr[i - 1])) {
                     euc += 40;          /* hiragana */
                 }
             } else {
                 /* ?? check hiragana or katana ?? */
                 if ((size - i > 1) && (ptr[i] == 0x82) && (0xa0 <= ptr[i + 1])) {
                     sjis++;     /* hiragana */
-                } else if ((size - i > 1) && (ptr[i] == 0x83)
-                         && (0x40 <= ptr[i + 1] && ptr[i + 1] <= 0x9f)) {
+                } else if ((size - i > 1) && (ptr[i] == 0x83) && (0x40 <= ptr[i + 1] && ptr[i + 1] <= 0x9f)) {
                     sjis++;     /* katakana */
                 } else if ((size - i > 1) && (ptr[i] == 0xa4) && (0xa0 <= ptr[i + 1])) {
                     euc++;      /* hiragana */
                 } else if ((size - i > 1) && (ptr[i] == 0xa5) && (0xa0 <= ptr[i + 1])) {
                     euc++;      /* katakana */
                 }
                 if (bfr) {
                     if ((i >= 1) && (0x40 <= ptr[i] && ptr[i] <= 0xa0) && ISkanji(ptr[i - 1])) {
                         code = SJIS;
                         goto breakBreak;
-                    } else if ((i >= 1) && (0x81 <= ptr[i - 1] && ptr[i - 1] <= 0x9f) && ((0x40 <= ptr[i] && ptr[i] < 0x7e) || (0x7e < ptr[i] && ptr[i] <= 0xfc))) {
+                    }
+
+                    if ((i >= 1) && (0x81 <= ptr[i - 1] && ptr[i - 1] <= 0x9f) && ((0x40 <= ptr[i] && ptr[i] < 0x7e) || (0x7e < ptr[i] && ptr[i] <= 0xfc))) {
                         code = SJIS;
                         goto breakBreak;
-                    } else if ((i >= 1) && (0xfd <= ptr[i] && ptr[i] <= 0xfe) && (0xa1 <= ptr[i - 1] && ptr[i - 1] <= 0xfe)) {
+                    }
+
+                    if ((i >= 1) && (0xfd <= ptr[i] && ptr[i] <= 0xfe) && (0xa1 <= ptr[i - 1] && ptr[i - 1] <= 0xfe)) {
                         code = EUC;
                         goto breakBreak;
-                    } else if ((i >= 1) && (0xfd <= ptr[i - 1] && ptr[i - 1] <= 0xfe) && (0xa1 <= ptr[i] && ptr[i] <= 0xfe)) {
+                    }
+
+                    if ((i >= 1) && (0xfd <= ptr[i - 1] && ptr[i - 1] <= 0xfe) && (0xa1 <= ptr[i] && ptr[i] <= 0xfe)) {
                         code = EUC;
                         goto breakBreak;
-                    } else if ((i >= 1) && (ptr[i] < 0xa0 || 0xdf < ptr[i]) && (0x8e == ptr[i - 1])) {
+                    }
+
+                    if ((i >= 1) && (ptr[i] < 0xa0 || 0xdf < ptr[i]) && (0x8e == ptr[i - 1])) {
                         code = SJIS;
                         goto breakBreak;
-                    } else if (ptr[i] <= 0x7f) {
+                    }
+
+                    if (ptr[i] <= 0x7f) {
                         code = SJIS;
                         goto breakBreak;
-                    } else {
-                        if (0xa1 <= ptr[i] && ptr[i] <= 0xa6) {
-                            euc++;      /* sjis hankaku kana kigo */
-                        } else if (0xa1 <= ptr[i] && ptr[i] <= 0xdf) {
-                            ;           /* sjis hankaku kana */
-                        } else if (0xa1 <= ptr[i] && ptr[i] <= 0xfe) {
-                            euc++;
-                        } else if (0x8e == ptr[i]) {
-                            euc++;
-                        } else if (0x20 <= ptr[i] && ptr[i] <= 0x7f) {
-                            sjis++;
-                        }
-                        bfr = false;
-                        bfk = 0;
                     }
+
+                    if (0xa1 <= ptr[i] && ptr[i] <= 0xa6) {
+                        euc++;      /* sjis hankaku kana kigo */
+                    } else if (0xa1 <= ptr[i] && ptr[i] <= 0xdf) {
+                        /* sjis hankaku kana */
+                    } else if (0xa1 <= ptr[i] && ptr[i] <= 0xfe) {
+                        euc++;
+                    } else if (0x8e == ptr[i]) {
+                        euc++;
+                    } else if (0x20 <= ptr[i] && ptr[i] <= 0x7f) {
+                        sjis++;
+                    }
+
+                    bfr = false;
+                    bfk = 0;
                 } else if (0x8e == ptr[i]) {
                     if (size - i <= 1) {
-                        ;
+
                     } else if (0xa1 <= ptr[i + 1] && ptr[i + 1] <= 0xdf) {
                         /* EUC KANA or SJIS KANJI */
                         if (bfk == 1) {
                             euc += 100;
                         }
                         bfk++;
                         i++;
                     } else {
                         /* SJIS only */
                         code = SJIS;
                         goto breakBreak;
                     }
                 } else if (0x81 <= ptr[i] && ptr[i] <= 0x9f) {
                     /* SJIS only */
                     code = SJIS;
-                    if ((size - i >= 1)
-                            && ((0x40 <= ptr[i + 1] && ptr[i + 1] <= 0x7e)
-                            || (0x80 <= ptr[i + 1] && ptr[i + 1] <= 0xfc))) {
+                    if ((size - i >= 1) && ((0x40 <= ptr[i + 1] && ptr[i + 1] <= 0x7e) || (0x80 <= ptr[i + 1] && ptr[i + 1] <= 0xfc)))
                         goto breakBreak;
-                    }
                 } else if (0xfd <= ptr[i] && ptr[i] <= 0xfe) {
                     /* EUC only */
                     code = EUC;
-                    if ((size - i >= 1)
-                            && (0xa1 <= ptr[i + 1] && ptr[i + 1] <= 0xfe)) {
+                    if ((size - i >= 1) && (0xa1 <= ptr[i + 1] && ptr[i + 1] <= 0xfe))
                         goto breakBreak;
-                    }
                 } else if (ptr[i] <= 0x7f) {
-                    ;
+
                 } else {
                     bfr = true;
                     bfk = 0;
                 }
             }
             i++;
         }
     }
     if (code == ASCII) {
         if (sjis > euc) {
@@ skipping 48 matching lines @@
 }
 
 void TextResourceDecoder::setEncoding(const WTF::TextEncoding& encoding, EncodingSource source)
 {
     // In case the encoding didn't exist, we keep the old one (helps some sites specifying invalid encodings).
     if (!encoding.isValid())
         return;
 
     // When encoding comes from meta tag (i.e. it cannot be XML files sent via XHR),
     // treat x-user-defined as windows-1252 (bug 18270)
-    if (source == EncodingFromMetaTag && strcasecmp(encoding.name(), "x-user-defined") == 0)
+    if (source == EncodingFromMetaTag && !strcasecmp(encoding.name(), "x-user-defined"))
         m_encoding = "windows-1252";
     else if (source == EncodingFromMetaTag || source == EncodingFromXMLHeader || source == EncodingFromCSSCharset)
         m_encoding = encoding.closestByteBasedEquivalent();
     else
         m_encoding = encoding;
 
     m_codec.clear();
     m_source = source;
 }
 
@@ skipping 59 matching lines @@
     size_t buf2Len = len;
     const unsigned char* buf1 = reinterpret_cast<const unsigned char*>(m_buffer.data());
     const unsigned char* buf2 = reinterpret_cast<const unsigned char*>(data);
     unsigned char c1 = buf1Len ? (--buf1Len, *buf1++) : buf2Len ? (--buf2Len, *buf2++) : 0;
     unsigned char c2 = buf1Len ? (--buf1Len, *buf1++) : buf2Len ? (--buf2Len, *buf2++) : 0;
     unsigned char c3 = buf1Len ? (--buf1Len, *buf1++) : buf2Len ? (--buf2Len, *buf2++) : 0;
     unsigned char c4 = buf2Len ? (--buf2Len, *buf2++) : 0;
 
     // Check for the BOM.
     if (c1 == 0xFF && c2 == 0xFE) {
-        if (c3 != 0 || c4 != 0) {
+        if (c3 || c4) {
             setEncoding(UTF16LittleEndianEncoding(), AutoDetectedEncoding);
             lengthOfBOM = 2;
         } else {
             setEncoding(UTF32LittleEndianEncoding(), AutoDetectedEncoding);
             lengthOfBOM = 4;
         }
     } else if (c1 == 0xEF && c2 == 0xBB && c3 == 0xBF) {
         setEncoding(UTF8Encoding(), AutoDetectedEncoding);
         lengthOfBOM = 3;
     } else if (c1 == 0xFE && c2 == 0xFF) {
         setEncoding(UTF16BigEndianEncoding(), AutoDetectedEncoding);
         lengthOfBOM = 2;
-    } else if (c1 == 0 && c2 == 0 && c3 == 0xFE && c4 == 0xFF) {
+    } else if (!c1 && !c2 && c3 == 0xFE && c4 == 0xFF) {
         setEncoding(UTF32BigEndianEncoding(), AutoDetectedEncoding);
         lengthOfBOM = 4;
     }
 
     if (lengthOfBOM || bufferLength + len >= 4)
         m_checkedForBOM = true;
 
     return lengthOfBOM;
 }
 
@@ skipping 67 matching lines @@
         while (xmlDeclarationEnd != pEnd && *xmlDeclarationEnd != '>')
             ++xmlDeclarationEnd;
         if (xmlDeclarationEnd == pEnd)
             return false;
         // No need for +1, because we have an extra "?" to lose at the end of XML declaration.
         int len = 0;
         int pos = findXMLEncoding(ptr, xmlDeclarationEnd - ptr, len);
         if (pos != -1)
             setEncoding(findTextEncoding(ptr + pos, len), EncodingFromXMLHeader);
         // continue looking for a charset - it may be specified in an HTTP-Equiv meta
-    } else if (bytesEqual(ptr, '<', 0, '?', 0, 'x', 0))
+    } else if (bytesEqual(ptr, '<', 0, '?', 0, 'x', 0)) {
         setEncoding(UTF16LittleEndianEncoding(), AutoDetectedEncoding);
-    else if (bytesEqual(ptr, 0, '<', 0, '?', 0, 'x'))
+    } else if (bytesEqual(ptr, 0, '<', 0, '?', 0, 'x')) {
         setEncoding(UTF16BigEndianEncoding(), AutoDetectedEncoding);
-    else if (bytesEqual(ptr, '<', 0, 0, 0, '?', 0, 0, 0))
+    } else if (bytesEqual(ptr, '<', 0, 0, 0, '?', 0, 0, 0)) {
         setEncoding(UTF32LittleEndianEncoding(), AutoDetectedEncoding);
-    else if (bytesEqual(ptr, 0, 0, 0, '<', 0, 0, 0, '?'))
+    } else if (bytesEqual(ptr, 0, 0, 0, '<', 0, 0, 0, '?')) {
         setEncoding(UTF32BigEndianEncoding(), AutoDetectedEncoding);
+    }
 
     m_checkedForXMLCharset = true;
     return true;
 }
 
 void TextResourceDecoder::checkForMetaCharset(const char* data, size_t length)
 {
     if (m_source == UserChosenEncoding || m_source == EncodingFromHTTPHeader || m_source == AutoDetectedEncoding) {
         m_checkedForMetaCharset = true;
         return;
     }
 
     if (!m_charsetParser)
         m_charsetParser = HTMLMetaCharsetParser::create();
 
     if (!m_charsetParser->checkForMetaCharset(data, length))
         return;
 
     setEncoding(m_charsetParser->encoding(), EncodingFromMetaTag);
     m_charsetParser.clear();
     m_checkedForMetaCharset = true;
     return;
 }
 
 void TextResourceDecoder::detectJapaneseEncoding(const char* data, size_t len)
 {
     switch (KanjiCode::judge(data, len)) {
-        case KanjiCode::JIS:
-            setEncoding("ISO-2022-JP", EncodingFromContentSniffing);
-            break;
-        case KanjiCode::EUC:
-            setEncoding("EUC-JP", EncodingFromContentSniffing);
-            break;
-        case KanjiCode::SJIS:
-            setEncoding("Shift_JIS", EncodingFromContentSniffing);
-            break;
-        case KanjiCode::ASCII:
-        case KanjiCode::UTF16:
-        case KanjiCode::UTF8:
-            break;
+    case KanjiCode::JIS:
+        setEncoding("ISO-2022-JP", EncodingFromContentSniffing);
+        break;
+    case KanjiCode::EUC:
+        setEncoding("EUC-JP", EncodingFromContentSniffing);
+        break;
+    case KanjiCode::SJIS:
+        setEncoding("Shift_JIS", EncodingFromContentSniffing);
+        break;
+    case KanjiCode::ASCII:
+    case KanjiCode::UTF16:
+    case KanjiCode::UTF8:
+        break;
     }
 }
 
 // We use the encoding detector in two cases:
 //   1. Encoding detector is turned ON and no other encoding source is
 //      available (that is, it's DefaultEncoding).
 //   2. Encoding detector is turned ON and the encoding is set to
 //      the encoding of the parent frame, which is also auto-detected.
 //   Note that condition #2 is NOT satisfied unless parent-child frame
 //   relationship is compliant to the same-origin policy. If they're from
 //   different domains, |m_source| would not be set to EncodingFromParentFrame
 //   in the first place.
 bool TextResourceDecoder::shouldAutoDetect() const
 {
     // Just checking m_hintEncoding suffices here because it's only set
     // in setHintEncoding when the source is AutoDetectedEncoding.
     return m_usesEncodingDetector
         && (m_source == DefaultEncoding || (m_source == EncodingFromParentFrame && m_hintEncoding));
 }
 
 String TextResourceDecoder::decode(const char* data, size_t len)
 {
     size_t lengthOfBOM = 0;
     if (!m_checkedForBOM)
         lengthOfBOM = checkForBOM(data, len);
 
     bool movedDataToBuffer = false;
 
-    if (m_contentType == CSS && !m_checkedForCSSCharset)
+    if (m_contentType == CSS && !m_checkedForCSSCharset) {
         if (!checkForCSSCharset(data, len, movedDataToBuffer))
             return emptyString();
+    }
 
-    if ((m_contentType == HTML || m_contentType == XML) && !m_checkedForXMLCharset)
+    if ((m_contentType == HTML || m_contentType == XML) && !m_checkedForXMLCharset) {
         if (!checkForXMLCharset(data, len, movedDataToBuffer))
             return emptyString();
+    }
 
     // FIXME: It would be more efficient to move this logic below checkForMetaCharset because
     //        checkForMetaCharset can overrule these detections.
     if (shouldAutoDetect()) {
-        if (m_encoding.isJapanese())
+        if (m_encoding.isJapanese()) {
             detectJapaneseEncoding(data, len); // FIXME: We should use detectTextEncoding() for all languages.
-        else {
+        } else {
             WTF::TextEncoding detectedEncoding;
             if (detectTextEncoding(data, len, m_hintEncoding, &detectedEncoding))
                 setEncoding(detectedEncoding, EncodingFromContentSniffing);
         }
     }
 
     ASSERT(m_encoding.isValid());
 
     const char* dataForDecode = data + lengthOfBOM;
     size_t lengthForDecode = len - lengthOfBOM;
@@ skipping 16 matching lines @@
         m_codec = newTextCodec(m_encoding);
 
     String result = m_codec->decode(dataForDecode, lengthForDecode, false, m_contentType == XML && !m_useLenientXMLDecoding, m_sawError);
 
     m_buffer.clear();
     return result;
 }
 
 String TextResourceDecoder::flush()
 {
-   // If we can not identify the encoding even after a document is completely
-   // loaded, we need to detect the encoding if other conditions for
-   // autodetection is satisfied.
+    // If we can not identify the encoding even after a document is completely
+    // loaded, we need to detect the encoding if other conditions for
+    // autodetection is satisfied.
     if (m_buffer.size() && shouldAutoDetect()
         && ((!m_checkedForXMLCharset && (m_contentType == HTML || m_contentType == XML)) || (!m_checkedForCSSCharset && (m_contentType == CSS)))) {
         WTF::TextEncoding detectedEncoding;
         if (detectTextEncoding(m_buffer.data(), m_buffer.size(), m_hintEncoding, &detectedEncoding))
             setEncoding(detectedEncoding, EncodingFromContentSniffing);
     }
 
     if (!m_codec)
         m_codec = newTextCodec(m_encoding);
 
     String result = m_codec->decode(m_buffer.data(), m_buffer.size(), true, m_contentType == XML && !m_useLenientXMLDecoding, m_sawError);
     m_buffer.clear();
     m_codec.clear();
     m_checkedForBOM = false; // Skip BOM again when re-decoding.
     return result;
 }
 
 }