11e14a46e16e3f41d40cd33f800225bf0b6a6bff
[WebKit-https.git] / Source / WebCore / html / parser / HTMLMetaCharsetParser.cpp
1 /*
2  * Copyright (C) 2010 Google Inc. All Rights Reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "HTMLMetaCharsetParser.h"
28
29 #include "HTMLNames.h"
30 #include "HTMLParserIdioms.h"
31 #include "HTMLTokenizer.h"
32 #include "TextCodec.h"
33 #include "TextEncodingRegistry.h"
34
35 using namespace WTF;
36
37 namespace WebCore {
38
39 using namespace HTMLNames;
40
41 HTMLMetaCharsetParser::HTMLMetaCharsetParser()
42     : m_tokenizer(std::make_unique<HTMLTokenizer>(HTMLParserOptions()))
43     , m_assumedCodec(newTextCodec(Latin1Encoding()))
44     , m_inHeadSection(true)
45     , m_doneChecking(false)
46 {
47 }
48
49 HTMLMetaCharsetParser::~HTMLMetaCharsetParser()
50 {
51 }
52
53 static const char charsetString[] = "charset";
54 static const size_t charsetLength = sizeof("charset") - 1;
55
56 String HTMLMetaCharsetParser::extractCharset(const String& value)
57 {
58     size_t pos = 0;
59     unsigned length = value.length();
60
61     while (pos < length) {
62         pos = value.find(charsetString, pos, false);
63         if (pos == notFound)
64             break;
65
66         pos += charsetLength;
67
68         // Skip whitespace.
69         while (pos < length && value[pos] <= ' ')
70             ++pos;
71
72         if (value[pos] != '=')
73             continue;
74
75         ++pos;
76
77         while (pos < length && value[pos] <= ' ')
78             ++pos;
79
80         char quoteMark = 0;
81         if (pos < length && (value[pos] == '"' || value[pos] == '\'')) {
82             quoteMark = static_cast<char>(value[pos++]);
83             ASSERT(!(quoteMark & 0x80));
84         }
85             
86         if (pos == length)
87             break;
88
89         unsigned end = pos;
90         while (end < length && ((quoteMark && value[end] != quoteMark) || (!quoteMark && value[end] > ' ' && value[end] != '"' && value[end] != '\'' && value[end] != ';')))
91             ++end;
92
93         if (quoteMark && (end == length))
94             break; // Close quote not found.
95
96         return value.substring(pos, end - pos);
97     }
98
99     return "";
100 }
101
102 bool HTMLMetaCharsetParser::processMeta()
103 {
104     const HTMLToken::AttributeList& tokenAttributes = m_token.attributes();
105     AttributeList attributes;
106     for (HTMLToken::AttributeList::const_iterator iter = tokenAttributes.begin(); iter != tokenAttributes.end(); ++iter) {
107         String attributeName = StringImpl::create8BitIfPossible(iter->name);
108         String attributeValue = StringImpl::create8BitIfPossible(iter->value);
109         attributes.append(std::make_pair(attributeName, attributeValue));
110     }
111
112     m_encoding = encodingFromMetaAttributes(attributes);
113     return m_encoding.isValid();
114 }
115
116 TextEncoding HTMLMetaCharsetParser::encodingFromMetaAttributes(const AttributeList& attributes)
117 {
118     bool gotPragma = false;
119     Mode mode = None;
120     String charset;
121
122     for (AttributeList::const_iterator iter = attributes.begin(); iter != attributes.end(); ++iter) {
123         const AtomicString& attributeName = iter->first;
124         const String& attributeValue = iter->second;
125
126         if (attributeName == http_equivAttr) {
127             if (equalIgnoringCase(attributeValue, "content-type"))
128                 gotPragma = true;
129         } else if (charset.isEmpty()) {
130             if (attributeName == charsetAttr) {
131                 charset = attributeValue;
132                 mode = Charset;
133             } else if (attributeName == contentAttr) {
134                 charset = extractCharset(attributeValue);
135                 if (charset.length())
136                     mode = Pragma;
137             }
138         }
139     }
140
141     if (mode == Charset || (mode == Pragma && gotPragma))
142         return TextEncoding(stripLeadingAndTrailingHTMLSpaces(charset));
143
144     return TextEncoding();
145 }
146
147 static const int bytesToCheckUnconditionally = 1024; // That many input bytes will be checked for meta charset even if <head> section is over.
148
149 bool HTMLMetaCharsetParser::checkForMetaCharset(const char* data, size_t length)
150 {
151     if (m_doneChecking)
152         return true;
153
154     ASSERT(!m_encoding.isValid());
155
156     // We still don't have an encoding, and are in the head.
157     // The following tags are allowed in <head>:
158     // SCRIPT|STYLE|META|LINK|OBJECT|TITLE|BASE
159
160     // We stop scanning when a tag that is not permitted in <head>
161     // is seen, rather when </head> is seen, because that more closely
162     // matches behavior in other browsers; more details in
163     // <http://bugs.webkit.org/show_bug.cgi?id=3590>.
164
165     // Additionally, we ignore things that looks like tags in <title>, <script>
166     // and <noscript>; see <http://bugs.webkit.org/show_bug.cgi?id=4560>,
167     // <http://bugs.webkit.org/show_bug.cgi?id=12165> and
168     // <http://bugs.webkit.org/show_bug.cgi?id=12389>.
169
170     // Since many sites have charset declarations after <body> or other tags
171     // that are disallowed in <head>, we don't bail out until we've checked at
172     // least bytesToCheckUnconditionally bytes of input.
173
174     m_input.append(SegmentedString(m_assumedCodec->decode(data, length)));
175
176     while (m_tokenizer->nextToken(m_input, m_token)) {
177         bool end = m_token.type() == HTMLToken::EndTag;
178         if (end || m_token.type() == HTMLToken::StartTag) {
179             AtomicString tagName(m_token.name());
180             if (!end) {
181                 m_tokenizer->updateStateFor(tagName);
182                 if (tagName == metaTag && processMeta()) {
183                     m_doneChecking = true;
184                     return true;
185                 }
186             }
187
188             if (tagName != scriptTag && tagName != noscriptTag
189                 && tagName != styleTag && tagName != linkTag
190                 && tagName != metaTag && tagName != objectTag
191                 && tagName != titleTag && tagName != baseTag
192                 && (end || tagName != htmlTag) && (end || tagName != headTag)) {
193                 m_inHeadSection = false;
194             }
195         }
196
197         if (!m_inHeadSection && m_input.numberOfCharactersConsumed() >= bytesToCheckUnconditionally) {
198             m_doneChecking = true;
199             return true;
200         }
201
202         m_token.clear();
203     }
204
205     return false;
206 }
207
208 }