153888574e282136fd4246c713e61f1767df0e7d
[WebKit-https.git] / Source / WebCore / css / parser / CSSParser.cpp
1 /*
2  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
3  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
4  * Copyright (C) 2004-2016 Apple Inc. All rights reserved.
5  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
6  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
7  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
8  * Copyright (C) 2012, 2013 Adobe Systems Incorporated. All rights reserved.
9  * Copyright (C) 2012 Intel Corporation. All rights reserved.
10  * Copyright (C) 2014 Google Inc. All rights reserved.
11  *
12  * This library is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU Library General Public
14  * License as published by the Free Software Foundation; either
15  * version 2 of the License, or (at your option) any later version.
16  *
17  * This library is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20  * Library General Public License for more details.
21  *
22  * You should have received a copy of the GNU Library General Public License
23  * along with this library; see the file COPYING.LIB.  If not, write to
24  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
25  * Boston, MA 02110-1301, USA.
26  */
27
28 #include "config.h"
29 #include "CSSParser.h"
30
31 #include "CSSKeyframeRule.h"
32 #include "CSSParserFastPaths.h"
33 #include "CSSParserImpl.h"
34 #include "CSSPendingSubstitutionValue.h"
35 #include "CSSPropertyParser.h"
36 #include "CSSSelectorParser.h"
37 #include "CSSSupportsParser.h"
38 #include "CSSTokenizer.h"
39 #include "CSSVariableData.h"
40 #include "CSSVariableReferenceValue.h"
41 #include "Document.h"
42 #include "Element.h"
43 #include "Page.h"
44 #include "RenderTheme.h"
45 #include "RuntimeEnabledFeatures.h"
46 #include "Settings.h"
47 #include "StyleColor.h"
48 #include "StyleRule.h"
49 #include "StyleSheetContents.h"
50 #include <wtf/NeverDestroyed.h>
51 #include <wtf/text/StringBuilder.h>
52
53 using namespace WTF;
54
55 namespace WebCore {
56
57 const CSSParserContext& strictCSSParserContext()
58 {
59     static NeverDestroyed<CSSParserContext> strictContext(HTMLStandardMode);
60     return strictContext;
61 }
62
63 CSSParserContext::CSSParserContext(CSSParserMode mode, const URL& baseURL)
64     : baseURL(baseURL)
65     , mode(mode)
66 #if ENABLE(CSS_GRID_LAYOUT)
67     , cssGridLayoutEnabled(RuntimeEnabledFeatures::sharedFeatures().isCSSGridLayoutEnabled())
68 #endif
69 {
70 #if PLATFORM(IOS)
71     // FIXME: Force the site specific quirk below to work on iOS. Investigating other site specific quirks
72     // to see if we can enable the preference all together is to be handled by:
73     // <rdar://problem/8493309> Investigate Enabling Site Specific Quirks in MobileSafari and UIWebView
74     needsSiteSpecificQuirks = true;
75 #endif
76 }
77
78 CSSParserContext::CSSParserContext(Document& document, const URL& baseURL, const String& charset)
79     : baseURL(baseURL.isNull() ? document.baseURL() : baseURL)
80     , charset(charset)
81     , mode(document.inQuirksMode() ? HTMLQuirksMode : HTMLStandardMode)
82     , isHTMLDocument(document.isHTMLDocument())
83 #if ENABLE(CSS_GRID_LAYOUT)
84     , cssGridLayoutEnabled(document.isCSSGridLayoutEnabled())
85 #endif
86 {
87     if (Settings* settings = document.settings()) {
88         needsSiteSpecificQuirks = settings->needsSiteSpecificQuirks();
89         enforcesCSSMIMETypeInNoQuirksMode = settings->enforceCSSMIMETypeInNoQuirksMode();
90         useLegacyBackgroundSizeShorthandBehavior = settings->useLegacyBackgroundSizeShorthandBehavior();
91 #if ENABLE(TEXT_AUTOSIZING)
92         textAutosizingEnabled = settings->textAutosizingEnabled();
93 #endif
94         springTimingFunctionEnabled = settings->springTimingFunctionEnabled();
95
96 #if ENABLE(VARIATION_FONTS)
97         variationFontsEnabled = settings->variationFontsEnabled();
98 #endif
99         deferredCSSParserEnabled = settings->deferredCSSParserEnabled();
100     }
101
102 #if PLATFORM(IOS)
103     // FIXME: Force the site specific quirk below to work on iOS. Investigating other site specific quirks
104     // to see if we can enable the preference all together is to be handled by:
105     // <rdar://problem/8493309> Investigate Enabling Site Specific Quirks in MobileSafari and UIWebView
106     needsSiteSpecificQuirks = true;
107 #endif
108 }
109
110 bool operator==(const CSSParserContext& a, const CSSParserContext& b)
111 {
112     return a.baseURL == b.baseURL
113         && a.charset == b.charset
114         && a.mode == b.mode
115         && a.isHTMLDocument == b.isHTMLDocument
116 #if ENABLE(CSS_GRID_LAYOUT)
117         && a.cssGridLayoutEnabled == b.cssGridLayoutEnabled
118 #endif
119         && a.needsSiteSpecificQuirks == b.needsSiteSpecificQuirks
120         && a.enforcesCSSMIMETypeInNoQuirksMode == b.enforcesCSSMIMETypeInNoQuirksMode
121         && a.useLegacyBackgroundSizeShorthandBehavior == b.useLegacyBackgroundSizeShorthandBehavior
122 #if ENABLE(VARIATION_FONTS)
123         && a.variationFontsEnabled == b.variationFontsEnabled
124 #endif
125         && a.springTimingFunctionEnabled == b.springTimingFunctionEnabled
126         && a.deferredCSSParserEnabled == b.deferredCSSParserEnabled;
127 }
128
129 CSSParser::CSSParser(const CSSParserContext& context)
130     : m_context(context)
131 {
132 }
133
134 CSSParser::~CSSParser()
135 {
136 }
137
138 void CSSParser::parseSheet(StyleSheetContents* sheet, const String& string, RuleParsing ruleParsing)
139 {
140     return CSSParserImpl::parseStyleSheet(string, m_context, sheet, ruleParsing);
141 }
142
143 void CSSParser::parseSheetForInspector(const CSSParserContext& context, StyleSheetContents* sheet, const String& string, CSSParserObserver& observer)
144 {
145     return CSSParserImpl::parseStyleSheetForInspector(string, context, sheet, observer);
146 }
147
148 RefPtr<StyleRuleBase> CSSParser::parseRule(const CSSParserContext& context, StyleSheetContents* sheet, const String& string)
149 {
150     return CSSParserImpl::parseRule(string, context, sheet, CSSParserImpl::AllowImportRules);
151 }
152
153 RefPtr<StyleKeyframe> CSSParser::parseKeyframeRule(const String& string)
154 {
155     RefPtr<StyleRuleBase> keyframe = CSSParserImpl::parseRule(string, m_context, nullptr, CSSParserImpl::KeyframeRules);
156     return downcast<StyleKeyframe>(keyframe.get());
157 }
158
159 bool CSSParser::parseSupportsCondition(const String& condition)
160 {
161     CSSParserImpl parser(m_context, condition);
162     return CSSSupportsParser::supportsCondition(parser.tokenizer()->tokenRange(), parser) == CSSSupportsParser::Supported;
163 }
164
165 Color CSSParser::parseColor(const String& string, bool strict)
166 {
167     if (string.isEmpty())
168         return Color();
169     
170     // Try named colors first.
171     Color namedColor { string };
172     if (namedColor.isValid())
173         return namedColor;
174     
175     // Try the fast path to parse hex and rgb.
176     RefPtr<CSSValue> value = CSSParserFastPaths::parseColor(string, strict ? HTMLStandardMode : HTMLQuirksMode);
177     
178     // If that fails, try the full parser.
179     if (!value)
180         value = parseSingleValue(CSSPropertyColor, string, strictCSSParserContext());
181     if (!value || !value->isPrimitiveValue())
182         return Color();
183     const auto& primitiveValue = downcast<CSSPrimitiveValue>(*value);
184     if (!primitiveValue.isRGBColor())
185         return Color();
186     return primitiveValue.color();
187 }
188
189 Color CSSParser::parseSystemColor(const String& string, Document* document)
190 {
191     if (!document || !document->page())
192         return Color();
193     
194     CSSValueID id = cssValueKeywordID(string);
195     if (!StyleColor::isSystemColor(id))
196         return Color();
197     
198     return document->page()->theme().systemColor(id);
199 }
200
201 RefPtr<CSSValue> CSSParser::parseSingleValue(CSSPropertyID propertyID, const String& string, const CSSParserContext& context)
202 {
203     if (string.isEmpty())
204         return nullptr;
205     if (RefPtr<CSSValue> value = CSSParserFastPaths::maybeParseValue(propertyID, string, context.mode))
206         return value;
207     CSSTokenizer tokenizer(string);
208     return CSSPropertyParser::parseSingleValue(propertyID, tokenizer.tokenRange(), context, nullptr);
209 }
210
211 CSSParser::ParseResult CSSParser::parseValue(MutableStyleProperties& declaration, CSSPropertyID propertyID, const String& string, bool important, const CSSParserContext& context)
212 {
213     ASSERT(!string.isEmpty());
214     RefPtr<CSSValue> value = CSSParserFastPaths::maybeParseValue(propertyID, string, context.mode);
215     if (value)
216         return declaration.addParsedProperty(CSSProperty(propertyID, WTFMove(value), important)) ? CSSParser::ParseResult::Changed : CSSParser::ParseResult::Unchanged;
217
218     CSSParser parser(context);
219     return parser.parseValue(declaration, propertyID, string, important);
220 }
221
222 CSSParser::ParseResult CSSParser::parseCustomPropertyValue(MutableStyleProperties& declaration, const AtomicString& propertyName, const String& string, bool important, const CSSParserContext& context)
223 {
224     return CSSParserImpl::parseCustomPropertyValue(&declaration, propertyName, string, important, context);
225 }
226
227 CSSParser::ParseResult CSSParser::parseValue(MutableStyleProperties& declaration, CSSPropertyID propertyID, const String& string, bool important)
228 {
229     return CSSParserImpl::parseValue(&declaration, propertyID, string, important, m_context);
230 }
231
232 void CSSParser::parseSelector(const String& string, CSSSelectorList& selectorList)
233 {
234     CSSTokenizer tokenizer(string);
235     selectorList = CSSSelectorParser::parseSelector(tokenizer.tokenRange(), m_context, nullptr);
236 }
237
238 Ref<ImmutableStyleProperties> CSSParser::parseInlineStyleDeclaration(const String& string, Element* element)
239 {
240     CSSParserContext context(element->document());
241     context.mode = strictToCSSParserMode(element->isHTMLElement() && !element->document().inQuirksMode());
242     return CSSParserImpl::parseInlineStyleDeclaration(string, element);
243 }
244
245 bool CSSParser::parseDeclaration(MutableStyleProperties& declaration, const String& string)
246 {
247     return CSSParserImpl::parseDeclarationList(&declaration, string, m_context);
248 }
249
250 void CSSParser::parseDeclarationForInspector(const CSSParserContext& context, const String& string, CSSParserObserver& observer)
251 {
252     CSSParserImpl::parseDeclarationListForInspector(string, context, observer);
253 }
254
255 RefPtr<CSSValue> CSSParser::parseValueWithVariableReferences(CSSPropertyID propID, const CSSValue& value, const CustomPropertyValueMap& customProperties, TextDirection direction, WritingMode writingMode)
256 {
257     if (value.isPendingSubstitutionValue()) {
258         // FIXME: Should have a resolvedShorthands cache to stop this from being done
259         // over and over for each longhand value.
260         const CSSPendingSubstitutionValue& pendingSubstitution = downcast<CSSPendingSubstitutionValue>(value);
261         CSSPropertyID shorthandID = pendingSubstitution.shorthandPropertyId();
262         if (CSSProperty::isDirectionAwareProperty(shorthandID))
263             shorthandID = CSSProperty::resolveDirectionAwareProperty(shorthandID, direction, writingMode);
264         CSSVariableReferenceValue* shorthandValue = pendingSubstitution.shorthandValue();
265         const CSSVariableData* variableData = shorthandValue->variableDataValue();
266         ASSERT(variableData);
267         
268         Vector<CSSParserToken> resolvedTokens;
269         if (!variableData->resolveTokenRange(customProperties, variableData->tokens(), resolvedTokens))
270             return nullptr;
271         
272         ParsedPropertyVector parsedProperties;
273         if (!CSSPropertyParser::parseValue(shorthandID, false, resolvedTokens, m_context, nullptr, parsedProperties, StyleRule::Style))
274             return nullptr;
275         
276         for (auto& property : parsedProperties) {
277             if (property.id() == propID)
278                 return property.value();
279         }
280         
281         return nullptr;
282     }
283
284     if (value.isVariableReferenceValue()) {
285         const CSSVariableReferenceValue& valueWithReferences = downcast<CSSVariableReferenceValue>(value);
286         const CSSVariableData* variableData = valueWithReferences.variableDataValue();
287         ASSERT(variableData);
288         
289         Vector<CSSParserToken> resolvedTokens;
290         if (!variableData->resolveTokenRange(customProperties, variableData->tokens(), resolvedTokens))
291             return nullptr;
292         
293         return CSSPropertyParser::parseSingleValue(propID, resolvedTokens, m_context, nullptr);
294     }
295     
296     return nullptr;
297 }
298
299 std::unique_ptr<Vector<double>> CSSParser::parseKeyframeKeyList(const String& selector)
300 {
301     return CSSParserImpl::parseKeyframeKeyList(selector);
302 }
303
304 RefPtr<CSSValue> CSSParser::parseFontFaceDescriptor(CSSPropertyID propertyID, const String& propertyValue, const CSSParserContext& context)
305 {
306     StringBuilder builder;
307     builder.append("@font-face { ");
308     builder.append(getPropertyNameString(propertyID));
309     builder.append(" : ");
310     builder.append(propertyValue);
311     builder.append("; }");
312     RefPtr<StyleRuleBase> rule = parseRule(context, nullptr, builder.toString());
313     if (!rule || !rule->isFontFaceRule())
314         return nullptr;
315     return downcast<StyleRuleFontFace>(*rule.get()).properties().getPropertyCSSValue(propertyID);
316 }
317
318 }