OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "core/css/parser/CSSParserImpl.h" | 5 #include "core/css/parser/CSSParserImpl.h" |
6 | 6 |
7 #include "core/css/CSSCustomIdentValue.h" | 7 #include "core/css/CSSCustomIdentValue.h" |
8 #include "core/css/CSSCustomPropertyDeclaration.h" | 8 #include "core/css/CSSCustomPropertyDeclaration.h" |
9 #include "core/css/CSSKeyframesRule.h" | 9 #include "core/css/CSSKeyframesRule.h" |
10 #include "core/css/CSSStyleSheet.h" | 10 #include "core/css/CSSStyleSheet.h" |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
80 // TODO(timloh): Do we need to do anything here? | 80 // TODO(timloh): Do we need to do anything here? |
81 } else { | 81 } else { |
82 if (seenProperties.test(propertyIDIndex)) | 82 if (seenProperties.test(propertyIDIndex)) |
83 continue; | 83 continue; |
84 seenProperties.set(propertyIDIndex); | 84 seenProperties.set(propertyIDIndex); |
85 } | 85 } |
86 output[--unusedEntries] = property; | 86 output[--unusedEntries] = property; |
87 } | 87 } |
88 } | 88 } |
89 | 89 |
90 static RawPtr<ImmutableStylePropertySet> createStylePropertySet(HeapVector<CSSPr
operty, 256>& parsedProperties, CSSParserMode mode) | 90 static ImmutableStylePropertySet* createStylePropertySet(HeapVector<CSSProperty,
256>& parsedProperties, CSSParserMode mode) |
91 { | 91 { |
92 std::bitset<numCSSProperties> seenProperties; | 92 std::bitset<numCSSProperties> seenProperties; |
93 size_t unusedEntries = parsedProperties.size(); | 93 size_t unusedEntries = parsedProperties.size(); |
94 HeapVector<CSSProperty, 256> results(unusedEntries); | 94 HeapVector<CSSProperty, 256> results(unusedEntries); |
95 HashSet<AtomicString> seenCustomProperties; | 95 HashSet<AtomicString> seenCustomProperties; |
96 | 96 |
97 filterProperties(true, parsedProperties, results, unusedEntries, seenPropert
ies, seenCustomProperties); | 97 filterProperties(true, parsedProperties, results, unusedEntries, seenPropert
ies, seenCustomProperties); |
98 filterProperties(false, parsedProperties, results, unusedEntries, seenProper
ties, seenCustomProperties); | 98 filterProperties(false, parsedProperties, results, unusedEntries, seenProper
ties, seenCustomProperties); |
99 | 99 |
100 RawPtr<ImmutableStylePropertySet> result = ImmutableStylePropertySet::create
(results.data() + unusedEntries, results.size() - unusedEntries, mode); | 100 ImmutableStylePropertySet* result = ImmutableStylePropertySet::create(result
s.data() + unusedEntries, results.size() - unusedEntries, mode); |
101 parsedProperties.clear(); | 101 parsedProperties.clear(); |
102 return result.release(); | 102 return result; |
103 } | 103 } |
104 | 104 |
105 RawPtr<ImmutableStylePropertySet> CSSParserImpl::parseInlineStyleDeclaration(con
st String& string, Element* element) | 105 ImmutableStylePropertySet* CSSParserImpl::parseInlineStyleDeclaration(const Stri
ng& string, Element* element) |
106 { | 106 { |
107 Document& document = element->document(); | 107 Document& document = element->document(); |
108 CSSParserContext context = CSSParserContext(document.elementSheet().contents
()->parserContext(), UseCounter::getFrom(&document)); | 108 CSSParserContext context = CSSParserContext(document.elementSheet().contents
()->parserContext(), UseCounter::getFrom(&document)); |
109 CSSParserMode mode = element->isHTMLElement() && !document.inQuirksMode() ?
HTMLStandardMode : HTMLQuirksMode; | 109 CSSParserMode mode = element->isHTMLElement() && !document.inQuirksMode() ?
HTMLStandardMode : HTMLQuirksMode; |
110 context.setMode(mode); | 110 context.setMode(mode); |
111 CSSParserImpl parser(context, document.elementSheet().contents()); | 111 CSSParserImpl parser(context, document.elementSheet().contents()); |
112 CSSTokenizer::Scope scope(string); | 112 CSSTokenizer::Scope scope(string); |
113 parser.consumeDeclarationList(scope.tokenRange(), StyleRule::Style); | 113 parser.consumeDeclarationList(scope.tokenRange(), StyleRule::Style); |
114 return createStylePropertySet(parser.m_parsedProperties, mode); | 114 return createStylePropertySet(parser.m_parsedProperties, mode); |
115 } | 115 } |
(...skipping 13 matching lines...) Expand all Loading... |
129 size_t unusedEntries = parser.m_parsedProperties.size(); | 129 size_t unusedEntries = parser.m_parsedProperties.size(); |
130 HeapVector<CSSProperty, 256> results(unusedEntries); | 130 HeapVector<CSSProperty, 256> results(unusedEntries); |
131 HashSet<AtomicString> seenCustomProperties; | 131 HashSet<AtomicString> seenCustomProperties; |
132 filterProperties(true, parser.m_parsedProperties, results, unusedEntries, se
enProperties, seenCustomProperties); | 132 filterProperties(true, parser.m_parsedProperties, results, unusedEntries, se
enProperties, seenCustomProperties); |
133 filterProperties(false, parser.m_parsedProperties, results, unusedEntries, s
eenProperties, seenCustomProperties); | 133 filterProperties(false, parser.m_parsedProperties, results, unusedEntries, s
eenProperties, seenCustomProperties); |
134 if (unusedEntries) | 134 if (unusedEntries) |
135 results.remove(0, unusedEntries); | 135 results.remove(0, unusedEntries); |
136 return declaration->addParsedProperties(results); | 136 return declaration->addParsedProperties(results); |
137 } | 137 } |
138 | 138 |
139 RawPtr<StyleRuleBase> CSSParserImpl::parseRule(const String& string, const CSSPa
rserContext& context, StyleSheetContents* styleSheet, AllowedRulesType allowedRu
les) | 139 StyleRuleBase* CSSParserImpl::parseRule(const String& string, const CSSParserCon
text& context, StyleSheetContents* styleSheet, AllowedRulesType allowedRules) |
140 { | 140 { |
141 CSSParserImpl parser(context, styleSheet); | 141 CSSParserImpl parser(context, styleSheet); |
142 CSSTokenizer::Scope scope(string); | 142 CSSTokenizer::Scope scope(string); |
143 CSSParserTokenRange range = scope.tokenRange(); | 143 CSSParserTokenRange range = scope.tokenRange(); |
144 range.consumeWhitespace(); | 144 range.consumeWhitespace(); |
145 if (range.atEnd()) | 145 if (range.atEnd()) |
146 return nullptr; // Parse error, empty rule | 146 return nullptr; // Parse error, empty rule |
147 RawPtr<StyleRuleBase> rule; | 147 StyleRuleBase* rule; |
148 if (range.peek().type() == AtKeywordToken) | 148 if (range.peek().type() == AtKeywordToken) |
149 rule = parser.consumeAtRule(range, allowedRules); | 149 rule = parser.consumeAtRule(range, allowedRules); |
150 else | 150 else |
151 rule = parser.consumeQualifiedRule(range, allowedRules); | 151 rule = parser.consumeQualifiedRule(range, allowedRules); |
152 if (!rule) | 152 if (!rule) |
153 return nullptr; // Parse error, failed to consume rule | 153 return nullptr; // Parse error, failed to consume rule |
154 range.consumeWhitespace(); | 154 range.consumeWhitespace(); |
155 if (!rule || !range.atEnd()) | 155 if (!rule || !range.atEnd()) |
156 return nullptr; // Parse error, trailing garbage | 156 return nullptr; // Parse error, trailing garbage |
157 return rule; | 157 return rule; |
158 } | 158 } |
159 | 159 |
160 void CSSParserImpl::parseStyleSheet(const String& string, const CSSParserContext
& context, StyleSheetContents* styleSheet) | 160 void CSSParserImpl::parseStyleSheet(const String& string, const CSSParserContext
& context, StyleSheetContents* styleSheet) |
161 { | 161 { |
162 TRACE_EVENT_BEGIN2( | 162 TRACE_EVENT_BEGIN2( |
163 "blink,blink_style", "CSSParserImpl::parseStyleSheet", | 163 "blink,blink_style", "CSSParserImpl::parseStyleSheet", |
164 "baseUrl", context.baseURL().getString().utf8(), | 164 "baseUrl", context.baseURL().getString().utf8(), |
165 "mode", context.mode()); | 165 "mode", context.mode()); |
166 | 166 |
167 TRACE_EVENT_BEGIN0("blink,blink_style", "CSSParserImpl::parseStyleSheet.toke
nize"); | 167 TRACE_EVENT_BEGIN0("blink,blink_style", "CSSParserImpl::parseStyleSheet.toke
nize"); |
168 CSSTokenizer::Scope scope(string); | 168 CSSTokenizer::Scope scope(string); |
169 TRACE_EVENT_END0("blink,blink_style", "CSSParserImpl::parseStyleSheet.tokeni
ze"); | 169 TRACE_EVENT_END0("blink,blink_style", "CSSParserImpl::parseStyleSheet.tokeni
ze"); |
170 | 170 |
171 TRACE_EVENT_BEGIN0("blink,blink_style", "CSSParserImpl::parseStyleSheet.pars
e"); | 171 TRACE_EVENT_BEGIN0("blink,blink_style", "CSSParserImpl::parseStyleSheet.pars
e"); |
172 CSSParserImpl parser(context, styleSheet); | 172 CSSParserImpl parser(context, styleSheet); |
173 bool firstRuleValid = parser.consumeRuleList(scope.tokenRange(), TopLevelRul
eList, [&styleSheet](RawPtr<StyleRuleBase> rule) { | 173 bool firstRuleValid = parser.consumeRuleList(scope.tokenRange(), TopLevelRul
eList, [&styleSheet](StyleRuleBase* rule) { |
174 if (rule->isCharsetRule()) | 174 if (rule->isCharsetRule()) |
175 return; | 175 return; |
176 styleSheet->parserAppendRule(rule); | 176 styleSheet->parserAppendRule(rule); |
177 }); | 177 }); |
178 styleSheet->setHasSyntacticallyValidCSSHeader(firstRuleValid); | 178 styleSheet->setHasSyntacticallyValidCSSHeader(firstRuleValid); |
179 TRACE_EVENT_END0("blink,blink_style", "CSSParserImpl::parseStyleSheet.parse"
); | 179 TRACE_EVENT_END0("blink,blink_style", "CSSParserImpl::parseStyleSheet.parse"
); |
180 | 180 |
181 TRACE_EVENT_END2( | 181 TRACE_EVENT_END2( |
182 "blink,blink_style", "CSSParserImpl::parseStyleSheet", | 182 "blink,blink_style", "CSSParserImpl::parseStyleSheet", |
183 "tokenCount", scope.tokenCount(), | 183 "tokenCount", scope.tokenCount(), |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
220 } | 220 } |
221 } | 221 } |
222 | 222 |
223 selector->setForPage(); | 223 selector->setForPage(); |
224 Vector<OwnPtr<CSSParserSelector>> selectorVector; | 224 Vector<OwnPtr<CSSParserSelector>> selectorVector; |
225 selectorVector.append(selector.release()); | 225 selectorVector.append(selector.release()); |
226 CSSSelectorList selectorList = CSSSelectorList::adoptSelectorVector(selector
Vector); | 226 CSSSelectorList selectorList = CSSSelectorList::adoptSelectorVector(selector
Vector); |
227 return selectorList; | 227 return selectorList; |
228 } | 228 } |
229 | 229 |
230 RawPtr<ImmutableStylePropertySet> CSSParserImpl::parseCustomPropertySet(CSSParse
rTokenRange range) | 230 ImmutableStylePropertySet* CSSParserImpl::parseCustomPropertySet(CSSParserTokenR
ange range) |
231 { | 231 { |
232 range.consumeWhitespace(); | 232 range.consumeWhitespace(); |
233 if (range.peek().type() != LeftBraceToken) | 233 if (range.peek().type() != LeftBraceToken) |
234 return nullptr; | 234 return nullptr; |
235 CSSParserTokenRange block = range.consumeBlock(); | 235 CSSParserTokenRange block = range.consumeBlock(); |
236 range.consumeWhitespace(); | 236 range.consumeWhitespace(); |
237 if (!range.atEnd()) | 237 if (!range.atEnd()) |
238 return nullptr; | 238 return nullptr; |
239 CSSParserImpl parser(strictCSSParserContext()); | 239 CSSParserImpl parser(strictCSSParserContext()); |
240 parser.consumeDeclarationList(block, StyleRule::Style); | 240 parser.consumeDeclarationList(block, StyleRule::Style); |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
273 observer.endRuleHeader(1); | 273 observer.endRuleHeader(1); |
274 parser.consumeDeclarationList(scope.tokenRange(), StyleRule::Style); | 274 parser.consumeDeclarationList(scope.tokenRange(), StyleRule::Style); |
275 } | 275 } |
276 | 276 |
277 void CSSParserImpl::parseStyleSheetForInspector(const String& string, const CSSP
arserContext& context, StyleSheetContents* styleSheet, CSSParserObserver& observ
er) | 277 void CSSParserImpl::parseStyleSheetForInspector(const String& string, const CSSP
arserContext& context, StyleSheetContents* styleSheet, CSSParserObserver& observ
er) |
278 { | 278 { |
279 CSSParserImpl parser(context, styleSheet); | 279 CSSParserImpl parser(context, styleSheet); |
280 CSSParserObserverWrapper wrapper(observer); | 280 CSSParserObserverWrapper wrapper(observer); |
281 parser.m_observerWrapper = &wrapper; | 281 parser.m_observerWrapper = &wrapper; |
282 CSSTokenizer::Scope scope(string, wrapper); | 282 CSSTokenizer::Scope scope(string, wrapper); |
283 bool firstRuleValid = parser.consumeRuleList(scope.tokenRange(), TopLevelRul
eList, [&styleSheet](RawPtr<StyleRuleBase> rule) { | 283 bool firstRuleValid = parser.consumeRuleList(scope.tokenRange(), TopLevelRul
eList, [&styleSheet](StyleRuleBase* rule) { |
284 if (rule->isCharsetRule()) | 284 if (rule->isCharsetRule()) |
285 return; | 285 return; |
286 styleSheet->parserAppendRule(rule); | 286 styleSheet->parserAppendRule(rule); |
287 }); | 287 }); |
288 styleSheet->setHasSyntacticallyValidCSSHeader(firstRuleValid); | 288 styleSheet->setHasSyntacticallyValidCSSHeader(firstRuleValid); |
289 } | 289 } |
290 | 290 |
291 static CSSParserImpl::AllowedRulesType computeNewAllowedRules(CSSParserImpl::All
owedRulesType allowedRules, StyleRuleBase* rule) | 291 static CSSParserImpl::AllowedRulesType computeNewAllowedRules(CSSParserImpl::All
owedRulesType allowedRules, StyleRuleBase* rule) |
292 { | 292 { |
293 if (!rule || allowedRules == CSSParserImpl::KeyframeRules || allowedRules ==
CSSParserImpl::NoRules) | 293 if (!rule || allowedRules == CSSParserImpl::KeyframeRules || allowedRules ==
CSSParserImpl::NoRules) |
(...skipping 20 matching lines...) Expand all Loading... |
314 case KeyframesRuleList: | 314 case KeyframesRuleList: |
315 allowedRules = KeyframeRules; | 315 allowedRules = KeyframeRules; |
316 break; | 316 break; |
317 default: | 317 default: |
318 ASSERT_NOT_REACHED(); | 318 ASSERT_NOT_REACHED(); |
319 } | 319 } |
320 | 320 |
321 bool seenRule = false; | 321 bool seenRule = false; |
322 bool firstRuleValid = false; | 322 bool firstRuleValid = false; |
323 while (!range.atEnd()) { | 323 while (!range.atEnd()) { |
324 RawPtr<StyleRuleBase> rule; | 324 StyleRuleBase* rule; |
325 switch (range.peek().type()) { | 325 switch (range.peek().type()) { |
326 case WhitespaceToken: | 326 case WhitespaceToken: |
327 range.consumeWhitespace(); | 327 range.consumeWhitespace(); |
328 continue; | 328 continue; |
329 case AtKeywordToken: | 329 case AtKeywordToken: |
330 rule = consumeAtRule(range, allowedRules); | 330 rule = consumeAtRule(range, allowedRules); |
331 break; | 331 break; |
332 case CDOToken: | 332 case CDOToken: |
333 case CDCToken: | 333 case CDCToken: |
334 if (ruleListType == TopLevelRuleList) { | 334 if (ruleListType == TopLevelRuleList) { |
335 range.consume(); | 335 range.consume(); |
336 continue; | 336 continue; |
337 } | 337 } |
338 // fallthrough | 338 // fallthrough |
339 default: | 339 default: |
340 rule = consumeQualifiedRule(range, allowedRules); | 340 rule = consumeQualifiedRule(range, allowedRules); |
341 break; | 341 break; |
342 } | 342 } |
343 if (!seenRule) { | 343 if (!seenRule) { |
344 seenRule = true; | 344 seenRule = true; |
345 firstRuleValid = rule; | 345 firstRuleValid = rule; |
346 } | 346 } |
347 if (rule) { | 347 if (rule) { |
348 allowedRules = computeNewAllowedRules(allowedRules, rule.get()); | 348 allowedRules = computeNewAllowedRules(allowedRules, rule); |
349 callback(rule.release()); | 349 callback(rule); |
350 } | 350 } |
351 } | 351 } |
352 | 352 |
353 return firstRuleValid; | 353 return firstRuleValid; |
354 } | 354 } |
355 | 355 |
356 RawPtr<StyleRuleBase> CSSParserImpl::consumeAtRule(CSSParserTokenRange& range, A
llowedRulesType allowedRules) | 356 StyleRuleBase* CSSParserImpl::consumeAtRule(CSSParserTokenRange& range, AllowedR
ulesType allowedRules) |
357 { | 357 { |
358 ASSERT(range.peek().type() == AtKeywordToken); | 358 ASSERT(range.peek().type() == AtKeywordToken); |
359 const CSSParserString& name = range.consume().value(); | 359 const CSSParserString& name = range.consume().value(); |
360 const CSSParserToken* preludeStart = &range.peek(); | 360 const CSSParserToken* preludeStart = &range.peek(); |
361 while (!range.atEnd() && range.peek().type() != LeftBraceToken && range.peek
().type() != SemicolonToken) | 361 while (!range.atEnd() && range.peek().type() != LeftBraceToken && range.peek
().type() != SemicolonToken) |
362 range.consumeComponentValue(); | 362 range.consumeComponentValue(); |
363 | 363 |
364 CSSParserTokenRange prelude = range.makeSubRange(preludeStart, &range.peek()
); | 364 CSSParserTokenRange prelude = range.makeSubRange(preludeStart, &range.peek()
); |
365 CSSAtRuleID id = cssAtRuleID(name); | 365 CSSAtRuleID id = cssAtRuleID(name); |
366 if (id != CSSAtRuleInvalid && m_context.useCounter()) | 366 if (id != CSSAtRuleInvalid && m_context.useCounter()) |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
402 return consumeKeyframesRule(true, prelude, block); | 402 return consumeKeyframesRule(true, prelude, block); |
403 case CSSAtRuleKeyframes: | 403 case CSSAtRuleKeyframes: |
404 return consumeKeyframesRule(false, prelude, block); | 404 return consumeKeyframesRule(false, prelude, block); |
405 case CSSAtRulePage: | 405 case CSSAtRulePage: |
406 return consumePageRule(prelude, block); | 406 return consumePageRule(prelude, block); |
407 default: | 407 default: |
408 return nullptr; // Parse error, unrecognised at-rule with block | 408 return nullptr; // Parse error, unrecognised at-rule with block |
409 } | 409 } |
410 } | 410 } |
411 | 411 |
412 RawPtr<StyleRuleBase> CSSParserImpl::consumeQualifiedRule(CSSParserTokenRange& r
ange, AllowedRulesType allowedRules) | 412 StyleRuleBase* CSSParserImpl::consumeQualifiedRule(CSSParserTokenRange& range, A
llowedRulesType allowedRules) |
413 { | 413 { |
414 const CSSParserToken* preludeStart = &range.peek(); | 414 const CSSParserToken* preludeStart = &range.peek(); |
415 while (!range.atEnd() && range.peek().type() != LeftBraceToken) | 415 while (!range.atEnd() && range.peek().type() != LeftBraceToken) |
416 range.consumeComponentValue(); | 416 range.consumeComponentValue(); |
417 | 417 |
418 if (range.atEnd()) | 418 if (range.atEnd()) |
419 return nullptr; // Parse error, EOF instead of qualified rule block | 419 return nullptr; // Parse error, EOF instead of qualified rule block |
420 | 420 |
421 CSSParserTokenRange prelude = range.makeSubRange(preludeStart, &range.peek()
); | 421 CSSParserTokenRange prelude = range.makeSubRange(preludeStart, &range.peek()
); |
422 CSSParserTokenRange block = range.consumeBlock(); | 422 CSSParserTokenRange block = range.consumeBlock(); |
(...skipping 19 matching lines...) Expand all Loading... |
442 return AtomicString(); | 442 return AtomicString(); |
443 | 443 |
444 CSSParserTokenRange contents = range.consumeBlock(); | 444 CSSParserTokenRange contents = range.consumeBlock(); |
445 const CSSParserToken& uri = contents.consumeIncludingWhitespace(); | 445 const CSSParserToken& uri = contents.consumeIncludingWhitespace(); |
446 ASSERT(uri.type() == StringToken); | 446 ASSERT(uri.type() == StringToken); |
447 if (!contents.atEnd()) | 447 if (!contents.atEnd()) |
448 return AtomicString(); | 448 return AtomicString(); |
449 return uri.value(); | 449 return uri.value(); |
450 } | 450 } |
451 | 451 |
452 RawPtr<StyleRuleCharset> CSSParserImpl::consumeCharsetRule(CSSParserTokenRange p
relude) | 452 StyleRuleCharset* CSSParserImpl::consumeCharsetRule(CSSParserTokenRange prelude) |
453 { | 453 { |
454 prelude.consumeWhitespace(); | 454 prelude.consumeWhitespace(); |
455 const CSSParserToken& string = prelude.consumeIncludingWhitespace(); | 455 const CSSParserToken& string = prelude.consumeIncludingWhitespace(); |
456 if (string.type() != StringToken || !prelude.atEnd()) | 456 if (string.type() != StringToken || !prelude.atEnd()) |
457 return nullptr; // Parse error, expected a single string | 457 return nullptr; // Parse error, expected a single string |
458 return StyleRuleCharset::create(); | 458 return StyleRuleCharset::create(); |
459 } | 459 } |
460 | 460 |
461 RawPtr<StyleRuleImport> CSSParserImpl::consumeImportRule(CSSParserTokenRange pre
lude) | 461 StyleRuleImport* CSSParserImpl::consumeImportRule(CSSParserTokenRange prelude) |
462 { | 462 { |
463 prelude.consumeWhitespace(); | 463 prelude.consumeWhitespace(); |
464 AtomicString uri(consumeStringOrURI(prelude)); | 464 AtomicString uri(consumeStringOrURI(prelude)); |
465 if (uri.isNull()) | 465 if (uri.isNull()) |
466 return nullptr; // Parse error, expected string or URI | 466 return nullptr; // Parse error, expected string or URI |
467 | 467 |
468 if (m_observerWrapper) { | 468 if (m_observerWrapper) { |
469 unsigned endOffset = m_observerWrapper->endOffset(prelude); | 469 unsigned endOffset = m_observerWrapper->endOffset(prelude); |
470 m_observerWrapper->observer().startRuleHeader(StyleRule::Import, m_obser
verWrapper->startOffset(prelude)); | 470 m_observerWrapper->observer().startRuleHeader(StyleRule::Import, m_obser
verWrapper->startOffset(prelude)); |
471 m_observerWrapper->observer().endRuleHeader(endOffset); | 471 m_observerWrapper->observer().endRuleHeader(endOffset); |
472 m_observerWrapper->observer().startRuleBody(endOffset); | 472 m_observerWrapper->observer().startRuleBody(endOffset); |
473 m_observerWrapper->observer().endRuleBody(endOffset); | 473 m_observerWrapper->observer().endRuleBody(endOffset); |
474 } | 474 } |
475 | 475 |
476 return StyleRuleImport::create(uri, MediaQueryParser::parseMediaQuerySet(pre
lude)); | 476 return StyleRuleImport::create(uri, MediaQueryParser::parseMediaQuerySet(pre
lude)); |
477 } | 477 } |
478 | 478 |
479 RawPtr<StyleRuleNamespace> CSSParserImpl::consumeNamespaceRule(CSSParserTokenRan
ge prelude) | 479 StyleRuleNamespace* CSSParserImpl::consumeNamespaceRule(CSSParserTokenRange prel
ude) |
480 { | 480 { |
481 prelude.consumeWhitespace(); | 481 prelude.consumeWhitespace(); |
482 AtomicString namespacePrefix; | 482 AtomicString namespacePrefix; |
483 if (prelude.peek().type() == IdentToken) | 483 if (prelude.peek().type() == IdentToken) |
484 namespacePrefix = prelude.consumeIncludingWhitespace().value(); | 484 namespacePrefix = prelude.consumeIncludingWhitespace().value(); |
485 | 485 |
486 AtomicString uri(consumeStringOrURI(prelude)); | 486 AtomicString uri(consumeStringOrURI(prelude)); |
487 prelude.consumeWhitespace(); | 487 prelude.consumeWhitespace(); |
488 if (uri.isNull() || !prelude.atEnd()) | 488 if (uri.isNull() || !prelude.atEnd()) |
489 return nullptr; // Parse error, expected string or URI | 489 return nullptr; // Parse error, expected string or URI |
490 | 490 |
491 return StyleRuleNamespace::create(namespacePrefix, uri); | 491 return StyleRuleNamespace::create(namespacePrefix, uri); |
492 } | 492 } |
493 | 493 |
494 RawPtr<StyleRuleMedia> CSSParserImpl::consumeMediaRule(CSSParserTokenRange prelu
de, CSSParserTokenRange block) | 494 StyleRuleMedia* CSSParserImpl::consumeMediaRule(CSSParserTokenRange prelude, CSS
ParserTokenRange block) |
495 { | 495 { |
496 HeapVector<Member<StyleRuleBase>> rules; | 496 HeapVector<Member<StyleRuleBase>> rules; |
497 | 497 |
498 if (m_observerWrapper) { | 498 if (m_observerWrapper) { |
499 CSSParserTokenRange preludeWithoutWhitespace = prelude; | 499 CSSParserTokenRange preludeWithoutWhitespace = prelude; |
500 preludeWithoutWhitespace.consumeWhitespace(); | 500 preludeWithoutWhitespace.consumeWhitespace(); |
501 m_observerWrapper->observer().startRuleHeader(StyleRule::Media, m_observ
erWrapper->startOffset(preludeWithoutWhitespace)); | 501 m_observerWrapper->observer().startRuleHeader(StyleRule::Media, m_observ
erWrapper->startOffset(preludeWithoutWhitespace)); |
502 m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset
(preludeWithoutWhitespace)); | 502 m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset
(preludeWithoutWhitespace)); |
503 m_observerWrapper->observer().startRuleBody(m_observerWrapper->previousT
okenStartOffset(block)); | 503 m_observerWrapper->observer().startRuleBody(m_observerWrapper->previousT
okenStartOffset(block)); |
504 } | 504 } |
505 | 505 |
506 consumeRuleList(block, RegularRuleList, [&rules](RawPtr<StyleRuleBase> rule)
{ | 506 consumeRuleList(block, RegularRuleList, [&rules](StyleRuleBase* rule) { |
507 rules.append(rule); | 507 rules.append(rule); |
508 }); | 508 }); |
509 | 509 |
510 if (m_observerWrapper) | 510 if (m_observerWrapper) |
511 m_observerWrapper->observer().endRuleBody(m_observerWrapper->endOffset(b
lock)); | 511 m_observerWrapper->observer().endRuleBody(m_observerWrapper->endOffset(b
lock)); |
512 | 512 |
513 return StyleRuleMedia::create(MediaQueryParser::parseMediaQuerySet(prelude),
rules); | 513 return StyleRuleMedia::create(MediaQueryParser::parseMediaQuerySet(prelude),
rules); |
514 } | 514 } |
515 | 515 |
516 RawPtr<StyleRuleSupports> CSSParserImpl::consumeSupportsRule(CSSParserTokenRange
prelude, CSSParserTokenRange block) | 516 StyleRuleSupports* CSSParserImpl::consumeSupportsRule(CSSParserTokenRange prelud
e, CSSParserTokenRange block) |
517 { | 517 { |
518 CSSSupportsParser::SupportsResult supported = CSSSupportsParser::supportsCon
dition(prelude, *this); | 518 CSSSupportsParser::SupportsResult supported = CSSSupportsParser::supportsCon
dition(prelude, *this); |
519 if (supported == CSSSupportsParser::Invalid) | 519 if (supported == CSSSupportsParser::Invalid) |
520 return nullptr; // Parse error, invalid @supports condition | 520 return nullptr; // Parse error, invalid @supports condition |
521 | 521 |
522 if (m_observerWrapper) { | 522 if (m_observerWrapper) { |
523 m_observerWrapper->observer().startRuleHeader(StyleRule::Supports, m_obs
erverWrapper->startOffset(prelude)); | 523 m_observerWrapper->observer().startRuleHeader(StyleRule::Supports, m_obs
erverWrapper->startOffset(prelude)); |
524 m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset
(prelude)); | 524 m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset
(prelude)); |
525 m_observerWrapper->observer().startRuleBody(m_observerWrapper->previousT
okenStartOffset(block)); | 525 m_observerWrapper->observer().startRuleBody(m_observerWrapper->previousT
okenStartOffset(block)); |
526 } | 526 } |
527 | 527 |
528 HeapVector<Member<StyleRuleBase>> rules; | 528 HeapVector<Member<StyleRuleBase>> rules; |
529 consumeRuleList(block, RegularRuleList, [&rules](RawPtr<StyleRuleBase> rule)
{ | 529 consumeRuleList(block, RegularRuleList, [&rules](StyleRuleBase* rule) { |
530 rules.append(rule); | 530 rules.append(rule); |
531 }); | 531 }); |
532 | 532 |
533 if (m_observerWrapper) | 533 if (m_observerWrapper) |
534 m_observerWrapper->observer().endRuleBody(m_observerWrapper->endOffset(b
lock)); | 534 m_observerWrapper->observer().endRuleBody(m_observerWrapper->endOffset(b
lock)); |
535 | 535 |
536 return StyleRuleSupports::create(prelude.serialize().stripWhiteSpace(), supp
orted, rules); | 536 return StyleRuleSupports::create(prelude.serialize().stripWhiteSpace(), supp
orted, rules); |
537 } | 537 } |
538 | 538 |
539 RawPtr<StyleRuleViewport> CSSParserImpl::consumeViewportRule(CSSParserTokenRange
prelude, CSSParserTokenRange block) | 539 StyleRuleViewport* CSSParserImpl::consumeViewportRule(CSSParserTokenRange prelud
e, CSSParserTokenRange block) |
540 { | 540 { |
541 // Allow @viewport rules from UA stylesheets even if the feature is disabled
. | 541 // Allow @viewport rules from UA stylesheets even if the feature is disabled
. |
542 if (!RuntimeEnabledFeatures::cssViewportEnabled() && !isUASheetBehavior(m_co
ntext.mode())) | 542 if (!RuntimeEnabledFeatures::cssViewportEnabled() && !isUASheetBehavior(m_co
ntext.mode())) |
543 return nullptr; | 543 return nullptr; |
544 | 544 |
545 prelude.consumeWhitespace(); | 545 prelude.consumeWhitespace(); |
546 if (!prelude.atEnd()) | 546 if (!prelude.atEnd()) |
547 return nullptr; // Parser error; @viewport prelude should be empty | 547 return nullptr; // Parser error; @viewport prelude should be empty |
548 | 548 |
549 if (m_observerWrapper) { | 549 if (m_observerWrapper) { |
550 unsigned endOffset = m_observerWrapper->endOffset(prelude); | 550 unsigned endOffset = m_observerWrapper->endOffset(prelude); |
551 m_observerWrapper->observer().startRuleHeader(StyleRule::Viewport, m_obs
erverWrapper->startOffset(prelude)); | 551 m_observerWrapper->observer().startRuleHeader(StyleRule::Viewport, m_obs
erverWrapper->startOffset(prelude)); |
552 m_observerWrapper->observer().endRuleHeader(endOffset); | 552 m_observerWrapper->observer().endRuleHeader(endOffset); |
553 m_observerWrapper->observer().startRuleBody(endOffset); | 553 m_observerWrapper->observer().startRuleBody(endOffset); |
554 m_observerWrapper->observer().endRuleBody(endOffset); | 554 m_observerWrapper->observer().endRuleBody(endOffset); |
555 } | 555 } |
556 | 556 |
557 consumeDeclarationList(block, StyleRule::Viewport); | 557 consumeDeclarationList(block, StyleRule::Viewport); |
558 return StyleRuleViewport::create(createStylePropertySet(m_parsedProperties,
CSSViewportRuleMode)); | 558 return StyleRuleViewport::create(createStylePropertySet(m_parsedProperties,
CSSViewportRuleMode)); |
559 } | 559 } |
560 | 560 |
561 RawPtr<StyleRuleFontFace> CSSParserImpl::consumeFontFaceRule(CSSParserTokenRange
prelude, CSSParserTokenRange block) | 561 StyleRuleFontFace* CSSParserImpl::consumeFontFaceRule(CSSParserTokenRange prelud
e, CSSParserTokenRange block) |
562 { | 562 { |
563 prelude.consumeWhitespace(); | 563 prelude.consumeWhitespace(); |
564 if (!prelude.atEnd()) | 564 if (!prelude.atEnd()) |
565 return nullptr; // Parse error; @font-face prelude should be empty | 565 return nullptr; // Parse error; @font-face prelude should be empty |
566 | 566 |
567 if (m_observerWrapper) { | 567 if (m_observerWrapper) { |
568 unsigned endOffset = m_observerWrapper->endOffset(prelude); | 568 unsigned endOffset = m_observerWrapper->endOffset(prelude); |
569 m_observerWrapper->observer().startRuleHeader(StyleRule::FontFace, m_obs
erverWrapper->startOffset(prelude)); | 569 m_observerWrapper->observer().startRuleHeader(StyleRule::FontFace, m_obs
erverWrapper->startOffset(prelude)); |
570 m_observerWrapper->observer().endRuleHeader(endOffset); | 570 m_observerWrapper->observer().endRuleHeader(endOffset); |
571 m_observerWrapper->observer().startRuleBody(endOffset); | 571 m_observerWrapper->observer().startRuleBody(endOffset); |
572 m_observerWrapper->observer().endRuleBody(endOffset); | 572 m_observerWrapper->observer().endRuleBody(endOffset); |
573 } | 573 } |
574 | 574 |
575 if (m_styleSheet) | 575 if (m_styleSheet) |
576 m_styleSheet->setHasFontFaceRule(true); | 576 m_styleSheet->setHasFontFaceRule(true); |
577 | 577 |
578 consumeDeclarationList(block, StyleRule::FontFace); | 578 consumeDeclarationList(block, StyleRule::FontFace); |
579 return StyleRuleFontFace::create(createStylePropertySet(m_parsedProperties,
m_context.mode())); | 579 return StyleRuleFontFace::create(createStylePropertySet(m_parsedProperties,
m_context.mode())); |
580 } | 580 } |
581 | 581 |
582 RawPtr<StyleRuleKeyframes> CSSParserImpl::consumeKeyframesRule(bool webkitPrefix
ed, CSSParserTokenRange prelude, CSSParserTokenRange block) | 582 StyleRuleKeyframes* CSSParserImpl::consumeKeyframesRule(bool webkitPrefixed, CSS
ParserTokenRange prelude, CSSParserTokenRange block) |
583 { | 583 { |
584 prelude.consumeWhitespace(); | 584 prelude.consumeWhitespace(); |
585 CSSParserTokenRange rangeCopy = prelude; // For inspector callbacks | 585 CSSParserTokenRange rangeCopy = prelude; // For inspector callbacks |
586 const CSSParserToken& nameToken = prelude.consumeIncludingWhitespace(); | 586 const CSSParserToken& nameToken = prelude.consumeIncludingWhitespace(); |
587 if (!prelude.atEnd()) | 587 if (!prelude.atEnd()) |
588 return nullptr; // Parse error; expected single non-whitespace token in
@keyframes header | 588 return nullptr; // Parse error; expected single non-whitespace token in
@keyframes header |
589 | 589 |
590 String name; | 590 String name; |
591 if (nameToken.type() == IdentToken) { | 591 if (nameToken.type() == IdentToken) { |
592 name = nameToken.value(); | 592 name = nameToken.value(); |
593 } else if (nameToken.type() == StringToken && webkitPrefixed) { | 593 } else if (nameToken.type() == StringToken && webkitPrefixed) { |
594 if (m_context.useCounter()) | 594 if (m_context.useCounter()) |
595 m_context.useCounter()->count(UseCounter::QuotedKeyframesRule); | 595 m_context.useCounter()->count(UseCounter::QuotedKeyframesRule); |
596 name = nameToken.value(); | 596 name = nameToken.value(); |
597 } else { | 597 } else { |
598 return nullptr; // Parse error; expected ident token in @keyframes heade
r | 598 return nullptr; // Parse error; expected ident token in @keyframes heade
r |
599 } | 599 } |
600 | 600 |
601 if (m_observerWrapper) { | 601 if (m_observerWrapper) { |
602 m_observerWrapper->observer().startRuleHeader(StyleRule::Keyframes, m_ob
serverWrapper->startOffset(rangeCopy)); | 602 m_observerWrapper->observer().startRuleHeader(StyleRule::Keyframes, m_ob
serverWrapper->startOffset(rangeCopy)); |
603 m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset
(prelude)); | 603 m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset
(prelude)); |
604 m_observerWrapper->observer().startRuleBody(m_observerWrapper->previousT
okenStartOffset(block)); | 604 m_observerWrapper->observer().startRuleBody(m_observerWrapper->previousT
okenStartOffset(block)); |
605 m_observerWrapper->observer().endRuleBody(m_observerWrapper->endOffset(b
lock)); | 605 m_observerWrapper->observer().endRuleBody(m_observerWrapper->endOffset(b
lock)); |
606 } | 606 } |
607 | 607 |
608 RawPtr<StyleRuleKeyframes> keyframeRule = StyleRuleKeyframes::create(); | 608 StyleRuleKeyframes* keyframeRule = StyleRuleKeyframes::create(); |
609 consumeRuleList(block, KeyframesRuleList, [keyframeRule](RawPtr<StyleRuleBas
e> keyframe) { | 609 consumeRuleList(block, KeyframesRuleList, [keyframeRule](StyleRuleBase* keyf
rame) { |
610 keyframeRule->parserAppendKeyframe(toStyleRuleKeyframe(keyframe.get())); | 610 keyframeRule->parserAppendKeyframe(toStyleRuleKeyframe(keyframe)); |
611 }); | 611 }); |
612 keyframeRule->setName(name); | 612 keyframeRule->setName(name); |
613 keyframeRule->setVendorPrefixed(webkitPrefixed); | 613 keyframeRule->setVendorPrefixed(webkitPrefixed); |
614 return keyframeRule.release(); | 614 return keyframeRule; |
615 } | 615 } |
616 | 616 |
617 RawPtr<StyleRulePage> CSSParserImpl::consumePageRule(CSSParserTokenRange prelude
, CSSParserTokenRange block) | 617 StyleRulePage* CSSParserImpl::consumePageRule(CSSParserTokenRange prelude, CSSPa
rserTokenRange block) |
618 { | 618 { |
619 CSSSelectorList selectorList = parsePageSelector(prelude, m_styleSheet); | 619 CSSSelectorList selectorList = parsePageSelector(prelude, m_styleSheet); |
620 if (!selectorList.isValid()) | 620 if (!selectorList.isValid()) |
621 return nullptr; // Parse error, invalid @page selector | 621 return nullptr; // Parse error, invalid @page selector |
622 | 622 |
623 if (m_observerWrapper) { | 623 if (m_observerWrapper) { |
624 unsigned endOffset = m_observerWrapper->endOffset(prelude); | 624 unsigned endOffset = m_observerWrapper->endOffset(prelude); |
625 m_observerWrapper->observer().startRuleHeader(StyleRule::Page, m_observe
rWrapper->startOffset(prelude)); | 625 m_observerWrapper->observer().startRuleHeader(StyleRule::Page, m_observe
rWrapper->startOffset(prelude)); |
626 m_observerWrapper->observer().endRuleHeader(endOffset); | 626 m_observerWrapper->observer().endRuleHeader(endOffset); |
627 } | 627 } |
628 | 628 |
629 consumeDeclarationList(block, StyleRule::Style); | 629 consumeDeclarationList(block, StyleRule::Style); |
630 | 630 |
631 return StyleRulePage::create(std::move(selectorList), createStylePropertySet
(m_parsedProperties, m_context.mode())); | 631 return StyleRulePage::create(std::move(selectorList), createStylePropertySet
(m_parsedProperties, m_context.mode())); |
632 } | 632 } |
633 | 633 |
634 void CSSParserImpl::consumeApplyRule(CSSParserTokenRange prelude) | 634 void CSSParserImpl::consumeApplyRule(CSSParserTokenRange prelude) |
635 { | 635 { |
636 ASSERT(RuntimeEnabledFeatures::cssApplyAtRulesEnabled()); | 636 ASSERT(RuntimeEnabledFeatures::cssApplyAtRulesEnabled()); |
637 | 637 |
638 prelude.consumeWhitespace(); | 638 prelude.consumeWhitespace(); |
639 const CSSParserToken& ident = prelude.consumeIncludingWhitespace(); | 639 const CSSParserToken& ident = prelude.consumeIncludingWhitespace(); |
640 if (!prelude.atEnd() || !CSSVariableParser::isValidVariableName(ident)) | 640 if (!prelude.atEnd() || !CSSVariableParser::isValidVariableName(ident)) |
641 return; // Parse error, expected a single custom property name | 641 return; // Parse error, expected a single custom property name |
642 m_parsedProperties.append(CSSProperty( | 642 m_parsedProperties.append(CSSProperty( |
643 CSSPropertyApplyAtRule, | 643 CSSPropertyApplyAtRule, |
644 CSSCustomIdentValue::create(ident.value()))); | 644 CSSCustomIdentValue::create(ident.value()))); |
645 } | 645 } |
646 | 646 |
647 RawPtr<StyleRuleKeyframe> CSSParserImpl::consumeKeyframeStyleRule(CSSParserToken
Range prelude, CSSParserTokenRange block) | 647 StyleRuleKeyframe* CSSParserImpl::consumeKeyframeStyleRule(CSSParserTokenRange p
relude, CSSParserTokenRange block) |
648 { | 648 { |
649 OwnPtr<Vector<double>> keyList = consumeKeyframeKeyList(prelude); | 649 OwnPtr<Vector<double>> keyList = consumeKeyframeKeyList(prelude); |
650 if (!keyList) | 650 if (!keyList) |
651 return nullptr; | 651 return nullptr; |
652 | 652 |
653 if (m_observerWrapper) { | 653 if (m_observerWrapper) { |
654 m_observerWrapper->observer().startRuleHeader(StyleRule::Keyframe, m_obs
erverWrapper->startOffset(prelude)); | 654 m_observerWrapper->observer().startRuleHeader(StyleRule::Keyframe, m_obs
erverWrapper->startOffset(prelude)); |
655 m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset
(prelude)); | 655 m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset
(prelude)); |
656 } | 656 } |
657 | 657 |
(...skipping 15 matching lines...) Expand all Loading... |
673 CSSParserTokenRange selector = selectors.makeSubRange(selectorStart, &se
lectors.peek()); | 673 CSSParserTokenRange selector = selectors.makeSubRange(selectorStart, &se
lectors.peek()); |
674 selectors.consumeIncludingWhitespace(); | 674 selectors.consumeIncludingWhitespace(); |
675 | 675 |
676 wrapper.observer().observeSelector(wrapper.startOffset(selector), wrappe
r.endOffset(selector)); | 676 wrapper.observer().observeSelector(wrapper.startOffset(selector), wrappe
r.endOffset(selector)); |
677 } | 677 } |
678 | 678 |
679 wrapper.observer().endRuleHeader(wrapper.endOffset(originalRange)); | 679 wrapper.observer().endRuleHeader(wrapper.endOffset(originalRange)); |
680 } | 680 } |
681 | 681 |
682 | 682 |
683 RawPtr<StyleRule> CSSParserImpl::consumeStyleRule(CSSParserTokenRange prelude, C
SSParserTokenRange block) | 683 StyleRule* CSSParserImpl::consumeStyleRule(CSSParserTokenRange prelude, CSSParse
rTokenRange block) |
684 { | 684 { |
685 CSSSelectorList selectorList = CSSSelectorParser::parseSelector(prelude, m_c
ontext, m_styleSheet); | 685 CSSSelectorList selectorList = CSSSelectorParser::parseSelector(prelude, m_c
ontext, m_styleSheet); |
686 if (!selectorList.isValid()) | 686 if (!selectorList.isValid()) |
687 return nullptr; // Parse error, invalid selector list | 687 return nullptr; // Parse error, invalid selector list |
688 | 688 |
689 if (m_observerWrapper) | 689 if (m_observerWrapper) |
690 observeSelectors(*m_observerWrapper, prelude); | 690 observeSelectors(*m_observerWrapper, prelude); |
691 | 691 |
692 consumeDeclarationList(block, StyleRule::Style); | 692 consumeDeclarationList(block, StyleRule::Style); |
693 | 693 |
(...skipping 26 matching lines...) Expand all Loading... |
720 range.consumeComponentValue(); | 720 range.consumeComponentValue(); |
721 | 721 |
722 consumeDeclaration(range.makeSubRange(declarationStart, &range.peek(
)), ruleType); | 722 consumeDeclaration(range.makeSubRange(declarationStart, &range.peek(
)), ruleType); |
723 | 723 |
724 if (useObserver) | 724 if (useObserver) |
725 m_observerWrapper->skipCommentsBefore(range, false); | 725 m_observerWrapper->skipCommentsBefore(range, false); |
726 break; | 726 break; |
727 } | 727 } |
728 case AtKeywordToken: { | 728 case AtKeywordToken: { |
729 AllowedRulesType allowedRules = ruleType == StyleRule::Style && Runt
imeEnabledFeatures::cssApplyAtRulesEnabled() ? ApplyRules : NoRules; | 729 AllowedRulesType allowedRules = ruleType == StyleRule::Style && Runt
imeEnabledFeatures::cssApplyAtRulesEnabled() ? ApplyRules : NoRules; |
730 RawPtr<StyleRuleBase> rule = consumeAtRule(range, allowedRules); | 730 StyleRuleBase* rule = consumeAtRule(range, allowedRules); |
731 ASSERT_UNUSED(rule, !rule); | 731 ASSERT_UNUSED(rule, !rule); |
732 break; | 732 break; |
733 } | 733 } |
734 default: // Parse error, unexpected token in declaration list | 734 default: // Parse error, unexpected token in declaration list |
735 while (!range.atEnd() && range.peek().type() != SemicolonToken) | 735 while (!range.atEnd() && range.peek().type() != SemicolonToken) |
736 range.consumeComponentValue(); | 736 range.consumeComponentValue(); |
737 break; | 737 break; |
738 } | 738 } |
739 } | 739 } |
740 | 740 |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
787 | 787 |
788 if (m_observerWrapper && (ruleType == StyleRule::Style || ruleType == StyleR
ule::Keyframe)) { | 788 if (m_observerWrapper && (ruleType == StyleRule::Style || ruleType == StyleR
ule::Keyframe)) { |
789 m_observerWrapper->observer().observeProperty( | 789 m_observerWrapper->observer().observeProperty( |
790 m_observerWrapper->startOffset(rangeCopy), m_observerWrapper->endOff
set(rangeCopy), | 790 m_observerWrapper->startOffset(rangeCopy), m_observerWrapper->endOff
set(rangeCopy), |
791 important, m_parsedProperties.size() != propertiesCount); | 791 important, m_parsedProperties.size() != propertiesCount); |
792 } | 792 } |
793 } | 793 } |
794 | 794 |
795 void CSSParserImpl::consumeVariableValue(CSSParserTokenRange range, const Atomic
String& variableName, bool important) | 795 void CSSParserImpl::consumeVariableValue(CSSParserTokenRange range, const Atomic
String& variableName, bool important) |
796 { | 796 { |
797 if (RawPtr<CSSCustomPropertyDeclaration> value = CSSVariableParser::parseDec
larationValue(variableName, range)) | 797 if (CSSCustomPropertyDeclaration* value = CSSVariableParser::parseDeclaratio
nValue(variableName, range)) |
798 m_parsedProperties.append(CSSProperty(CSSPropertyVariable, value.release
(), important)); | 798 m_parsedProperties.append(CSSProperty(CSSPropertyVariable, value, import
ant)); |
799 } | 799 } |
800 | 800 |
801 void CSSParserImpl::consumeDeclarationValue(CSSParserTokenRange range, CSSProper
tyID unresolvedProperty, bool important, StyleRule::RuleType ruleType) | 801 void CSSParserImpl::consumeDeclarationValue(CSSParserTokenRange range, CSSProper
tyID unresolvedProperty, bool important, StyleRule::RuleType ruleType) |
802 { | 802 { |
803 CSSPropertyParser::parseValue(unresolvedProperty, important, range, m_contex
t, m_parsedProperties, ruleType); | 803 CSSPropertyParser::parseValue(unresolvedProperty, important, range, m_contex
t, m_parsedProperties, ruleType); |
804 } | 804 } |
805 | 805 |
806 PassOwnPtr<Vector<double>> CSSParserImpl::consumeKeyframeKeyList(CSSParserTokenR
ange range) | 806 PassOwnPtr<Vector<double>> CSSParserImpl::consumeKeyframeKeyList(CSSParserTokenR
ange range) |
807 { | 807 { |
808 OwnPtr<Vector<double>> result = adoptPtr(new Vector<double>); | 808 OwnPtr<Vector<double>> result = adoptPtr(new Vector<double>); |
809 while (true) { | 809 while (true) { |
810 range.consumeWhitespace(); | 810 range.consumeWhitespace(); |
811 const CSSParserToken& token = range.consumeIncludingWhitespace(); | 811 const CSSParserToken& token = range.consumeIncludingWhitespace(); |
812 if (token.type() == PercentageToken && token.numericValue() >= 0 && toke
n.numericValue() <= 100) | 812 if (token.type() == PercentageToken && token.numericValue() >= 0 && toke
n.numericValue() <= 100) |
813 result->append(token.numericValue() / 100); | 813 result->append(token.numericValue() / 100); |
814 else if (token.type() == IdentToken && token.valueEqualsIgnoringASCIICas
e("from")) | 814 else if (token.type() == IdentToken && token.valueEqualsIgnoringASCIICas
e("from")) |
815 result->append(0); | 815 result->append(0); |
816 else if (token.type() == IdentToken && token.valueEqualsIgnoringASCIICas
e("to")) | 816 else if (token.type() == IdentToken && token.valueEqualsIgnoringASCIICas
e("to")) |
817 result->append(1); | 817 result->append(1); |
818 else | 818 else |
819 return nullptr; // Parser error, invalid value in keyframe selector | 819 return nullptr; // Parser error, invalid value in keyframe selector |
820 if (range.atEnd()) | 820 if (range.atEnd()) |
821 return result.release(); | 821 return result.release(); |
822 if (range.consume().type() != CommaToken) | 822 if (range.consume().type() != CommaToken) |
823 return nullptr; // Parser error | 823 return nullptr; // Parser error |
824 } | 824 } |
825 } | 825 } |
826 | 826 |
827 } // namespace blink | 827 } // namespace blink |
OLD | NEW |