Use default std::optional if it is provided
[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
54 namespace WebCore {
55 using namespace WTF;
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 {
67 #if PLATFORM(IOS)
68     // FIXME: Force the site specific quirk below to work on iOS. Investigating other site specific quirks
69     // to see if we can enable the preference all together is to be handled by:
70     // <rdar://problem/8493309> Investigate Enabling Site Specific Quirks in MobileSafari and UIWebView
71     needsSiteSpecificQuirks = true;
72 #endif
73 }
74
75 CSSParserContext::CSSParserContext(Document& document, const URL& sheetBaseURL, const String& charset)
76     : baseURL(sheetBaseURL.isNull() ? document.baseURL() : sheetBaseURL)
77     , charset(charset)
78     , mode(document.inQuirksMode() ? HTMLQuirksMode : HTMLStandardMode)
79     , isHTMLDocument(document.isHTMLDocument())
80     , hasDocumentSecurityOrigin(sheetBaseURL.isNull() || document.securityOrigin().canRequest(baseURL))
81 {
82     
83     needsSiteSpecificQuirks = document.settings().needsSiteSpecificQuirks();
84     enforcesCSSMIMETypeInNoQuirksMode = document.settings().enforceCSSMIMETypeInNoQuirksMode();
85     useLegacyBackgroundSizeShorthandBehavior = document.settings().useLegacyBackgroundSizeShorthandBehavior();
86 #if ENABLE(TEXT_AUTOSIZING)
87     textAutosizingEnabled = document.settings().textAutosizingEnabled();
88 #endif
89     springTimingFunctionEnabled = document.settings().springTimingFunctionEnabled();
90     constantPropertiesEnabled = document.settings().constantPropertiesEnabled();
91     conicGradientsEnabled = document.settings().conicGradientsEnabled();
92     colorFilterEnabled = document.settings().colorFilterEnabled();
93     deferredCSSParserEnabled = document.settings().deferredCSSParserEnabled();
94     allowNewLinesClamp = document.settings().appleMailLinesClampEnabled();
95     useSystemAppearance = document.page() ? document.page()->useSystemAppearance() : false;
96     
97 #if PLATFORM(IOS)
98     // FIXME: Force the site specific quirk below to work on iOS. Investigating other site specific quirks
99     // to see if we can enable the preference all together is to be handled by:
100     // <rdar://problem/8493309> Investigate Enabling Site Specific Quirks in MobileSafari and UIWebView
101     needsSiteSpecificQuirks = true;
102 #endif
103 }
104
105 bool operator==(const CSSParserContext& a, const CSSParserContext& b)
106 {
107     return a.baseURL == b.baseURL
108         && a.charset == b.charset
109         && a.mode == b.mode
110         && a.isHTMLDocument == b.isHTMLDocument
111         && a.needsSiteSpecificQuirks == b.needsSiteSpecificQuirks
112         && a.enforcesCSSMIMETypeInNoQuirksMode == b.enforcesCSSMIMETypeInNoQuirksMode
113         && a.useLegacyBackgroundSizeShorthandBehavior == b.useLegacyBackgroundSizeShorthandBehavior
114         && a.springTimingFunctionEnabled == b.springTimingFunctionEnabled
115         && a.constantPropertiesEnabled == b.constantPropertiesEnabled
116         && a.conicGradientsEnabled == b.conicGradientsEnabled
117         && a.colorFilterEnabled == b.colorFilterEnabled
118         && a.deferredCSSParserEnabled == b.deferredCSSParserEnabled
119         && a.hasDocumentSecurityOrigin == b.hasDocumentSecurityOrigin
120         && a.useSystemAppearance == b.useSystemAppearance;
121 }
122
123 CSSParser::CSSParser(const CSSParserContext& context)
124     : m_context(context)
125 {
126 }
127
128 CSSParser::~CSSParser() = default;
129
130 void CSSParser::parseSheet(StyleSheetContents* sheet, const String& string, RuleParsing ruleParsing)
131 {
132     return CSSParserImpl::parseStyleSheet(string, m_context, sheet, ruleParsing);
133 }
134
135 void CSSParser::parseSheetForInspector(const CSSParserContext& context, StyleSheetContents* sheet, const String& string, CSSParserObserver& observer)
136 {
137     return CSSParserImpl::parseStyleSheetForInspector(string, context, sheet, observer);
138 }
139
140 RefPtr<StyleRuleBase> CSSParser::parseRule(const CSSParserContext& context, StyleSheetContents* sheet, const String& string)
141 {
142     return CSSParserImpl::parseRule(string, context, sheet, CSSParserImpl::AllowImportRules);
143 }
144
145 RefPtr<StyleRuleKeyframe> CSSParser::parseKeyframeRule(const String& string)
146 {
147     RefPtr<StyleRuleBase> keyframe = CSSParserImpl::parseRule(string, m_context, nullptr, CSSParserImpl::KeyframeRules);
148     return downcast<StyleRuleKeyframe>(keyframe.get());
149 }
150
151 bool CSSParser::parseSupportsCondition(const String& condition)
152 {
153     CSSParserImpl parser(m_context, condition);
154     return CSSSupportsParser::supportsCondition(parser.tokenizer()->tokenRange(), parser, CSSSupportsParser::ForWindowCSS) == CSSSupportsParser::Supported;
155 }
156
157 Color CSSParser::parseColor(const String& string, bool strict)
158 {
159     if (string.isEmpty())
160         return Color();
161     
162     // Try named colors first.
163     Color namedColor { string };
164     if (namedColor.isValid())
165         return namedColor;
166     
167     // Try the fast path to parse hex and rgb.
168     RefPtr<CSSValue> value = CSSParserFastPaths::parseColor(string, strict ? HTMLStandardMode : HTMLQuirksMode);
169     
170     // If that fails, try the full parser.
171     if (!value)
172         value = parseSingleValue(CSSPropertyColor, string, strictCSSParserContext());
173     if (!value || !value->isPrimitiveValue())
174         return Color();
175     const auto& primitiveValue = downcast<CSSPrimitiveValue>(*value);
176     if (!primitiveValue.isRGBColor())
177         return Color();
178     return primitiveValue.color();
179 }
180
181 Color CSSParser::parseSystemColor(const String& string, std::optional<std::reference_wrapper<const CSSParserContext>> context)
182 {
183     CSSValueID id = cssValueKeywordID(string);
184     if (!StyleColor::isSystemColor(id))
185         return Color();
186
187     OptionSet<StyleColor::Options> options;
188     if (context && context->get().useSystemAppearance)
189         options |= StyleColor::Options::UseSystemAppearance;
190     return RenderTheme::singleton().systemColor(id, options);
191 }
192
193 RefPtr<CSSValue> CSSParser::parseSingleValue(CSSPropertyID propertyID, const String& string, const CSSParserContext& context)
194 {
195     if (string.isEmpty())
196         return nullptr;
197     if (RefPtr<CSSValue> value = CSSParserFastPaths::maybeParseValue(propertyID, string, context.mode))
198         return value;
199     CSSTokenizer tokenizer(string);
200     return CSSPropertyParser::parseSingleValue(propertyID, tokenizer.tokenRange(), context);
201 }
202
203 CSSParser::ParseResult CSSParser::parseValue(MutableStyleProperties& declaration, CSSPropertyID propertyID, const String& string, bool important, const CSSParserContext& context)
204 {
205     ASSERT(!string.isEmpty());
206     RefPtr<CSSValue> value = CSSParserFastPaths::maybeParseValue(propertyID, string, context.mode);
207     if (value)
208         return declaration.addParsedProperty(CSSProperty(propertyID, WTFMove(value), important)) ? CSSParser::ParseResult::Changed : CSSParser::ParseResult::Unchanged;
209
210     CSSParser parser(context);
211     return parser.parseValue(declaration, propertyID, string, important);
212 }
213
214 CSSParser::ParseResult CSSParser::parseCustomPropertyValue(MutableStyleProperties& declaration, const AtomicString& propertyName, const String& string, bool important, const CSSParserContext& context)
215 {
216     return CSSParserImpl::parseCustomPropertyValue(&declaration, propertyName, string, important, context);
217 }
218
219 CSSParser::ParseResult CSSParser::parseValue(MutableStyleProperties& declaration, CSSPropertyID propertyID, const String& string, bool important)
220 {
221     return CSSParserImpl::parseValue(&declaration, propertyID, string, important, m_context);
222 }
223
224 void CSSParser::parseSelector(const String& string, CSSSelectorList& selectorList)
225 {
226     CSSTokenizer tokenizer(string);
227     selectorList = CSSSelectorParser::parseSelector(tokenizer.tokenRange(), m_context, nullptr);
228 }
229
230 Ref<ImmutableStyleProperties> CSSParser::parseInlineStyleDeclaration(const String& string, const Element* element)
231 {
232     return CSSParserImpl::parseInlineStyleDeclaration(string, element);
233 }
234
235 bool CSSParser::parseDeclaration(MutableStyleProperties& declaration, const String& string)
236 {
237     return CSSParserImpl::parseDeclarationList(&declaration, string, m_context);
238 }
239
240 void CSSParser::parseDeclarationForInspector(const CSSParserContext& context, const String& string, CSSParserObserver& observer)
241 {
242     CSSParserImpl::parseDeclarationListForInspector(string, context, observer);
243 }
244
245 RefPtr<CSSValue> CSSParser::parseValueWithVariableReferences(CSSPropertyID propID, const CSSValue& value, const CustomPropertyValueMap& customProperties, TextDirection direction, WritingMode writingMode)
246 {
247     if (value.isPendingSubstitutionValue()) {
248         // FIXME: Should have a resolvedShorthands cache to stop this from being done
249         // over and over for each longhand value.
250         const CSSPendingSubstitutionValue& pendingSubstitution = downcast<CSSPendingSubstitutionValue>(value);
251         CSSPropertyID shorthandID = pendingSubstitution.shorthandPropertyId();
252         if (CSSProperty::isDirectionAwareProperty(shorthandID))
253             shorthandID = CSSProperty::resolveDirectionAwareProperty(shorthandID, direction, writingMode);
254         CSSVariableReferenceValue* shorthandValue = pendingSubstitution.shorthandValue();
255         const CSSVariableData* variableData = shorthandValue->variableDataValue();
256         ASSERT(variableData);
257         
258         Vector<CSSParserToken> resolvedTokens;
259         if (!variableData->resolveTokenRange(customProperties, variableData->tokens(), resolvedTokens))
260             return nullptr;
261         
262         ParsedPropertyVector parsedProperties;
263         if (!CSSPropertyParser::parseValue(shorthandID, false, resolvedTokens, m_context, parsedProperties, StyleRule::Style))
264             return nullptr;
265         
266         for (auto& property : parsedProperties) {
267             if (property.id() == propID)
268                 return property.value();
269         }
270         
271         return nullptr;
272     }
273
274     if (value.isVariableReferenceValue()) {
275         const CSSVariableReferenceValue& valueWithReferences = downcast<CSSVariableReferenceValue>(value);
276         const CSSVariableData* variableData = valueWithReferences.variableDataValue();
277         ASSERT(variableData);
278         
279         Vector<CSSParserToken> resolvedTokens;
280         if (!variableData->resolveTokenRange(customProperties, variableData->tokens(), resolvedTokens))
281             return nullptr;
282         
283         return CSSPropertyParser::parseSingleValue(propID, resolvedTokens, m_context);
284     }
285     
286     return nullptr;
287 }
288
289 std::unique_ptr<Vector<double>> CSSParser::parseKeyframeKeyList(const String& selector)
290 {
291     return CSSParserImpl::parseKeyframeKeyList(selector);
292 }
293
294 RefPtr<CSSValue> CSSParser::parseFontFaceDescriptor(CSSPropertyID propertyID, const String& propertyValue, const CSSParserContext& context)
295 {
296     StringBuilder builder;
297     builder.appendLiteral("@font-face { ");
298     builder.append(getPropertyNameString(propertyID));
299     builder.appendLiteral(" : ");
300     builder.append(propertyValue);
301     builder.appendLiteral("; }");
302     RefPtr<StyleRuleBase> rule = parseRule(context, nullptr, builder.toString());
303     if (!rule || !rule->isFontFaceRule())
304         return nullptr;
305     return downcast<StyleRuleFontFace>(*rule.get()).properties().getPropertyCSSValue(propertyID);
306 }
307
308 }