1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef THIRD_PARTY_BLINK_RENDERER_CORE_CSS_PARSER_CSS_PARSER_IMPL_H_
#define THIRD_PARTY_BLINK_RENDERER_CORE_CSS_PARSER_CSS_PARSER_IMPL_H_
#include <memory>
#include "base/macros.h"
#include "third_party/blink/renderer/core/core_export.h"
#include "third_party/blink/renderer/core/css/css_property_names.h"
#include "third_party/blink/renderer/core/css/css_property_source_data.h"
#include "third_party/blink/renderer/core/css/css_property_value.h"
#include "third_party/blink/renderer/core/css/css_property_value_set.h"
#include "third_party/blink/renderer/core/css/parser/css_parser_token_range.h"
#include "third_party/blink/renderer/platform/heap/handle.h"
#include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
#include "third_party/blink/renderer/platform/wtf/vector.h"
namespace blink {
class CSSLazyParsingState;
class CSSParserContext;
class CSSParserObserver;
class CSSParserTokenStream;
class StyleRule;
class StyleRuleBase;
class StyleRuleCharset;
class StyleRuleFontFace;
class StyleRuleImport;
class StyleRuleKeyframe;
class StyleRuleKeyframes;
class StyleRuleMedia;
class StyleRuleNamespace;
class StyleRulePage;
class StyleRuleProperty;
class StyleRuleSupports;
class StyleRuleViewport;
class StyleSheetContents;
class Element;
enum class ParseSheetResult {
kSucceeded,
kHasUnallowedImportRule,
};
class CORE_EXPORT CSSParserImpl {
STACK_ALLOCATED();
public:
CSSParserImpl(const CSSParserContext*, StyleSheetContents* = nullptr);
enum AllowedRulesType {
// As per css-syntax, css-cascade and css-namespaces, @charset rules
// must come first, followed by @import then @namespace.
// AllowImportRules actually means we allow @import and any rules thay
// may follow it, i.e. @namespace rules and regular rules.
// AllowCharsetRules and AllowNamespaceRules behave similarly.
kAllowCharsetRules,
kAllowImportRules,
kAllowNamespaceRules,
kRegularRules,
kKeyframeRules,
kFontFeatureRules,
kNoRules, // For parsing at-rules inside declaration lists
};
// Represents the start and end offsets of a CSSParserTokenRange.
struct RangeOffset {
wtf_size_t start, end;
RangeOffset(wtf_size_t start, wtf_size_t end) : start(start), end(end) {
DCHECK(start <= end);
}
// Used when we don't care what the offset is (typically when we don't have
// an observer).
static RangeOffset Ignore() { return {0, 0}; }
};
static MutableCSSPropertyValueSet::SetResult ParseValue(
MutableCSSPropertyValueSet*,
CSSPropertyID,
const String&,
bool important,
const CSSParserContext*);
static MutableCSSPropertyValueSet::SetResult ParseVariableValue(
MutableCSSPropertyValueSet*,
const AtomicString& property_name,
const String&,
bool important,
const CSSParserContext*,
bool is_animation_tainted);
static ImmutableCSSPropertyValueSet* ParseInlineStyleDeclaration(
const String&,
Element*);
static ImmutableCSSPropertyValueSet*
ParseInlineStyleDeclaration(const String&, CSSParserMode, SecureContextMode);
static bool ParseDeclarationList(MutableCSSPropertyValueSet*,
const String&,
const CSSParserContext*);
static StyleRuleBase* ParseRule(const String&,
const CSSParserContext*,
StyleSheetContents*,
AllowedRulesType);
static ParseSheetResult ParseStyleSheet(
const String&,
const CSSParserContext*,
StyleSheetContents*,
CSSDeferPropertyParsing = CSSDeferPropertyParsing::kNo,
bool allow_import_rules = true);
static CSSSelectorList ParsePageSelector(CSSParserTokenRange,
StyleSheetContents*);
static std::unique_ptr<Vector<double>> ParseKeyframeKeyList(const String&);
bool SupportsDeclaration(CSSParserTokenRange&);
const CSSParserContext* GetContext() const { return context_; }
static void ParseDeclarationListForInspector(const String&,
const CSSParserContext*,
CSSParserObserver&);
static void ParseStyleSheetForInspector(const String&,
const CSSParserContext*,
StyleSheetContents*,
CSSParserObserver&);
static CSSPropertyValueSet* ParseDeclarationListForLazyStyle(
const String&,
wtf_size_t offset,
const CSSParserContext*);
private:
enum RuleListType {
kTopLevelRuleList,
kRegularRuleList,
kKeyframesRuleList,
kFontFeatureRuleList,
};
// Returns whether the first encountered rule was valid
template <typename T>
bool ConsumeRuleList(CSSParserTokenStream&, RuleListType, T callback);
// These functions update the range/stream they're given
StyleRuleBase* ConsumeAtRule(CSSParserTokenStream&, AllowedRulesType);
StyleRuleBase* ConsumeQualifiedRule(CSSParserTokenStream&, AllowedRulesType);
static StyleRuleCharset* ConsumeCharsetRule(CSSParserTokenStream&);
StyleRuleImport* ConsumeImportRule(AtomicString prelude_uri,
CSSParserTokenStream&);
StyleRuleNamespace* ConsumeNamespaceRule(CSSParserTokenStream&);
StyleRuleMedia* ConsumeMediaRule(CSSParserTokenStream&);
StyleRuleSupports* ConsumeSupportsRule(CSSParserTokenStream&);
StyleRuleViewport* ConsumeViewportRule(CSSParserTokenStream&);
StyleRuleFontFace* ConsumeFontFaceRule(CSSParserTokenStream&);
StyleRuleKeyframes* ConsumeKeyframesRule(bool webkit_prefixed,
CSSParserTokenStream&);
StyleRulePage* ConsumePageRule(CSSParserTokenStream&);
StyleRuleProperty* ConsumePropertyRule(CSSParserTokenStream&);
StyleRuleScrollTimeline* ConsumeScrollTimelineRule(CSSParserTokenStream&);
StyleRuleKeyframe* ConsumeKeyframeStyleRule(CSSParserTokenRange prelude,
const RangeOffset& prelude_offset,
CSSParserTokenStream& block);
StyleRule* ConsumeStyleRule(CSSParserTokenStream&);
void ConsumeDeclarationList(CSSParserTokenStream&, StyleRule::RuleType);
void ConsumeDeclaration(CSSParserTokenRange,
const RangeOffset& decl_offset,
StyleRule::RuleType);
void ConsumeDeclarationValue(CSSParserTokenRange,
CSSPropertyID,
bool important,
StyleRule::RuleType);
void ConsumeVariableValue(CSSParserTokenRange,
const AtomicString& property_name,
bool important,
bool is_animation_tainted);
static std::unique_ptr<Vector<double>> ConsumeKeyframeKeyList(
CSSParserTokenRange);
// FIXME: Can we build CSSPropertyValueSets directly?
// FIXME: Investigate using a smaller inline buffer
HeapVector<CSSPropertyValue, 256> parsed_properties_;
const CSSParserContext* context_;
StyleSheetContents* style_sheet_;
// For the inspector
CSSParserObserver* observer_;
CSSLazyParsingState* lazy_state_;
DISALLOW_COPY_AND_ASSIGN(CSSParserImpl);
};
} // namespace blink
#endif // THIRD_PARTY_BLINK_RENDERER_CORE_CSS_PARSER_CSS_PARSER_IMPL_H_
|
