1 /* 2 * Copyright (C) 2003 Lars Knoll (knoll (at) kde.org) 3 * Copyright (C) 2005 Allan Sandfeld Jensen (kde (at) carewolf.com) 4 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved. 5 * Copyright (C) 2007 Nicholas Shanks <webkit (at) nickshanks.com> 6 * Copyright (C) 2008 Eric Seidel <eric (at) webkit.org> 7 * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/) 8 * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved. 9 * Copyright (C) 2012 Intel Corporation. All rights reserved. 10 * 11 * This library is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU Library General Public 13 * License as published by the Free Software Foundation; either 14 * version 2 of the License, or (at your option) any later version. 15 * 16 * This library is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 * Library General Public License for more details. 20 * 21 * You should have received a copy of the GNU Library General Public License 22 * along with this library; see the file COPYING.LIB. If not, write to 23 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 24 * Boston, MA 02110-1301, USA. 25 */ 26 27 #include "config.h" 28 #include "core/css/parser/BisonCSSParser.h" 29 30 #include "core/CSSValueKeywords.h" 31 #include "core/MediaTypeNames.h" 32 #include "core/StylePropertyShorthand.h" 33 #include "core/css/CSSAspectRatioValue.h" 34 #include "core/css/CSSBasicShapes.h" 35 #include "core/css/CSSBorderImage.h" 36 #include "core/css/CSSCanvasValue.h" 37 #include "core/css/CSSCrossfadeValue.h" 38 #include "core/css/CSSCursorImageValue.h" 39 #include "core/css/CSSFontFaceSrcValue.h" 40 #include "core/css/CSSFontFeatureValue.h" 41 #include "core/css/CSSFunctionValue.h" 42 #include "core/css/CSSGradientValue.h" 43 #include "core/css/CSSGridLineNamesValue.h" 44 #include "core/css/CSSGridTemplateAreasValue.h" 45 #include "core/css/CSSImageSetValue.h" 46 #include "core/css/CSSImageValue.h" 47 #include "core/css/CSSInheritedValue.h" 48 #include "core/css/CSSInitialValue.h" 49 #include "core/css/CSSKeyframeRule.h" 50 #include "core/css/CSSKeyframesRule.h" 51 #include "core/css/CSSLineBoxContainValue.h" 52 #include "core/css/CSSPrimitiveValue.h" 53 #include "core/css/CSSPropertySourceData.h" 54 #include "core/css/CSSReflectValue.h" 55 #include "core/css/CSSSelector.h" 56 #include "core/css/CSSShadowValue.h" 57 #include "core/css/CSSStyleSheet.h" 58 #include "core/css/CSSTimingFunctionValue.h" 59 #include "core/css/CSSTransformValue.h" 60 #include "core/css/CSSUnicodeRangeValue.h" 61 #include "core/css/CSSValueList.h" 62 #include "core/css/CSSValuePool.h" 63 #include "core/css/Counter.h" 64 #include "core/css/HashTools.h" 65 #include "core/css/MediaList.h" 66 #include "core/css/MediaQueryExp.h" 67 #include "core/css/Pair.h" 68 #include "core/css/Rect.h" 69 #include "core/css/StylePropertySet.h" 70 #include "core/css/StyleRule.h" 71 #include "core/css/StyleRuleImport.h" 72 #include "core/css/StyleSheetContents.h" 73 #include "core/css/parser/CSSParserIdioms.h" 74 #include "core/dom/Document.h" 75 #include "core/frame/FrameConsole.h" 76 #include "core/frame/FrameHost.h" 77 #include "core/frame/Settings.h" 78 #include "core/frame/UseCounter.h" 79 #include "core/html/parser/HTMLParserIdioms.h" 80 #include "core/inspector/ConsoleMessage.h" 81 #include "core/inspector/InspectorInstrumentation.h" 82 #include "core/rendering/RenderTheme.h" 83 #include "platform/FloatConversion.h" 84 #include "platform/RuntimeEnabledFeatures.h" 85 #include "wtf/BitArray.h" 86 #include "wtf/HexNumber.h" 87 #include "wtf/text/StringBuffer.h" 88 #include "wtf/text/StringBuilder.h" 89 #include "wtf/text/StringImpl.h" 90 #include "wtf/text/TextEncoding.h" 91 #include <limits.h> 92 93 #define YYDEBUG 0 94 95 #if YYDEBUG > 0 96 extern int cssyydebug; 97 #endif 98 99 int cssyyparse(blink::BisonCSSParser*); 100 101 using namespace WTF; 102 103 namespace blink { 104 105 static const unsigned INVALID_NUM_PARSED_PROPERTIES = UINT_MAX; 106 107 BisonCSSParser::BisonCSSParser(const CSSParserContext& context) 108 : m_context(context) 109 , m_important(false) 110 , m_id(CSSPropertyInvalid) 111 , m_styleSheet(nullptr) 112 , m_supportsCondition(false) 113 , m_selectorListForParseSelector(0) 114 , m_numParsedPropertiesBeforeMarginBox(INVALID_NUM_PARSED_PROPERTIES) 115 , m_hadSyntacticallyValidCSSRule(false) 116 , m_logErrors(false) 117 , m_ignoreErrors(false) 118 , m_defaultNamespace(starAtom) 119 , m_observer(0) 120 , m_source(0) 121 , m_ruleHeaderType(CSSRuleSourceData::UNKNOWN_RULE) 122 , m_allowImportRules(true) 123 , m_allowNamespaceDeclarations(true) 124 , m_inViewport(false) 125 , m_tokenizer(*this) 126 { 127 #if YYDEBUG > 0 128 cssyydebug = 1; 129 #endif 130 } 131 132 BisonCSSParser::~BisonCSSParser() 133 { 134 clearProperties(); 135 136 deleteAllValues(m_floatingSelectors); 137 deleteAllValues(m_floatingSelectorVectors); 138 deleteAllValues(m_floatingValueLists); 139 deleteAllValues(m_floatingFunctions); 140 } 141 142 void BisonCSSParser::setupParser(const char* prefix, unsigned prefixLength, const String& string, const char* suffix, unsigned suffixLength) 143 { 144 m_tokenizer.setupTokenizer(prefix, prefixLength, string, suffix, suffixLength); 145 m_ruleHasHeader = true; 146 } 147 148 void BisonCSSParser::parseSheet(StyleSheetContents* sheet, const String& string, const TextPosition& startPosition, CSSParserObserver* observer, bool logErrors) 149 { 150 setStyleSheet(sheet); 151 m_defaultNamespace = starAtom; // Reset the default namespace. 152 TemporaryChange<CSSParserObserver*> scopedObsever(m_observer, observer); 153 m_logErrors = logErrors && sheet->singleOwnerDocument() && !sheet->baseURL().isEmpty() && sheet->singleOwnerDocument()->frameHost(); 154 m_ignoreErrors = false; 155 m_tokenizer.m_lineNumber = 0; 156 m_startPosition = startPosition; 157 m_source = &string; 158 m_tokenizer.m_internal = false; 159 setupParser("", string, ""); 160 cssyyparse(this); 161 sheet->shrinkToFit(); 162 m_source = 0; 163 m_rule = nullptr; 164 m_lineEndings.clear(); 165 m_ignoreErrors = false; 166 m_logErrors = false; 167 m_tokenizer.m_internal = true; 168 } 169 170 PassRefPtrWillBeRawPtr<StyleRuleBase> BisonCSSParser::parseRule(StyleSheetContents* sheet, const String& string) 171 { 172 setStyleSheet(sheet); 173 m_allowNamespaceDeclarations = false; 174 setupParser("@-internal-rule ", string, ""); 175 cssyyparse(this); 176 return m_rule.release(); 177 } 178 179 PassRefPtrWillBeRawPtr<StyleKeyframe> BisonCSSParser::parseKeyframeRule(StyleSheetContents* sheet, const String& string) 180 { 181 setStyleSheet(sheet); 182 setupParser("@-internal-keyframe-rule ", string, ""); 183 cssyyparse(this); 184 return m_keyframe.release(); 185 } 186 187 PassOwnPtr<Vector<double> > BisonCSSParser::parseKeyframeKeyList(const String& string) 188 { 189 setupParser("@-internal-keyframe-key-list ", string, ""); 190 cssyyparse(this); 191 ASSERT(m_valueList); 192 return StyleKeyframe::createKeyList(m_valueList.get()); 193 } 194 195 bool BisonCSSParser::parseSupportsCondition(const String& string) 196 { 197 m_supportsCondition = false; 198 setupParser("@-internal-supports-condition ", string, ""); 199 cssyyparse(this); 200 return m_supportsCondition; 201 } 202 203 static inline bool isColorPropertyID(CSSPropertyID propertyId) 204 { 205 switch (propertyId) { 206 case CSSPropertyColor: 207 case CSSPropertyBackgroundColor: 208 case CSSPropertyBorderBottomColor: 209 case CSSPropertyBorderLeftColor: 210 case CSSPropertyBorderRightColor: 211 case CSSPropertyBorderTopColor: 212 case CSSPropertyOutlineColor: 213 case CSSPropertyWebkitBorderAfterColor: 214 case CSSPropertyWebkitBorderBeforeColor: 215 case CSSPropertyWebkitBorderEndColor: 216 case CSSPropertyWebkitBorderStartColor: 217 case CSSPropertyWebkitColumnRuleColor: 218 case CSSPropertyWebkitTextEmphasisColor: 219 case CSSPropertyWebkitTextFillColor: 220 case CSSPropertyWebkitTextStrokeColor: 221 case CSSPropertyTextDecorationColor: 222 return true; 223 default: 224 return false; 225 } 226 } 227 228 static bool parseColorValue(MutableStylePropertySet* declaration, CSSPropertyID propertyId, const String& string, bool important, CSSParserMode cssParserMode) 229 { 230 ASSERT(!string.isEmpty()); 231 bool quirksMode = isQuirksModeBehavior(cssParserMode); 232 if (!isColorPropertyID(propertyId)) 233 return false; 234 CSSParserString cssString; 235 cssString.init(string); 236 CSSValueID valueID = cssValueKeywordID(cssString); 237 bool validPrimitive = false; 238 if (valueID == CSSValueWebkitText) { 239 validPrimitive = true; 240 } else if (valueID == CSSValueCurrentcolor) { 241 validPrimitive = true; 242 } else if ((valueID >= CSSValueAqua && valueID <= CSSValueWindowtext) || valueID == CSSValueMenu 243 || (quirksMode && valueID >= CSSValueWebkitFocusRingColor && valueID < CSSValueWebkitText)) { 244 validPrimitive = true; 245 } 246 247 if (validPrimitive) { 248 RefPtrWillBeRawPtr<CSSValue> value = cssValuePool().createIdentifierValue(valueID); 249 declaration->addParsedProperty(CSSProperty(propertyId, value.release(), important)); 250 return true; 251 } 252 RGBA32 color; 253 if (!CSSPropertyParser::fastParseColor(color, string, !quirksMode && string[0] != '#')) 254 return false; 255 RefPtrWillBeRawPtr<CSSValue> value = cssValuePool().createColorValue(color); 256 declaration->addParsedProperty(CSSProperty(propertyId, value.release(), important)); 257 return true; 258 } 259 260 static inline bool isSimpleLengthPropertyID(CSSPropertyID propertyId, bool& acceptsNegativeNumbers) 261 { 262 switch (propertyId) { 263 case CSSPropertyFontSize: 264 case CSSPropertyHeight: 265 case CSSPropertyWidth: 266 case CSSPropertyMinHeight: 267 case CSSPropertyMinWidth: 268 case CSSPropertyPaddingBottom: 269 case CSSPropertyPaddingLeft: 270 case CSSPropertyPaddingRight: 271 case CSSPropertyPaddingTop: 272 case CSSPropertyWebkitLogicalWidth: 273 case CSSPropertyWebkitLogicalHeight: 274 case CSSPropertyWebkitMinLogicalWidth: 275 case CSSPropertyWebkitMinLogicalHeight: 276 case CSSPropertyWebkitPaddingAfter: 277 case CSSPropertyWebkitPaddingBefore: 278 case CSSPropertyWebkitPaddingEnd: 279 case CSSPropertyWebkitPaddingStart: 280 acceptsNegativeNumbers = false; 281 return true; 282 case CSSPropertyShapeMargin: 283 acceptsNegativeNumbers = false; 284 return true; 285 case CSSPropertyBottom: 286 case CSSPropertyLeft: 287 case CSSPropertyMarginBottom: 288 case CSSPropertyMarginLeft: 289 case CSSPropertyMarginRight: 290 case CSSPropertyMarginTop: 291 case CSSPropertyRight: 292 case CSSPropertyTop: 293 case CSSPropertyWebkitMarginAfter: 294 case CSSPropertyWebkitMarginBefore: 295 case CSSPropertyWebkitMarginEnd: 296 case CSSPropertyWebkitMarginStart: 297 acceptsNegativeNumbers = true; 298 return true; 299 default: 300 return false; 301 } 302 } 303 304 template <typename CharacterType> 305 static inline bool parseSimpleLength(const CharacterType* characters, unsigned length, CSSPrimitiveValue::UnitType& unit, double& number) 306 { 307 if (length > 2 && (characters[length - 2] | 0x20) == 'p' && (characters[length - 1] | 0x20) == 'x') { 308 length -= 2; 309 unit = CSSPrimitiveValue::CSS_PX; 310 } else if (length > 1 && characters[length - 1] == '%') { 311 length -= 1; 312 unit = CSSPrimitiveValue::CSS_PERCENTAGE; 313 } 314 315 // We rely on charactersToDouble for validation as well. The function 316 // will set "ok" to "false" if the entire passed-in character range does 317 // not represent a double. 318 bool ok; 319 number = charactersToDouble(characters, length, &ok); 320 return ok; 321 } 322 323 static bool parseSimpleLengthValue(MutableStylePropertySet* declaration, CSSPropertyID propertyId, const String& string, bool important, CSSParserMode cssParserMode) 324 { 325 ASSERT(!string.isEmpty()); 326 bool acceptsNegativeNumbers = false; 327 328 // In @viewport, width and height are shorthands, not simple length values. 329 if (isCSSViewportParsingEnabledForMode(cssParserMode) || !isSimpleLengthPropertyID(propertyId, acceptsNegativeNumbers)) 330 return false; 331 332 unsigned length = string.length(); 333 double number; 334 CSSPrimitiveValue::UnitType unit = CSSPrimitiveValue::CSS_NUMBER; 335 336 if (string.is8Bit()) { 337 if (!parseSimpleLength(string.characters8(), length, unit, number)) 338 return false; 339 } else { 340 if (!parseSimpleLength(string.characters16(), length, unit, number)) 341 return false; 342 } 343 344 if (unit == CSSPrimitiveValue::CSS_NUMBER) { 345 bool quirksMode = isQuirksModeBehavior(cssParserMode); 346 if (number && !quirksMode) 347 return false; 348 unit = CSSPrimitiveValue::CSS_PX; 349 } 350 if (number < 0 && !acceptsNegativeNumbers) 351 return false; 352 353 RefPtrWillBeRawPtr<CSSValue> value = cssValuePool().createValue(number, unit); 354 declaration->addParsedProperty(CSSProperty(propertyId, value.release(), important)); 355 return true; 356 } 357 358 bool isValidKeywordPropertyAndValue(CSSPropertyID propertyId, CSSValueID valueID, const CSSParserContext& parserContext) 359 { 360 if (valueID == CSSValueInvalid) 361 return false; 362 363 switch (propertyId) { 364 case CSSPropertyAll: 365 return valueID == CSSValueUnset; 366 case CSSPropertyBackgroundRepeatX: // repeat | no-repeat 367 case CSSPropertyBackgroundRepeatY: // repeat | no-repeat 368 return valueID == CSSValueRepeat || valueID == CSSValueNoRepeat; 369 case CSSPropertyBorderCollapse: // collapse | separate 370 return valueID == CSSValueCollapse || valueID == CSSValueSeparate; 371 case CSSPropertyBorderTopStyle: // <border-style> 372 case CSSPropertyBorderRightStyle: // Defined as: none | hidden | dotted | dashed | 373 case CSSPropertyBorderBottomStyle: // solid | double | groove | ridge | inset | outset 374 case CSSPropertyBorderLeftStyle: 375 case CSSPropertyWebkitBorderAfterStyle: 376 case CSSPropertyWebkitBorderBeforeStyle: 377 case CSSPropertyWebkitBorderEndStyle: 378 case CSSPropertyWebkitBorderStartStyle: 379 case CSSPropertyWebkitColumnRuleStyle: 380 return valueID >= CSSValueNone && valueID <= CSSValueDouble; 381 case CSSPropertyBoxSizing: 382 return valueID == CSSValueBorderBox || valueID == CSSValueContentBox; 383 case CSSPropertyCaptionSide: // top | bottom | left | right 384 return valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueTop || valueID == CSSValueBottom; 385 case CSSPropertyClear: // none | left | right | both 386 return valueID == CSSValueNone || valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueBoth; 387 case CSSPropertyDirection: // ltr | rtl 388 return valueID == CSSValueLtr || valueID == CSSValueRtl; 389 case CSSPropertyDisplay: 390 // inline | block | list-item | inline-block | table | 391 // inline-table | table-row-group | table-header-group | table-footer-group | table-row | 392 // table-column-group | table-column | table-cell | table-caption | -webkit-box | -webkit-inline-box | none 393 // flex | inline-flex | -webkit-flex | -webkit-inline-flex | grid | inline-grid 394 return (valueID >= CSSValueInline && valueID <= CSSValueInlineFlex) || valueID == CSSValueWebkitFlex || valueID == CSSValueWebkitInlineFlex || valueID == CSSValueNone 395 || (RuntimeEnabledFeatures::cssGridLayoutEnabled() && (valueID == CSSValueGrid || valueID == CSSValueInlineGrid)); 396 case CSSPropertyEmptyCells: // show | hide 397 return valueID == CSSValueShow || valueID == CSSValueHide; 398 case CSSPropertyFloat: // left | right | none | center (for buggy CSS, maps to none) 399 return valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueNone || valueID == CSSValueCenter; 400 case CSSPropertyFontStyle: // normal | italic | oblique 401 return valueID == CSSValueNormal || valueID == CSSValueItalic || valueID == CSSValueOblique; 402 case CSSPropertyFontStretch: // normal | ultra-condensed | extra-condensed | condensed | semi-condensed | semi-expanded | expanded | extra-expanded | ultra-expanded 403 return valueID == CSSValueNormal || (valueID >= CSSValueUltraCondensed && valueID <= CSSValueUltraExpanded); 404 case CSSPropertyImageRendering: // auto | optimizeContrast | pixelated 405 return valueID == CSSValueAuto || valueID == CSSValueWebkitOptimizeContrast || (RuntimeEnabledFeatures::imageRenderingPixelatedEnabled() && valueID == CSSValuePixelated); 406 case CSSPropertyIsolation: // auto | isolate 407 ASSERT(RuntimeEnabledFeatures::cssCompositingEnabled()); 408 return valueID == CSSValueAuto || valueID == CSSValueIsolate; 409 case CSSPropertyListStylePosition: // inside | outside 410 return valueID == CSSValueInside || valueID == CSSValueOutside; 411 case CSSPropertyListStyleType: 412 // See section CSS_PROP_LIST_STYLE_TYPE of file CSSValueKeywords.in 413 // for the list of supported list-style-types. 414 return (valueID >= CSSValueDisc && valueID <= CSSValueKatakanaIroha) || valueID == CSSValueNone; 415 case CSSPropertyObjectFit: 416 return valueID == CSSValueFill || valueID == CSSValueContain || valueID == CSSValueCover || valueID == CSSValueNone || valueID == CSSValueScaleDown; 417 case CSSPropertyOutlineStyle: // (<border-style> except hidden) | auto 418 return valueID == CSSValueAuto || valueID == CSSValueNone || (valueID >= CSSValueInset && valueID <= CSSValueDouble); 419 case CSSPropertyOverflowWrap: // normal | break-word 420 case CSSPropertyWordWrap: 421 return valueID == CSSValueNormal || valueID == CSSValueBreakWord; 422 case CSSPropertyOverflowX: // visible | hidden | scroll | auto | overlay 423 return valueID == CSSValueVisible || valueID == CSSValueHidden || valueID == CSSValueScroll || valueID == CSSValueAuto || valueID == CSSValueOverlay; 424 case CSSPropertyOverflowY: // visible | hidden | scroll | auto | overlay | -webkit-paged-x | -webkit-paged-y 425 return valueID == CSSValueVisible || valueID == CSSValueHidden || valueID == CSSValueScroll || valueID == CSSValueAuto || valueID == CSSValueOverlay || valueID == CSSValueWebkitPagedX || valueID == CSSValueWebkitPagedY; 426 case CSSPropertyPageBreakAfter: // auto | always | avoid | left | right 427 case CSSPropertyPageBreakBefore: 428 case CSSPropertyWebkitColumnBreakAfter: 429 case CSSPropertyWebkitColumnBreakBefore: 430 return valueID == CSSValueAuto || valueID == CSSValueAlways || valueID == CSSValueAvoid || valueID == CSSValueLeft || valueID == CSSValueRight; 431 case CSSPropertyPageBreakInside: // avoid | auto 432 case CSSPropertyWebkitColumnBreakInside: 433 return valueID == CSSValueAuto || valueID == CSSValueAvoid; 434 case CSSPropertyPointerEvents: 435 // none | visiblePainted | visibleFill | visibleStroke | visible | 436 // painted | fill | stroke | auto | all | bounding-box 437 return valueID == CSSValueVisible || valueID == CSSValueNone || valueID == CSSValueAll || valueID == CSSValueAuto || (valueID >= CSSValueVisiblepainted && valueID <= CSSValueBoundingBox); 438 case CSSPropertyPosition: // static | relative | absolute | fixed 439 return valueID == CSSValueStatic || valueID == CSSValueRelative || valueID == CSSValueAbsolute || valueID == CSSValueFixed; 440 case CSSPropertyResize: // none | both | horizontal | vertical | auto 441 return valueID == CSSValueNone || valueID == CSSValueBoth || valueID == CSSValueHorizontal || valueID == CSSValueVertical || valueID == CSSValueAuto; 442 case CSSPropertyScrollBehavior: // instant | smooth 443 ASSERT(RuntimeEnabledFeatures::cssomSmoothScrollEnabled()); 444 return valueID == CSSValueInstant || valueID == CSSValueSmooth; 445 case CSSPropertySpeak: // none | normal | spell-out | digits | literal-punctuation | no-punctuation 446 return valueID == CSSValueNone || valueID == CSSValueNormal || valueID == CSSValueSpellOut || valueID == CSSValueDigits || valueID == CSSValueLiteralPunctuation || valueID == CSSValueNoPunctuation; 447 case CSSPropertyTableLayout: // auto | fixed 448 return valueID == CSSValueAuto || valueID == CSSValueFixed; 449 case CSSPropertyTextAlignLast: 450 // auto | start | end | left | right | center | justify 451 ASSERT(RuntimeEnabledFeatures::css3TextEnabled()); 452 return (valueID >= CSSValueLeft && valueID <= CSSValueJustify) || valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueAuto; 453 case CSSPropertyTextDecorationStyle: 454 // solid | double | dotted | dashed | wavy 455 ASSERT(RuntimeEnabledFeatures::css3TextDecorationsEnabled()); 456 return valueID == CSSValueSolid || valueID == CSSValueDouble || valueID == CSSValueDotted || valueID == CSSValueDashed || valueID == CSSValueWavy; 457 case CSSPropertyTextJustify: 458 // auto | none | inter-word | distribute 459 ASSERT(RuntimeEnabledFeatures::css3TextEnabled()); 460 return valueID == CSSValueInterWord || valueID == CSSValueDistribute || valueID == CSSValueAuto || valueID == CSSValueNone; 461 case CSSPropertyTextOverflow: // clip | ellipsis 462 return valueID == CSSValueClip || valueID == CSSValueEllipsis; 463 case CSSPropertyTextRendering: // auto | optimizeSpeed | optimizeLegibility | geometricPrecision 464 return valueID == CSSValueAuto || valueID == CSSValueOptimizespeed || valueID == CSSValueOptimizelegibility || valueID == CSSValueGeometricprecision; 465 case CSSPropertyTextTransform: // capitalize | uppercase | lowercase | none 466 return (valueID >= CSSValueCapitalize && valueID <= CSSValueLowercase) || valueID == CSSValueNone; 467 case CSSPropertyUnicodeBidi: 468 return valueID == CSSValueNormal || valueID == CSSValueEmbed 469 || valueID == CSSValueBidiOverride || valueID == CSSValueWebkitIsolate 470 || valueID == CSSValueWebkitIsolateOverride || valueID == CSSValueWebkitPlaintext; 471 case CSSPropertyTouchActionDelay: // none | script 472 ASSERT(RuntimeEnabledFeatures::cssTouchActionDelayEnabled()); 473 return valueID == CSSValueScript || valueID == CSSValueNone; 474 case CSSPropertyVisibility: // visible | hidden | collapse 475 return valueID == CSSValueVisible || valueID == CSSValueHidden || valueID == CSSValueCollapse; 476 case CSSPropertyWebkitAppearance: 477 return (valueID >= CSSValueCheckbox && valueID <= CSSValueTextarea) || valueID == CSSValueNone; 478 case CSSPropertyBackfaceVisibility: 479 case CSSPropertyWebkitBackfaceVisibility: 480 return valueID == CSSValueVisible || valueID == CSSValueHidden; 481 case CSSPropertyMixBlendMode: 482 ASSERT(RuntimeEnabledFeatures::cssCompositingEnabled()); 483 return valueID == CSSValueNormal || valueID == CSSValueMultiply || valueID == CSSValueScreen || valueID == CSSValueOverlay 484 || valueID == CSSValueDarken || valueID == CSSValueLighten || valueID == CSSValueColorDodge || valueID == CSSValueColorBurn 485 || valueID == CSSValueHardLight || valueID == CSSValueSoftLight || valueID == CSSValueDifference || valueID == CSSValueExclusion 486 || valueID == CSSValueHue || valueID == CSSValueSaturation || valueID == CSSValueColor || valueID == CSSValueLuminosity; 487 case CSSPropertyWebkitBorderFit: 488 return valueID == CSSValueBorder || valueID == CSSValueLines; 489 case CSSPropertyWebkitBoxAlign: 490 return valueID == CSSValueStretch || valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline; 491 case CSSPropertyWebkitBoxDecorationBreak: 492 return valueID == CSSValueClone || valueID == CSSValueSlice; 493 case CSSPropertyWebkitBoxDirection: 494 return valueID == CSSValueNormal || valueID == CSSValueReverse; 495 case CSSPropertyWebkitBoxLines: 496 return valueID == CSSValueSingle || valueID == CSSValueMultiple; 497 case CSSPropertyWebkitBoxOrient: 498 return valueID == CSSValueHorizontal || valueID == CSSValueVertical || valueID == CSSValueInlineAxis || valueID == CSSValueBlockAxis; 499 case CSSPropertyWebkitBoxPack: 500 return valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueCenter || valueID == CSSValueJustify; 501 case CSSPropertyColumnFill: 502 ASSERT(RuntimeEnabledFeatures::regionBasedColumnsEnabled()); 503 return valueID == CSSValueAuto || valueID == CSSValueBalance; 504 case CSSPropertyAlignContent: 505 // FIXME: Per CSS alignment, this property should accept an optional <overflow-position>. We should share this parsing code with 'justify-self'. 506 return valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueSpaceBetween || valueID == CSSValueSpaceAround || valueID == CSSValueStretch; 507 case CSSPropertyAlignItems: 508 // FIXME: Per CSS alignment, this property should accept the same arguments as 'justify-self' so we should share its parsing code. 509 return valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline || valueID == CSSValueStretch; 510 case CSSPropertyAlignSelf: 511 // FIXME: Per CSS alignment, this property should accept the same arguments as 'justify-self' so we should share its parsing code. 512 return valueID == CSSValueAuto || valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline || valueID == CSSValueStretch; 513 case CSSPropertyFlexDirection: 514 return valueID == CSSValueRow || valueID == CSSValueRowReverse || valueID == CSSValueColumn || valueID == CSSValueColumnReverse; 515 case CSSPropertyFlexWrap: 516 return valueID == CSSValueNowrap || valueID == CSSValueWrap || valueID == CSSValueWrapReverse; 517 case CSSPropertyJustifyContent: 518 // FIXME: Per CSS alignment, this property should accept an optional <overflow-position>. We should share this parsing code with 'justify-self'. 519 return valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueSpaceBetween || valueID == CSSValueSpaceAround; 520 case CSSPropertyFontKerning: 521 return valueID == CSSValueAuto || valueID == CSSValueNormal || valueID == CSSValueNone; 522 case CSSPropertyWebkitFontSmoothing: 523 return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueAntialiased || valueID == CSSValueSubpixelAntialiased; 524 case CSSPropertyWebkitLineBreak: // auto | loose | normal | strict | after-white-space 525 return valueID == CSSValueAuto || valueID == CSSValueLoose || valueID == CSSValueNormal || valueID == CSSValueStrict || valueID == CSSValueAfterWhiteSpace; 526 case CSSPropertyWebkitMarginAfterCollapse: 527 case CSSPropertyWebkitMarginBeforeCollapse: 528 case CSSPropertyWebkitMarginBottomCollapse: 529 case CSSPropertyWebkitMarginTopCollapse: 530 return valueID == CSSValueCollapse || valueID == CSSValueSeparate || valueID == CSSValueDiscard; 531 case CSSPropertyInternalMarqueeDirection: 532 return valueID == CSSValueForwards || valueID == CSSValueBackwards || valueID == CSSValueAhead || valueID == CSSValueReverse || valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueDown 533 || valueID == CSSValueUp || valueID == CSSValueAuto; 534 case CSSPropertyInternalMarqueeStyle: 535 return valueID == CSSValueNone || valueID == CSSValueSlide || valueID == CSSValueScroll || valueID == CSSValueAlternate; 536 case CSSPropertyWebkitPrintColorAdjust: 537 return valueID == CSSValueExact || valueID == CSSValueEconomy; 538 case CSSPropertyWebkitRtlOrdering: 539 return valueID == CSSValueLogical || valueID == CSSValueVisual; 540 case CSSPropertyWebkitRubyPosition: 541 return valueID == CSSValueBefore || valueID == CSSValueAfter; 542 case CSSPropertyWebkitTextCombine: 543 return valueID == CSSValueNone || valueID == CSSValueHorizontal; 544 case CSSPropertyWebkitTextEmphasisPosition: 545 return valueID == CSSValueOver || valueID == CSSValueUnder; 546 case CSSPropertyWebkitTextSecurity: // disc | circle | square | none 547 return valueID == CSSValueDisc || valueID == CSSValueCircle || valueID == CSSValueSquare || valueID == CSSValueNone; 548 case CSSPropertyTransformStyle: 549 case CSSPropertyWebkitTransformStyle: 550 return valueID == CSSValueFlat || valueID == CSSValuePreserve3d; 551 case CSSPropertyWebkitUserDrag: // auto | none | element 552 return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueElement; 553 case CSSPropertyWebkitUserModify: // read-only | read-write 554 return valueID == CSSValueReadOnly || valueID == CSSValueReadWrite || valueID == CSSValueReadWritePlaintextOnly; 555 case CSSPropertyWebkitUserSelect: // auto | none | text | all 556 return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueText || valueID == CSSValueAll; 557 case CSSPropertyWebkitWritingMode: 558 return valueID >= CSSValueHorizontalTb && valueID <= CSSValueHorizontalBt; 559 case CSSPropertyWhiteSpace: // normal | pre | nowrap 560 return valueID == CSSValueNormal || valueID == CSSValuePre || valueID == CSSValuePreWrap || valueID == CSSValuePreLine || valueID == CSSValueNowrap; 561 case CSSPropertyWordBreak: // normal | break-all | break-word (this is a custom extension) 562 return valueID == CSSValueNormal || valueID == CSSValueBreakAll || valueID == CSSValueBreakWord; 563 default: 564 ASSERT_NOT_REACHED(); 565 return false; 566 } 567 return false; 568 } 569 570 bool isKeywordPropertyID(CSSPropertyID propertyId) 571 { 572 switch (propertyId) { 573 case CSSPropertyAll: 574 case CSSPropertyMixBlendMode: 575 case CSSPropertyIsolation: 576 case CSSPropertyBackgroundRepeatX: 577 case CSSPropertyBackgroundRepeatY: 578 case CSSPropertyBorderBottomStyle: 579 case CSSPropertyBorderCollapse: 580 case CSSPropertyBorderLeftStyle: 581 case CSSPropertyBorderRightStyle: 582 case CSSPropertyBorderTopStyle: 583 case CSSPropertyBoxSizing: 584 case CSSPropertyCaptionSide: 585 case CSSPropertyClear: 586 case CSSPropertyDirection: 587 case CSSPropertyDisplay: 588 case CSSPropertyEmptyCells: 589 case CSSPropertyFloat: 590 case CSSPropertyFontStyle: 591 case CSSPropertyFontStretch: 592 case CSSPropertyImageRendering: 593 case CSSPropertyListStylePosition: 594 case CSSPropertyListStyleType: 595 case CSSPropertyObjectFit: 596 case CSSPropertyOutlineStyle: 597 case CSSPropertyOverflowWrap: 598 case CSSPropertyOverflowX: 599 case CSSPropertyOverflowY: 600 case CSSPropertyPageBreakAfter: 601 case CSSPropertyPageBreakBefore: 602 case CSSPropertyPageBreakInside: 603 case CSSPropertyPointerEvents: 604 case CSSPropertyPosition: 605 case CSSPropertyResize: 606 case CSSPropertyScrollBehavior: 607 case CSSPropertySpeak: 608 case CSSPropertyTableLayout: 609 case CSSPropertyTextAlignLast: 610 case CSSPropertyTextDecorationStyle: 611 case CSSPropertyTextJustify: 612 case CSSPropertyTextOverflow: 613 case CSSPropertyTextRendering: 614 case CSSPropertyTextTransform: 615 case CSSPropertyTouchActionDelay: 616 case CSSPropertyUnicodeBidi: 617 case CSSPropertyVisibility: 618 case CSSPropertyWebkitAppearance: 619 case CSSPropertyBackfaceVisibility: 620 case CSSPropertyWebkitBackfaceVisibility: 621 case CSSPropertyWebkitBorderAfterStyle: 622 case CSSPropertyWebkitBorderBeforeStyle: 623 case CSSPropertyWebkitBorderEndStyle: 624 case CSSPropertyWebkitBorderFit: 625 case CSSPropertyWebkitBorderStartStyle: 626 case CSSPropertyWebkitBoxAlign: 627 case CSSPropertyWebkitBoxDecorationBreak: 628 case CSSPropertyWebkitBoxDirection: 629 case CSSPropertyWebkitBoxLines: 630 case CSSPropertyWebkitBoxOrient: 631 case CSSPropertyWebkitBoxPack: 632 case CSSPropertyWebkitColumnBreakAfter: 633 case CSSPropertyWebkitColumnBreakBefore: 634 case CSSPropertyWebkitColumnBreakInside: 635 case CSSPropertyColumnFill: 636 case CSSPropertyWebkitColumnRuleStyle: 637 case CSSPropertyAlignContent: 638 case CSSPropertyFlexDirection: 639 case CSSPropertyFlexWrap: 640 case CSSPropertyJustifyContent: 641 case CSSPropertyFontKerning: 642 case CSSPropertyWebkitFontSmoothing: 643 case CSSPropertyWebkitLineBreak: 644 case CSSPropertyWebkitMarginAfterCollapse: 645 case CSSPropertyWebkitMarginBeforeCollapse: 646 case CSSPropertyWebkitMarginBottomCollapse: 647 case CSSPropertyWebkitMarginTopCollapse: 648 case CSSPropertyInternalMarqueeDirection: 649 case CSSPropertyInternalMarqueeStyle: 650 case CSSPropertyWebkitPrintColorAdjust: 651 case CSSPropertyWebkitRtlOrdering: 652 case CSSPropertyWebkitRubyPosition: 653 case CSSPropertyWebkitTextCombine: 654 case CSSPropertyWebkitTextEmphasisPosition: 655 case CSSPropertyWebkitTextSecurity: 656 case CSSPropertyTransformStyle: 657 case CSSPropertyWebkitTransformStyle: 658 case CSSPropertyWebkitUserDrag: 659 case CSSPropertyWebkitUserModify: 660 case CSSPropertyWebkitUserSelect: 661 case CSSPropertyWebkitWritingMode: 662 case CSSPropertyWhiteSpace: 663 case CSSPropertyWordBreak: 664 case CSSPropertyWordWrap: 665 return true; 666 case CSSPropertyAlignItems: 667 case CSSPropertyAlignSelf: 668 return !RuntimeEnabledFeatures::cssGridLayoutEnabled(); 669 default: 670 return false; 671 } 672 } 673 674 static bool parseKeywordValue(MutableStylePropertySet* declaration, CSSPropertyID propertyId, const String& string, bool important, const CSSParserContext& parserContext) 675 { 676 ASSERT(!string.isEmpty()); 677 678 if (!isKeywordPropertyID(propertyId)) { 679 // All properties accept the values of "initial" and "inherit". 680 String lowerCaseString = string.lower(); 681 if (lowerCaseString != "initial" && lowerCaseString != "inherit") 682 return false; 683 684 // Parse initial/inherit shorthands using the BisonCSSParser. 685 if (shorthandForProperty(propertyId).length()) 686 return false; 687 } 688 689 CSSParserString cssString; 690 cssString.init(string); 691 CSSValueID valueID = cssValueKeywordID(cssString); 692 693 if (!valueID) 694 return false; 695 696 RefPtrWillBeRawPtr<CSSValue> value = nullptr; 697 if (valueID == CSSValueInherit) 698 value = cssValuePool().createInheritedValue(); 699 else if (valueID == CSSValueInitial) 700 value = cssValuePool().createExplicitInitialValue(); 701 else if (isValidKeywordPropertyAndValue(propertyId, valueID, parserContext)) 702 value = cssValuePool().createIdentifierValue(valueID); 703 else 704 return false; 705 706 declaration->addParsedProperty(CSSProperty(propertyId, value.release(), important)); 707 return true; 708 } 709 710 template <typename CharType> 711 static bool parseTransformTranslateArguments(CharType*& pos, CharType* end, unsigned expectedCount, CSSTransformValue* transformValue) 712 { 713 while (expectedCount) { 714 size_t delimiter = WTF::find(pos, end - pos, expectedCount == 1 ? ')' : ','); 715 if (delimiter == kNotFound) 716 return false; 717 unsigned argumentLength = static_cast<unsigned>(delimiter); 718 CSSPrimitiveValue::UnitType unit = CSSPrimitiveValue::CSS_NUMBER; 719 double number; 720 if (!parseSimpleLength(pos, argumentLength, unit, number)) 721 return false; 722 if (unit != CSSPrimitiveValue::CSS_PX && (number || unit != CSSPrimitiveValue::CSS_NUMBER)) 723 return false; 724 transformValue->append(cssValuePool().createValue(number, CSSPrimitiveValue::CSS_PX)); 725 pos += argumentLength + 1; 726 --expectedCount; 727 } 728 return true; 729 } 730 731 template <typename CharType> 732 static bool parseTransformNumberArguments(CharType*& pos, CharType* end, unsigned expectedCount, CSSTransformValue* transformValue) 733 { 734 while (expectedCount) { 735 size_t delimiter = WTF::find(pos, end - pos, expectedCount == 1 ? ')' : ','); 736 if (delimiter == kNotFound) 737 return false; 738 unsigned argumentLength = static_cast<unsigned>(delimiter); 739 bool ok; 740 double number = charactersToDouble(pos, argumentLength, &ok); 741 if (!ok) 742 return false; 743 transformValue->append(cssValuePool().createValue(number, CSSPrimitiveValue::CSS_NUMBER)); 744 pos += argumentLength + 1; 745 --expectedCount; 746 } 747 return true; 748 } 749 750 template <typename CharType> 751 static PassRefPtrWillBeRawPtr<CSSTransformValue> parseSimpleTransformValue(CharType*& pos, CharType* end) 752 { 753 static const int shortestValidTransformStringLength = 12; 754 755 if (end - pos < shortestValidTransformStringLength) 756 return nullptr; 757 758 const bool isTranslate = toASCIILower(pos[0]) == 't' 759 && toASCIILower(pos[1]) == 'r' 760 && toASCIILower(pos[2]) == 'a' 761 && toASCIILower(pos[3]) == 'n' 762 && toASCIILower(pos[4]) == 's' 763 && toASCIILower(pos[5]) == 'l' 764 && toASCIILower(pos[6]) == 'a' 765 && toASCIILower(pos[7]) == 't' 766 && toASCIILower(pos[8]) == 'e'; 767 768 if (isTranslate) { 769 CSSTransformValue::TransformOperationType transformType; 770 unsigned expectedArgumentCount = 1; 771 unsigned argumentStart = 11; 772 CharType c9 = toASCIILower(pos[9]); 773 if (c9 == 'x' && pos[10] == '(') { 774 transformType = CSSTransformValue::TranslateXTransformOperation; 775 } else if (c9 == 'y' && pos[10] == '(') { 776 transformType = CSSTransformValue::TranslateYTransformOperation; 777 } else if (c9 == 'z' && pos[10] == '(') { 778 transformType = CSSTransformValue::TranslateZTransformOperation; 779 } else if (c9 == '(') { 780 transformType = CSSTransformValue::TranslateTransformOperation; 781 expectedArgumentCount = 2; 782 argumentStart = 10; 783 } else if (c9 == '3' && toASCIILower(pos[10]) == 'd' && pos[11] == '(') { 784 transformType = CSSTransformValue::Translate3DTransformOperation; 785 expectedArgumentCount = 3; 786 argumentStart = 12; 787 } else { 788 return nullptr; 789 } 790 pos += argumentStart; 791 RefPtrWillBeRawPtr<CSSTransformValue> transformValue = CSSTransformValue::create(transformType); 792 if (!parseTransformTranslateArguments(pos, end, expectedArgumentCount, transformValue.get())) 793 return nullptr; 794 return transformValue.release(); 795 } 796 797 const bool isMatrix3d = toASCIILower(pos[0]) == 'm' 798 && toASCIILower(pos[1]) == 'a' 799 && toASCIILower(pos[2]) == 't' 800 && toASCIILower(pos[3]) == 'r' 801 && toASCIILower(pos[4]) == 'i' 802 && toASCIILower(pos[5]) == 'x' 803 && pos[6] == '3' 804 && toASCIILower(pos[7]) == 'd' 805 && pos[8] == '('; 806 807 if (isMatrix3d) { 808 pos += 9; 809 RefPtrWillBeRawPtr<CSSTransformValue> transformValue = CSSTransformValue::create(CSSTransformValue::Matrix3DTransformOperation); 810 if (!parseTransformNumberArguments(pos, end, 16, transformValue.get())) 811 return nullptr; 812 return transformValue.release(); 813 } 814 815 const bool isScale3d = toASCIILower(pos[0]) == 's' 816 && toASCIILower(pos[1]) == 'c' 817 && toASCIILower(pos[2]) == 'a' 818 && toASCIILower(pos[3]) == 'l' 819 && toASCIILower(pos[4]) == 'e' 820 && pos[5] == '3' 821 && toASCIILower(pos[6]) == 'd' 822 && pos[7] == '('; 823 824 if (isScale3d) { 825 pos += 8; 826 RefPtrWillBeRawPtr<CSSTransformValue> transformValue = CSSTransformValue::create(CSSTransformValue::Scale3DTransformOperation); 827 if (!parseTransformNumberArguments(pos, end, 3, transformValue.get())) 828 return nullptr; 829 return transformValue.release(); 830 } 831 832 return nullptr; 833 } 834 835 template <typename CharType> 836 static PassRefPtrWillBeRawPtr<CSSValueList> parseSimpleTransformList(CharType*& pos, CharType* end) 837 { 838 RefPtrWillBeRawPtr<CSSValueList> transformList = nullptr; 839 while (pos < end) { 840 while (pos < end && isCSSSpace(*pos)) 841 ++pos; 842 RefPtrWillBeRawPtr<CSSTransformValue> transformValue = parseSimpleTransformValue(pos, end); 843 if (!transformValue) 844 return nullptr; 845 if (!transformList) 846 transformList = CSSValueList::createSpaceSeparated(); 847 transformList->append(transformValue.release()); 848 if (pos < end) { 849 if (isCSSSpace(*pos)) 850 return nullptr; 851 } 852 } 853 return transformList.release(); 854 } 855 856 static bool parseSimpleTransform(MutableStylePropertySet* properties, CSSPropertyID propertyID, const String& string, bool important) 857 { 858 if (propertyID != CSSPropertyTransform && propertyID != CSSPropertyWebkitTransform) 859 return false; 860 if (string.isEmpty()) 861 return false; 862 RefPtrWillBeRawPtr<CSSValueList> transformList = nullptr; 863 if (string.is8Bit()) { 864 const LChar* pos = string.characters8(); 865 const LChar* end = pos + string.length(); 866 transformList = parseSimpleTransformList(pos, end); 867 if (!transformList) 868 return false; 869 } else { 870 const UChar* pos = string.characters16(); 871 const UChar* end = pos + string.length(); 872 transformList = parseSimpleTransformList(pos, end); 873 if (!transformList) 874 return false; 875 } 876 properties->addParsedProperty(CSSProperty(propertyID, transformList.release(), important)); 877 return true; 878 } 879 880 bool BisonCSSParser::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important, const CSSParserContext& context) 881 { 882 ASSERT(!string.isEmpty()); 883 884 if (parseSimpleLengthValue(declaration, propertyID, string, important, context.mode())) 885 return true; 886 if (parseColorValue(declaration, propertyID, string, important, context.mode())) 887 return true; 888 if (parseKeywordValue(declaration, propertyID, string, important, context)) 889 return true; 890 891 BisonCSSParser parser(context); 892 return parser.parseValue(declaration, propertyID, string, important, static_cast<StyleSheetContents*>(0)); 893 } 894 895 bool BisonCSSParser::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important, CSSParserMode cssParserMode, StyleSheetContents* contextStyleSheet) 896 { 897 ASSERT(!string.isEmpty()); 898 if (parseSimpleLengthValue(declaration, propertyID, string, important, cssParserMode)) 899 return true; 900 if (parseColorValue(declaration, propertyID, string, important, cssParserMode)) 901 return true; 902 903 CSSParserContext context(cssParserMode, 0); 904 if (contextStyleSheet) { 905 context = contextStyleSheet->parserContext(); 906 context.setMode(cssParserMode); 907 } 908 909 if (parseKeywordValue(declaration, propertyID, string, important, context)) 910 return true; 911 if (parseSimpleTransform(declaration, propertyID, string, important)) 912 return true; 913 914 BisonCSSParser parser(context); 915 return parser.parseValue(declaration, propertyID, string, important, contextStyleSheet); 916 } 917 918 bool BisonCSSParser::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important, StyleSheetContents* contextStyleSheet) 919 { 920 if (m_context.useCounter()) 921 m_context.useCounter()->count(m_context, propertyID); 922 923 setStyleSheet(contextStyleSheet); 924 925 setupParser("@-internal-value ", string, ""); 926 927 m_id = propertyID; 928 m_important = important; 929 930 { 931 StyleDeclarationScope scope(this, declaration); 932 cssyyparse(this); 933 } 934 935 m_rule = nullptr; 936 m_id = CSSPropertyInvalid; 937 938 bool ok = false; 939 if (!m_parsedProperties.isEmpty()) { 940 ok = true; 941 declaration->addParsedProperties(m_parsedProperties); 942 clearProperties(); 943 } 944 945 return ok; 946 } 947 948 // The color will only be changed when string contains a valid CSS color, so callers 949 // can set it to a default color and ignore the boolean result. 950 bool BisonCSSParser::parseColor(RGBA32& color, const String& string, bool strict) 951 { 952 // First try creating a color specified by name, rgba(), rgb() or "#" syntax. 953 if (CSSPropertyParser::fastParseColor(color, string, strict)) 954 return true; 955 956 BisonCSSParser parser(strictCSSParserContext()); 957 958 // In case the fast-path parser didn't understand the color, try the full parser. 959 if (!parser.parseColor(string)) 960 return false; 961 962 CSSValue* value = parser.m_parsedProperties.first().value(); 963 if (!value->isPrimitiveValue()) 964 return false; 965 966 CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value); 967 if (!primitiveValue->isRGBColor()) 968 return false; 969 970 color = primitiveValue->getRGBA32Value(); 971 return true; 972 } 973 974 StyleColor BisonCSSParser::colorFromRGBColorString(const String& colorString) 975 { 976 // FIXME: Rework css parser so it is more SVG aware. 977 RGBA32 color; 978 if (parseColor(color, colorString.stripWhiteSpace())) 979 return StyleColor(color); 980 // FIXME: This branch catches the string currentColor, but we should error if we have an illegal color value. 981 return StyleColor::currentColor(); 982 } 983 984 bool BisonCSSParser::parseColor(const String& string) 985 { 986 setupParser("@-internal-decls color:", string, ""); 987 cssyyparse(this); 988 m_rule = nullptr; 989 990 return !m_parsedProperties.isEmpty() && m_parsedProperties.first().id() == CSSPropertyColor; 991 } 992 993 bool BisonCSSParser::parseSystemColor(RGBA32& color, const String& string) 994 { 995 CSSParserString cssColor; 996 cssColor.init(string); 997 CSSValueID id = cssValueKeywordID(cssColor); 998 if (!CSSPropertyParser::isSystemColor(id)) 999 return false; 1000 1001 Color parsedColor = RenderTheme::theme().systemColor(id); 1002 color = parsedColor.rgb(); 1003 return true; 1004 } 1005 1006 void BisonCSSParser::parseSelector(const String& string, CSSSelectorList& selectorList) 1007 { 1008 m_selectorListForParseSelector = &selectorList; 1009 1010 setupParser("@-internal-selector ", string, ""); 1011 1012 cssyyparse(this); 1013 1014 m_selectorListForParseSelector = 0; 1015 } 1016 1017 PassRefPtrWillBeRawPtr<ImmutableStylePropertySet> BisonCSSParser::parseInlineStyleDeclaration(const String& string, Element* element) 1018 { 1019 Document& document = element->document(); 1020 CSSParserContext context = CSSParserContext(document.elementSheet().contents()->parserContext(), UseCounter::getFrom(&document)); 1021 context.setMode((element->isHTMLElement() && !document.inQuirksMode()) ? HTMLStandardMode : HTMLQuirksMode); 1022 return BisonCSSParser(context).parseDeclaration(string, document.elementSheet().contents()); 1023 } 1024 1025 PassRefPtrWillBeRawPtr<ImmutableStylePropertySet> BisonCSSParser::parseDeclaration(const String& string, StyleSheetContents* contextStyleSheet) 1026 { 1027 setStyleSheet(contextStyleSheet); 1028 1029 setupParser("@-internal-decls ", string, ""); 1030 cssyyparse(this); 1031 m_rule = nullptr; 1032 1033 RefPtrWillBeRawPtr<ImmutableStylePropertySet> style = createStylePropertySet(); 1034 clearProperties(); 1035 return style.release(); 1036 } 1037 1038 1039 bool BisonCSSParser::parseDeclaration(MutableStylePropertySet* declaration, const String& string, CSSParserObserver* observer, StyleSheetContents* contextStyleSheet) 1040 { 1041 setStyleSheet(contextStyleSheet); 1042 1043 TemporaryChange<CSSParserObserver*> scopedObsever(m_observer, observer); 1044 1045 setupParser("@-internal-decls ", string, ""); 1046 if (m_observer) { 1047 m_observer->startRuleHeader(CSSRuleSourceData::STYLE_RULE, 0); 1048 m_observer->endRuleHeader(1); 1049 m_observer->startRuleBody(0); 1050 } 1051 1052 { 1053 StyleDeclarationScope scope(this, declaration); 1054 cssyyparse(this); 1055 } 1056 1057 m_rule = nullptr; 1058 1059 bool ok = false; 1060 if (!m_parsedProperties.isEmpty()) { 1061 ok = true; 1062 declaration->addParsedProperties(m_parsedProperties); 1063 clearProperties(); 1064 } 1065 1066 if (m_observer) 1067 m_observer->endRuleBody(string.length(), false); 1068 1069 return ok; 1070 } 1071 1072 bool BisonCSSParser::parseAttributeMatchType(CSSSelector::AttributeMatchType& matchType, const String& string) 1073 { 1074 if (!RuntimeEnabledFeatures::cssAttributeCaseSensitivityEnabled() && !isUASheetBehavior(m_context.mode())) 1075 return false; 1076 if (string == "i") { 1077 matchType = CSSSelector::CaseInsensitive; 1078 return true; 1079 } 1080 return false; 1081 } 1082 1083 static inline void filterProperties(bool important, const WillBeHeapVector<CSSProperty, 256>& input, WillBeHeapVector<CSSProperty, 256>& output, size_t& unusedEntries, BitArray<numCSSProperties>& seenProperties) 1084 { 1085 // Add properties in reverse order so that highest priority definitions are reached first. Duplicate definitions can then be ignored when found. 1086 for (int i = input.size() - 1; i >= 0; --i) { 1087 const CSSProperty& property = input[i]; 1088 if (property.isImportant() != important) 1089 continue; 1090 const unsigned propertyIDIndex = property.id() - firstCSSProperty; 1091 if (seenProperties.get(propertyIDIndex)) 1092 continue; 1093 seenProperties.set(propertyIDIndex); 1094 output[--unusedEntries] = property; 1095 } 1096 } 1097 1098 PassRefPtrWillBeRawPtr<ImmutableStylePropertySet> BisonCSSParser::createStylePropertySet() 1099 { 1100 BitArray<numCSSProperties> seenProperties; 1101 size_t unusedEntries = m_parsedProperties.size(); 1102 WillBeHeapVector<CSSProperty, 256> results(unusedEntries); 1103 1104 // Important properties have higher priority, so add them first. Duplicate definitions can then be ignored when found. 1105 filterProperties(true, m_parsedProperties, results, unusedEntries, seenProperties); 1106 filterProperties(false, m_parsedProperties, results, unusedEntries, seenProperties); 1107 if (unusedEntries) 1108 results.remove(0, unusedEntries); 1109 1110 CSSParserMode mode = inViewport() ? CSSViewportRuleMode : m_context.mode(); 1111 1112 return ImmutableStylePropertySet::create(results.data(), results.size(), mode); 1113 } 1114 1115 void BisonCSSParser::rollbackLastProperties(int num) 1116 { 1117 ASSERT(num >= 0); 1118 ASSERT(m_parsedProperties.size() >= static_cast<unsigned>(num)); 1119 m_parsedProperties.shrink(m_parsedProperties.size() - num); 1120 } 1121 1122 void BisonCSSParser::clearProperties() 1123 { 1124 m_parsedProperties.clear(); 1125 m_numParsedPropertiesBeforeMarginBox = INVALID_NUM_PARSED_PROPERTIES; 1126 } 1127 1128 void BisonCSSParser::setCurrentProperty(CSSPropertyID propId) 1129 { 1130 m_id = propId; 1131 } 1132 1133 bool BisonCSSParser::parseValue(CSSPropertyID propId, bool important) 1134 { 1135 return CSSPropertyParser::parseValue(propId, important, m_valueList.get(), m_context, m_inViewport, m_parsedProperties, m_ruleHeaderType); 1136 } 1137 1138 1139 class TransformOperationInfo { 1140 public: 1141 TransformOperationInfo(const CSSParserString& name) 1142 : m_type(CSSTransformValue::UnknownTransformOperation) 1143 , m_argCount(1) 1144 , m_allowSingleArgument(false) 1145 , m_unit(CSSPropertyParser::FUnknown) 1146 { 1147 const UChar* characters; 1148 unsigned nameLength = name.length(); 1149 1150 const unsigned longestNameLength = 11; 1151 UChar characterBuffer[longestNameLength]; 1152 if (name.is8Bit()) { 1153 unsigned length = std::min(longestNameLength, nameLength); 1154 const LChar* characters8 = name.characters8(); 1155 for (unsigned i = 0; i < length; ++i) 1156 characterBuffer[i] = characters8[i]; 1157 characters = characterBuffer; 1158 } else 1159 characters = name.characters16(); 1160 1161 SWITCH(characters, nameLength) { 1162 CASE("skew") { 1163 m_unit = CSSPropertyParser::FAngle; 1164 m_type = CSSTransformValue::SkewTransformOperation; 1165 m_allowSingleArgument = true; 1166 m_argCount = 3; 1167 } 1168 CASE("scale") { 1169 m_unit = CSSPropertyParser::FNumber; 1170 m_type = CSSTransformValue::ScaleTransformOperation; 1171 m_allowSingleArgument = true; 1172 m_argCount = 3; 1173 } 1174 CASE("skewx") { 1175 m_unit = CSSPropertyParser::FAngle; 1176 m_type = CSSTransformValue::SkewXTransformOperation; 1177 } 1178 CASE("skewy") { 1179 m_unit = CSSPropertyParser::FAngle; 1180 m_type = CSSTransformValue::SkewYTransformOperation; 1181 } 1182 CASE("matrix") { 1183 m_unit = CSSPropertyParser::FNumber; 1184 m_type = CSSTransformValue::MatrixTransformOperation; 1185 m_argCount = 11; 1186 } 1187 CASE("rotate") { 1188 m_unit = CSSPropertyParser::FAngle; 1189 m_type = CSSTransformValue::RotateTransformOperation; 1190 } 1191 CASE("scalex") { 1192 m_unit = CSSPropertyParser::FNumber; 1193 m_type = CSSTransformValue::ScaleXTransformOperation; 1194 } 1195 CASE("scaley") { 1196 m_unit = CSSPropertyParser::FNumber; 1197 m_type = CSSTransformValue::ScaleYTransformOperation; 1198 } 1199 CASE("scalez") { 1200 m_unit = CSSPropertyParser::FNumber; 1201 m_type = CSSTransformValue::ScaleZTransformOperation; 1202 } 1203 CASE("scale3d") { 1204 m_unit = CSSPropertyParser::FNumber; 1205 m_type = CSSTransformValue::Scale3DTransformOperation; 1206 m_argCount = 5; 1207 } 1208 CASE("rotatex") { 1209 m_unit = CSSPropertyParser::FAngle; 1210 m_type = CSSTransformValue::RotateXTransformOperation; 1211 } 1212 CASE("rotatey") { 1213 m_unit = CSSPropertyParser::FAngle; 1214 m_type = CSSTransformValue::RotateYTransformOperation; 1215 } 1216 CASE("rotatez") { 1217 m_unit = CSSPropertyParser::FAngle; 1218 m_type = CSSTransformValue::RotateZTransformOperation; 1219 } 1220 CASE("matrix3d") { 1221 m_unit = CSSPropertyParser::FNumber; 1222 m_type = CSSTransformValue::Matrix3DTransformOperation; 1223 m_argCount = 31; 1224 } 1225 CASE("rotate3d") { 1226 m_unit = CSSPropertyParser::FNumber; 1227 m_type = CSSTransformValue::Rotate3DTransformOperation; 1228 m_argCount = 7; 1229 } 1230 CASE("translate") { 1231 m_unit = CSSPropertyParser::FLength | CSSPropertyParser::FPercent; 1232 m_type = CSSTransformValue::TranslateTransformOperation; 1233 m_allowSingleArgument = true; 1234 m_argCount = 3; 1235 } 1236 CASE("translatex") { 1237 m_unit = CSSPropertyParser::FLength | CSSPropertyParser::FPercent; 1238 m_type = CSSTransformValue::TranslateXTransformOperation; 1239 } 1240 CASE("translatey") { 1241 m_unit = CSSPropertyParser::FLength | CSSPropertyParser::FPercent; 1242 m_type = CSSTransformValue::TranslateYTransformOperation; 1243 } 1244 CASE("translatez") { 1245 m_unit = CSSPropertyParser::FLength | CSSPropertyParser::FPercent; 1246 m_type = CSSTransformValue::TranslateZTransformOperation; 1247 } 1248 CASE("perspective") { 1249 m_unit = CSSPropertyParser::FNumber; 1250 m_type = CSSTransformValue::PerspectiveTransformOperation; 1251 } 1252 CASE("translate3d") { 1253 m_unit = CSSPropertyParser::FLength | CSSPropertyParser::FPercent; 1254 m_type = CSSTransformValue::Translate3DTransformOperation; 1255 m_argCount = 5; 1256 } 1257 } 1258 } 1259 1260 CSSTransformValue::TransformOperationType type() const { return m_type; } 1261 unsigned argCount() const { return m_argCount; } 1262 CSSPropertyParser::Units unit() const { return m_unit; } 1263 1264 bool unknown() const { return m_type == CSSTransformValue::UnknownTransformOperation; } 1265 bool hasCorrectArgCount(unsigned argCount) { return m_argCount == argCount || (m_allowSingleArgument && argCount == 1); } 1266 1267 private: 1268 CSSTransformValue::TransformOperationType m_type; 1269 unsigned m_argCount; 1270 bool m_allowSingleArgument; 1271 CSSPropertyParser::Units m_unit; 1272 }; 1273 1274 PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseTransform(CSSPropertyID propId) 1275 { 1276 if (!m_valueList) 1277 return nullptr; 1278 1279 RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated(); 1280 for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) { 1281 RefPtrWillBeRawPtr<CSSValue> parsedTransformValue = parseTransformValue(propId, value); 1282 if (!parsedTransformValue) 1283 return nullptr; 1284 1285 list->append(parsedTransformValue.release()); 1286 } 1287 1288 return list.release(); 1289 } 1290 1291 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseTransformValue(CSSPropertyID propId, CSSParserValue *value) 1292 { 1293 if (value->unit != CSSParserValue::Function || !value->function) 1294 return nullptr; 1295 1296 // Every primitive requires at least one argument. 1297 CSSParserValueList* args = value->function->args.get(); 1298 if (!args) 1299 return nullptr; 1300 1301 // See if the specified primitive is one we understand. 1302 TransformOperationInfo info(value->function->name); 1303 if (info.unknown()) 1304 return nullptr; 1305 1306 if (!info.hasCorrectArgCount(args->size())) 1307 return nullptr; 1308 1309 // The transform is a list of functional primitives that specify transform operations. 1310 // We collect a list of CSSTransformValues, where each value specifies a single operation. 1311 1312 // Create the new CSSTransformValue for this operation and add it to our list. 1313 RefPtrWillBeRawPtr<CSSTransformValue> transformValue = CSSTransformValue::create(info.type()); 1314 1315 // Snag our values. 1316 CSSParserValue* a = args->current(); 1317 unsigned argNumber = 0; 1318 while (a) { 1319 CSSPropertyParser::Units unit = info.unit(); 1320 1321 if (info.type() == CSSTransformValue::Rotate3DTransformOperation && argNumber == 3) { 1322 // 4th param of rotate3d() is an angle rather than a bare number, validate it as such 1323 if (!validUnit(a, FAngle, HTMLStandardMode)) 1324 return nullptr; 1325 } else if (info.type() == CSSTransformValue::Translate3DTransformOperation && argNumber == 2) { 1326 // 3rd param of translate3d() cannot be a percentage 1327 if (!validUnit(a, FLength, HTMLStandardMode)) 1328 return nullptr; 1329 } else if (info.type() == CSSTransformValue::TranslateZTransformOperation && !argNumber) { 1330 // 1st param of translateZ() cannot be a percentage 1331 if (!validUnit(a, FLength, HTMLStandardMode)) 1332 return nullptr; 1333 } else if (info.type() == CSSTransformValue::PerspectiveTransformOperation && !argNumber) { 1334 // 1st param of perspective() must be a non-negative number (deprecated) or length. 1335 if ((propId == CSSPropertyWebkitTransform && !validUnit(a, FNumber | FLength | FNonNeg, HTMLStandardMode)) 1336 || (propId == CSSPropertyTransform && !validUnit(a, FLength | FNonNeg, HTMLStandardMode))) 1337 return nullptr; 1338 } else if (!validUnit(a, unit, HTMLStandardMode)) { 1339 return nullptr; 1340 } 1341 1342 // Add the value to the current transform operation. 1343 transformValue->append(createPrimitiveNumericValue(a)); 1344 1345 a = args->next(); 1346 if (!a) 1347 break; 1348 if (a->unit != CSSParserValue::Operator || a->iValue != ',') 1349 return nullptr; 1350 a = args->next(); 1351 1352 argNumber++; 1353 } 1354 1355 return transformValue.release(); 1356 } 1357 1358 void BisonCSSParser::ensureLineEndings() 1359 { 1360 if (!m_lineEndings) 1361 m_lineEndings = lineEndings(*m_source); 1362 } 1363 1364 CSSParserSelector* BisonCSSParser::createFloatingSelectorWithTagName(const QualifiedName& tagQName) 1365 { 1366 CSSParserSelector* selector = new CSSParserSelector(tagQName); 1367 m_floatingSelectors.append(selector); 1368 return selector; 1369 } 1370 1371 CSSParserSelector* BisonCSSParser::createFloatingSelector() 1372 { 1373 CSSParserSelector* selector = new CSSParserSelector; 1374 m_floatingSelectors.append(selector); 1375 return selector; 1376 } 1377 1378 PassOwnPtr<CSSParserSelector> BisonCSSParser::sinkFloatingSelector(CSSParserSelector* selector) 1379 { 1380 if (selector) { 1381 size_t index = m_floatingSelectors.reverseFind(selector); 1382 ASSERT(index != kNotFound); 1383 m_floatingSelectors.remove(index); 1384 } 1385 return adoptPtr(selector); 1386 } 1387 1388 Vector<OwnPtr<CSSParserSelector> >* BisonCSSParser::createFloatingSelectorVector() 1389 { 1390 Vector<OwnPtr<CSSParserSelector> >* selectorVector = new Vector<OwnPtr<CSSParserSelector> >; 1391 m_floatingSelectorVectors.append(selectorVector); 1392 return selectorVector; 1393 } 1394 1395 PassOwnPtr<Vector<OwnPtr<CSSParserSelector> > > BisonCSSParser::sinkFloatingSelectorVector(Vector<OwnPtr<CSSParserSelector> >* selectorVector) 1396 { 1397 if (selectorVector) { 1398 size_t index = m_floatingSelectorVectors.reverseFind(selectorVector); 1399 ASSERT(index != kNotFound); 1400 m_floatingSelectorVectors.remove(index); 1401 } 1402 return adoptPtr(selectorVector); 1403 } 1404 1405 CSSParserValueList* BisonCSSParser::createFloatingValueList() 1406 { 1407 CSSParserValueList* list = new CSSParserValueList; 1408 m_floatingValueLists.append(list); 1409 return list; 1410 } 1411 1412 PassOwnPtr<CSSParserValueList> BisonCSSParser::sinkFloatingValueList(CSSParserValueList* list) 1413 { 1414 if (list) { 1415 size_t index = m_floatingValueLists.reverseFind(list); 1416 ASSERT(index != kNotFound); 1417 m_floatingValueLists.remove(index); 1418 } 1419 return adoptPtr(list); 1420 } 1421 1422 CSSParserFunction* BisonCSSParser::createFloatingFunction() 1423 { 1424 CSSParserFunction* function = new CSSParserFunction; 1425 m_floatingFunctions.append(function); 1426 return function; 1427 } 1428 1429 CSSParserFunction* BisonCSSParser::createFloatingFunction(const CSSParserString& name, PassOwnPtr<CSSParserValueList> args) 1430 { 1431 CSSParserFunction* function = createFloatingFunction(); 1432 function->name = name; 1433 function->args = args; 1434 return function; 1435 } 1436 1437 PassOwnPtr<CSSParserFunction> BisonCSSParser::sinkFloatingFunction(CSSParserFunction* function) 1438 { 1439 if (function) { 1440 size_t index = m_floatingFunctions.reverseFind(function); 1441 ASSERT(index != kNotFound); 1442 m_floatingFunctions.remove(index); 1443 } 1444 return adoptPtr(function); 1445 } 1446 1447 CSSParserValue& BisonCSSParser::sinkFloatingValue(CSSParserValue& value) 1448 { 1449 if (value.unit == CSSParserValue::Function) { 1450 size_t index = m_floatingFunctions.reverseFind(value.function); 1451 ASSERT(index != kNotFound); 1452 m_floatingFunctions.remove(index); 1453 } 1454 return value; 1455 } 1456 1457 MediaQueryExp* BisonCSSParser::createFloatingMediaQueryExp(const AtomicString& mediaFeature, CSSParserValueList* values) 1458 { 1459 m_floatingMediaQueryExp = MediaQueryExp::createIfValid(mediaFeature, values); 1460 return m_floatingMediaQueryExp.get(); 1461 } 1462 1463 PassOwnPtrWillBeRawPtr<MediaQueryExp> BisonCSSParser::sinkFloatingMediaQueryExp(MediaQueryExp* expression) 1464 { 1465 ASSERT_UNUSED(expression, expression == m_floatingMediaQueryExp); 1466 return m_floatingMediaQueryExp.release(); 1467 } 1468 1469 WillBeHeapVector<OwnPtrWillBeMember<MediaQueryExp> >* BisonCSSParser::createFloatingMediaQueryExpList() 1470 { 1471 m_floatingMediaQueryExpList = adoptPtrWillBeNoop(new WillBeHeapVector<OwnPtrWillBeMember<MediaQueryExp> >); 1472 return m_floatingMediaQueryExpList.get(); 1473 } 1474 1475 PassOwnPtrWillBeRawPtr<WillBeHeapVector<OwnPtrWillBeMember<MediaQueryExp> > > BisonCSSParser::sinkFloatingMediaQueryExpList(WillBeHeapVector<OwnPtrWillBeMember<MediaQueryExp> >* list) 1476 { 1477 ASSERT_UNUSED(list, list == m_floatingMediaQueryExpList); 1478 return m_floatingMediaQueryExpList.release(); 1479 } 1480 1481 MediaQuery* BisonCSSParser::createFloatingMediaQuery(MediaQuery::Restrictor restrictor, const AtomicString& mediaType, PassOwnPtrWillBeRawPtr<WillBeHeapVector<OwnPtrWillBeMember<MediaQueryExp> > > expressions) 1482 { 1483 m_floatingMediaQuery = adoptPtrWillBeNoop(new MediaQuery(restrictor, mediaType, expressions)); 1484 return m_floatingMediaQuery.get(); 1485 } 1486 1487 MediaQuery* BisonCSSParser::createFloatingMediaQuery(PassOwnPtrWillBeRawPtr<WillBeHeapVector<OwnPtrWillBeMember<MediaQueryExp> > > expressions) 1488 { 1489 return createFloatingMediaQuery(MediaQuery::None, MediaTypeNames::all, expressions); 1490 } 1491 1492 MediaQuery* BisonCSSParser::createFloatingNotAllQuery() 1493 { 1494 return createFloatingMediaQuery(MediaQuery::Not, MediaTypeNames::all, sinkFloatingMediaQueryExpList(createFloatingMediaQueryExpList())); 1495 } 1496 1497 PassOwnPtrWillBeRawPtr<MediaQuery> BisonCSSParser::sinkFloatingMediaQuery(MediaQuery* query) 1498 { 1499 ASSERT_UNUSED(query, query == m_floatingMediaQuery); 1500 return m_floatingMediaQuery.release(); 1501 } 1502 1503 WillBeHeapVector<RefPtrWillBeMember<StyleKeyframe> >* BisonCSSParser::createFloatingKeyframeVector() 1504 { 1505 m_floatingKeyframeVector = adoptPtrWillBeNoop(new WillBeHeapVector<RefPtrWillBeMember<StyleKeyframe> >()); 1506 return m_floatingKeyframeVector.get(); 1507 } 1508 1509 PassOwnPtrWillBeRawPtr<WillBeHeapVector<RefPtrWillBeMember<StyleKeyframe> > > BisonCSSParser::sinkFloatingKeyframeVector(WillBeHeapVector<RefPtrWillBeMember<StyleKeyframe> >* keyframeVector) 1510 { 1511 ASSERT_UNUSED(keyframeVector, m_floatingKeyframeVector == keyframeVector); 1512 return m_floatingKeyframeVector.release(); 1513 } 1514 1515 MediaQuerySet* BisonCSSParser::createMediaQuerySet() 1516 { 1517 RefPtrWillBeRawPtr<MediaQuerySet> queries = MediaQuerySet::create(); 1518 MediaQuerySet* result = queries.get(); 1519 m_parsedMediaQuerySets.append(queries.release()); 1520 return result; 1521 } 1522 1523 StyleRuleBase* BisonCSSParser::createImportRule(const CSSParserString& url, MediaQuerySet* media) 1524 { 1525 if (!media || !m_allowImportRules) 1526 return 0; 1527 RefPtrWillBeRawPtr<StyleRuleImport> rule = StyleRuleImport::create(url, media); 1528 StyleRuleImport* result = rule.get(); 1529 m_parsedRules.append(rule.release()); 1530 return result; 1531 } 1532 1533 StyleRuleBase* BisonCSSParser::createMediaRule(MediaQuerySet* media, RuleList* rules) 1534 { 1535 m_allowImportRules = m_allowNamespaceDeclarations = false; 1536 RefPtrWillBeRawPtr<StyleRuleMedia> rule = nullptr; 1537 if (rules) { 1538 rule = StyleRuleMedia::create(media ? media : MediaQuerySet::create().get(), *rules); 1539 } else { 1540 RuleList emptyRules; 1541 rule = StyleRuleMedia::create(media ? media : MediaQuerySet::create().get(), emptyRules); 1542 } 1543 StyleRuleMedia* result = rule.get(); 1544 m_parsedRules.append(rule.release()); 1545 return result; 1546 } 1547 1548 StyleRuleBase* BisonCSSParser::createSupportsRule(bool conditionIsSupported, RuleList* rules) 1549 { 1550 m_allowImportRules = m_allowNamespaceDeclarations = false; 1551 1552 RefPtrWillBeRawPtr<CSSRuleSourceData> data = popSupportsRuleData(); 1553 RefPtrWillBeRawPtr<StyleRuleSupports> rule = nullptr; 1554 String conditionText; 1555 unsigned conditionOffset = data->ruleHeaderRange.start + 9; 1556 unsigned conditionLength = data->ruleHeaderRange.length() - 9; 1557 1558 if (m_tokenizer.is8BitSource()) 1559 conditionText = String(m_tokenizer.m_dataStart8.get() + conditionOffset, conditionLength).stripWhiteSpace(); 1560 else 1561 conditionText = String(m_tokenizer.m_dataStart16.get() + conditionOffset, conditionLength).stripWhiteSpace(); 1562 1563 if (rules) { 1564 rule = StyleRuleSupports::create(conditionText, conditionIsSupported, *rules); 1565 } else { 1566 RuleList emptyRules; 1567 rule = StyleRuleSupports::create(conditionText, conditionIsSupported, emptyRules); 1568 } 1569 1570 StyleRuleSupports* result = rule.get(); 1571 m_parsedRules.append(rule.release()); 1572 1573 return result; 1574 } 1575 1576 void BisonCSSParser::markSupportsRuleHeaderStart() 1577 { 1578 if (!m_supportsRuleDataStack) 1579 m_supportsRuleDataStack = adoptPtrWillBeNoop(new RuleSourceDataList()); 1580 1581 RefPtrWillBeRawPtr<CSSRuleSourceData> data = CSSRuleSourceData::create(CSSRuleSourceData::SUPPORTS_RULE); 1582 data->ruleHeaderRange.start = m_tokenizer.tokenStartOffset(); 1583 m_supportsRuleDataStack->append(data); 1584 } 1585 1586 void BisonCSSParser::markSupportsRuleHeaderEnd() 1587 { 1588 ASSERT(m_supportsRuleDataStack && !m_supportsRuleDataStack->isEmpty()); 1589 1590 if (m_tokenizer.is8BitSource()) 1591 m_supportsRuleDataStack->last()->ruleHeaderRange.end = m_tokenizer.tokenStart<LChar>() - m_tokenizer.m_dataStart8.get(); 1592 else 1593 m_supportsRuleDataStack->last()->ruleHeaderRange.end = m_tokenizer.tokenStart<UChar>() - m_tokenizer.m_dataStart16.get(); 1594 } 1595 1596 PassRefPtrWillBeRawPtr<CSSRuleSourceData> BisonCSSParser::popSupportsRuleData() 1597 { 1598 ASSERT(m_supportsRuleDataStack && !m_supportsRuleDataStack->isEmpty()); 1599 RefPtrWillBeRawPtr<CSSRuleSourceData> data = m_supportsRuleDataStack->last(); 1600 m_supportsRuleDataStack->removeLast(); 1601 return data.release(); 1602 } 1603 1604 BisonCSSParser::RuleList* BisonCSSParser::createRuleList() 1605 { 1606 OwnPtrWillBeRawPtr<RuleList> list = adoptPtrWillBeNoop(new RuleList); 1607 RuleList* listPtr = list.get(); 1608 1609 m_parsedRuleLists.append(list.release()); 1610 return listPtr; 1611 } 1612 1613 BisonCSSParser::RuleList* BisonCSSParser::appendRule(RuleList* ruleList, StyleRuleBase* rule) 1614 { 1615 if (rule) { 1616 if (!ruleList) 1617 ruleList = createRuleList(); 1618 ruleList->append(rule); 1619 } 1620 return ruleList; 1621 } 1622 1623 template <typename CharacterType> 1624 ALWAYS_INLINE static void makeLower(const CharacterType* input, CharacterType* output, unsigned length) 1625 { 1626 // FIXME: If we need Unicode lowercasing here, then we probably want the real kind 1627 // that can potentially change the length of the string rather than the character 1628 // by character kind. If we don't need Unicode lowercasing, it would be good to 1629 // simplify this function. 1630 1631 if (charactersAreAllASCII(input, length)) { 1632 // Fast case for all-ASCII. 1633 for (unsigned i = 0; i < length; i++) 1634 output[i] = toASCIILower(input[i]); 1635 } else { 1636 for (unsigned i = 0; i < length; i++) 1637 output[i] = Unicode::toLower(input[i]); 1638 } 1639 } 1640 1641 void BisonCSSParser::tokenToLowerCase(CSSParserString& token) 1642 { 1643 // Since it's our internal token, we know that we created it out 1644 // of our writable work buffers. Therefore the const_cast is just 1645 // ugly and not a potential crash. 1646 size_t length = token.length(); 1647 if (token.is8Bit()) { 1648 makeLower(token.characters8(), const_cast<LChar*>(token.characters8()), length); 1649 } else { 1650 makeLower(token.characters16(), const_cast<UChar*>(token.characters16()), length); 1651 } 1652 } 1653 1654 void BisonCSSParser::endInvalidRuleHeader() 1655 { 1656 if (m_ruleHeaderType == CSSRuleSourceData::UNKNOWN_RULE) 1657 return; 1658 1659 CSSParserLocation location; 1660 location.lineNumber = m_tokenizer.m_lineNumber; 1661 location.offset = m_ruleHeaderStartOffset; 1662 if (m_tokenizer.is8BitSource()) 1663 location.token.init(m_tokenizer.m_dataStart8.get() + m_ruleHeaderStartOffset, 0); 1664 else 1665 location.token.init(m_tokenizer.m_dataStart16.get() + m_ruleHeaderStartOffset, 0); 1666 1667 reportError(location, m_ruleHeaderType == CSSRuleSourceData::STYLE_RULE ? InvalidSelectorCSSError : InvalidRuleCSSError); 1668 1669 endRuleHeader(); 1670 } 1671 1672 void BisonCSSParser::reportError(const CSSParserLocation&, CSSParserError) 1673 { 1674 // FIXME: error reporting temporatily disabled. 1675 } 1676 1677 bool BisonCSSParser::isLoggingErrors() 1678 { 1679 return m_logErrors && !m_ignoreErrors; 1680 } 1681 1682 void BisonCSSParser::logError(const String& message, const CSSParserLocation& location) 1683 { 1684 unsigned lineNumberInStyleSheet; 1685 unsigned columnNumber = 0; 1686 if (InspectorInstrumentation::hasFrontends()) { 1687 ensureLineEndings(); 1688 TextPosition tokenPosition = TextPosition::fromOffsetAndLineEndings(location.offset, *m_lineEndings); 1689 lineNumberInStyleSheet = tokenPosition.m_line.zeroBasedInt(); 1690 columnNumber = (lineNumberInStyleSheet ? 0 : m_startPosition.m_column.zeroBasedInt()) + tokenPosition.m_column.zeroBasedInt(); 1691 } else { 1692 lineNumberInStyleSheet = location.lineNumber; 1693 } 1694 FrameConsole& console = m_styleSheet->singleOwnerDocument()->frame()->console(); 1695 console.addMessage(ConsoleMessage::create(CSSMessageSource, WarningMessageLevel, message, m_styleSheet->baseURL().string(), lineNumberInStyleSheet + m_startPosition.m_line.zeroBasedInt() + 1, columnNumber + 1)); 1696 } 1697 1698 StyleRuleKeyframes* BisonCSSParser::createKeyframesRule(const String& name, PassOwnPtrWillBeRawPtr<WillBeHeapVector<RefPtrWillBeMember<StyleKeyframe> > > popKeyframes, bool isPrefixed) 1699 { 1700 OwnPtrWillBeRawPtr<WillBeHeapVector<RefPtrWillBeMember<StyleKeyframe> > > keyframes = popKeyframes; 1701 m_allowImportRules = m_allowNamespaceDeclarations = false; 1702 RefPtrWillBeRawPtr<StyleRuleKeyframes> rule = StyleRuleKeyframes::create(); 1703 for (size_t i = 0; i < keyframes->size(); ++i) 1704 rule->parserAppendKeyframe(keyframes->at(i)); 1705 rule->setName(name); 1706 rule->setVendorPrefixed(isPrefixed); 1707 StyleRuleKeyframes* rulePtr = rule.get(); 1708 m_parsedRules.append(rule.release()); 1709 return rulePtr; 1710 } 1711 1712 static void recordSelectorStats(const CSSParserContext& context, const CSSSelectorList& selectorList) 1713 { 1714 if (!context.useCounter()) 1715 return; 1716 1717 for (const CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(*selector)) { 1718 for (const CSSSelector* current = selector; current ; current = current->tagHistory()) { 1719 UseCounter::Feature feature = UseCounter::NumberOfFeatures; 1720 switch (current->pseudoType()) { 1721 case CSSSelector::PseudoUnresolved: 1722 feature = UseCounter::CSSSelectorPseudoUnresolved; 1723 break; 1724 case CSSSelector::PseudoShadow: 1725 feature = UseCounter::CSSSelectorPseudoShadow; 1726 break; 1727 case CSSSelector::PseudoContent: 1728 feature = UseCounter::CSSSelectorPseudoContent; 1729 break; 1730 case CSSSelector::PseudoHost: 1731 feature = UseCounter::CSSSelectorPseudoHost; 1732 break; 1733 case CSSSelector::PseudoHostContext: 1734 feature = UseCounter::CSSSelectorPseudoHostContext; 1735 break; 1736 default: 1737 break; 1738 } 1739 if (feature != UseCounter::NumberOfFeatures) 1740 context.useCounter()->count(feature); 1741 if (current->relation() == CSSSelector::ShadowDeep) 1742 context.useCounter()->count(UseCounter::CSSDeepCombinator); 1743 if (current->selectorList()) 1744 recordSelectorStats(context, *current->selectorList()); 1745 } 1746 } 1747 } 1748 1749 StyleRuleBase* BisonCSSParser::createStyleRule(Vector<OwnPtr<CSSParserSelector> >* selectors) 1750 { 1751 StyleRule* result = 0; 1752 if (selectors) { 1753 m_allowImportRules = m_allowNamespaceDeclarations = false; 1754 RefPtrWillBeRawPtr<StyleRule> rule = StyleRule::create(); 1755 rule->parserAdoptSelectorVector(*selectors); 1756 rule->setProperties(createStylePropertySet()); 1757 result = rule.get(); 1758 m_parsedRules.append(rule.release()); 1759 recordSelectorStats(m_context, result->selectorList()); 1760 } 1761 clearProperties(); 1762 return result; 1763 } 1764 1765 StyleRuleBase* BisonCSSParser::createFontFaceRule() 1766 { 1767 m_allowImportRules = m_allowNamespaceDeclarations = false; 1768 for (unsigned i = 0; i < m_parsedProperties.size(); ++i) { 1769 CSSProperty& property = m_parsedProperties[i]; 1770 if (property.id() == CSSPropertyFontVariant && property.value()->isPrimitiveValue()) 1771 property.wrapValueInCommaSeparatedList(); 1772 else if (property.id() == CSSPropertyFontFamily && (!property.value()->isValueList() || toCSSValueList(property.value())->length() != 1)) { 1773 // Unlike font-family property, font-family descriptor in @font-face rule 1774 // has to be a value list with exactly one family name. It cannot have a 1775 // have 'initial' value and cannot 'inherit' from parent. 1776 // See http://dev.w3.org/csswg/css3-fonts/#font-family-desc 1777 clearProperties(); 1778 return 0; 1779 } 1780 } 1781 RefPtrWillBeRawPtr<StyleRuleFontFace> rule = StyleRuleFontFace::create(); 1782 rule->setProperties(createStylePropertySet()); 1783 clearProperties(); 1784 StyleRuleFontFace* result = rule.get(); 1785 m_parsedRules.append(rule.release()); 1786 if (m_styleSheet) 1787 m_styleSheet->setHasFontFaceRule(true); 1788 return result; 1789 } 1790 1791 void BisonCSSParser::addNamespace(const AtomicString& prefix, const AtomicString& uri) 1792 { 1793 if (!m_styleSheet || !m_allowNamespaceDeclarations) 1794 return; 1795 m_allowImportRules = false; 1796 m_styleSheet->parserAddNamespace(prefix, uri); 1797 if (prefix.isEmpty() && !uri.isNull()) 1798 m_defaultNamespace = uri; 1799 } 1800 1801 QualifiedName BisonCSSParser::determineNameInNamespace(const AtomicString& prefix, const AtomicString& localName) 1802 { 1803 if (!m_styleSheet) 1804 return QualifiedName(prefix, localName, m_defaultNamespace); 1805 return QualifiedName(prefix, localName, m_styleSheet->determineNamespace(prefix)); 1806 } 1807 1808 CSSParserSelector* BisonCSSParser::rewriteSpecifiersWithNamespaceIfNeeded(CSSParserSelector* specifiers) 1809 { 1810 if (m_defaultNamespace != starAtom || specifiers->crossesTreeScopes()) 1811 return rewriteSpecifiersWithElementName(nullAtom, starAtom, specifiers, /*tagIsForNamespaceRule*/true); 1812 return specifiers; 1813 } 1814 1815 CSSParserSelector* BisonCSSParser::rewriteSpecifiersWithElementName(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector* specifiers, bool tagIsForNamespaceRule) 1816 { 1817 AtomicString determinedNamespace = namespacePrefix != nullAtom && m_styleSheet ? m_styleSheet->determineNamespace(namespacePrefix) : m_defaultNamespace; 1818 QualifiedName tag(namespacePrefix, elementName, determinedNamespace); 1819 1820 if (specifiers->crossesTreeScopes()) 1821 return rewriteSpecifiersWithElementNameForCustomPseudoElement(tag, elementName, specifiers, tagIsForNamespaceRule); 1822 1823 if (specifiers->isContentPseudoElement()) 1824 return rewriteSpecifiersWithElementNameForContentPseudoElement(tag, elementName, specifiers, tagIsForNamespaceRule); 1825 1826 // *:host never matches, so we can't discard the * otherwise we can't tell the 1827 // difference between *:host and just :host. 1828 if (tag == anyQName() && !specifiers->hasHostPseudoSelector()) 1829 return specifiers; 1830 if (specifiers->pseudoType() != CSSSelector::PseudoCue) 1831 specifiers->prependTagSelector(tag, tagIsForNamespaceRule); 1832 return specifiers; 1833 } 1834 1835 CSSParserSelector* BisonCSSParser::rewriteSpecifiersWithElementNameForCustomPseudoElement(const QualifiedName& tag, const AtomicString& elementName, CSSParserSelector* specifiers, bool tagIsForNamespaceRule) 1836 { 1837 if (m_context.useCounter() && specifiers->pseudoType() == CSSSelector::PseudoUserAgentCustomElement) 1838 m_context.useCounter()->count(UseCounter::CSSPseudoElementUserAgentCustomPseudo); 1839 1840 CSSParserSelector* lastShadowPseudo = specifiers; 1841 CSSParserSelector* history = specifiers; 1842 while (history->tagHistory()) { 1843 history = history->tagHistory(); 1844 if (history->crossesTreeScopes() || history->hasShadowPseudo()) 1845 lastShadowPseudo = history; 1846 } 1847 1848 if (lastShadowPseudo->tagHistory()) { 1849 if (tag != anyQName()) 1850 lastShadowPseudo->tagHistory()->prependTagSelector(tag, tagIsForNamespaceRule); 1851 return specifiers; 1852 } 1853 1854 // For shadow-ID pseudo-elements to be correctly matched, the ShadowPseudo combinator has to be used. 1855 // We therefore create a new Selector with that combinator here in any case, even if matching any (host) element in any namespace (i.e. '*'). 1856 OwnPtr<CSSParserSelector> elementNameSelector = adoptPtr(new CSSParserSelector(tag)); 1857 lastShadowPseudo->setTagHistory(elementNameSelector.release()); 1858 lastShadowPseudo->setRelation(CSSSelector::ShadowPseudo); 1859 return specifiers; 1860 } 1861 1862 CSSParserSelector* BisonCSSParser::rewriteSpecifiersWithElementNameForContentPseudoElement(const QualifiedName& tag, const AtomicString& elementName, CSSParserSelector* specifiers, bool tagIsForNamespaceRule) 1863 { 1864 CSSParserSelector* last = specifiers; 1865 CSSParserSelector* history = specifiers; 1866 while (history->tagHistory()) { 1867 history = history->tagHistory(); 1868 if (history->isContentPseudoElement() || history->relationIsAffectedByPseudoContent()) 1869 last = history; 1870 } 1871 1872 if (last->tagHistory()) { 1873 if (tag != anyQName()) 1874 last->tagHistory()->prependTagSelector(tag, tagIsForNamespaceRule); 1875 return specifiers; 1876 } 1877 1878 // For shadow-ID pseudo-elements to be correctly matched, the ShadowPseudo combinator has to be used. 1879 // We therefore create a new Selector with that combinator here in any case, even if matching any (host) element in any namespace (i.e. '*'). 1880 OwnPtr<CSSParserSelector> elementNameSelector = adoptPtr(new CSSParserSelector(tag)); 1881 last->setTagHistory(elementNameSelector.release()); 1882 last->setRelation(CSSSelector::SubSelector); 1883 return specifiers; 1884 } 1885 1886 CSSParserSelector* BisonCSSParser::rewriteSpecifiers(CSSParserSelector* specifiers, CSSParserSelector* newSpecifier) 1887 { 1888 if (newSpecifier->crossesTreeScopes()) { 1889 // Unknown pseudo element always goes at the top of selector chain. 1890 newSpecifier->appendTagHistory(CSSSelector::ShadowPseudo, sinkFloatingSelector(specifiers)); 1891 return newSpecifier; 1892 } 1893 if (newSpecifier->isContentPseudoElement()) { 1894 newSpecifier->appendTagHistory(CSSSelector::SubSelector, sinkFloatingSelector(specifiers)); 1895 return newSpecifier; 1896 } 1897 if (specifiers->crossesTreeScopes()) { 1898 // Specifiers for unknown pseudo element go right behind it in the chain. 1899 specifiers->insertTagHistory(CSSSelector::SubSelector, sinkFloatingSelector(newSpecifier), CSSSelector::ShadowPseudo); 1900 return specifiers; 1901 } 1902 if (specifiers->isContentPseudoElement()) { 1903 specifiers->insertTagHistory(CSSSelector::SubSelector, sinkFloatingSelector(newSpecifier), CSSSelector::SubSelector); 1904 return specifiers; 1905 } 1906 specifiers->appendTagHistory(CSSSelector::SubSelector, sinkFloatingSelector(newSpecifier)); 1907 return specifiers; 1908 } 1909 1910 StyleRuleBase* BisonCSSParser::createPageRule(PassOwnPtr<CSSParserSelector> pageSelector) 1911 { 1912 // FIXME: Margin at-rules are ignored. 1913 m_allowImportRules = m_allowNamespaceDeclarations = false; 1914 StyleRulePage* pageRule = 0; 1915 if (pageSelector) { 1916 RefPtrWillBeRawPtr<StyleRulePage> rule = StyleRulePage::create(); 1917 Vector<OwnPtr<CSSParserSelector> > selectorVector; 1918 selectorVector.append(pageSelector); 1919 rule->parserAdoptSelectorVector(selectorVector); 1920 rule->setProperties(createStylePropertySet()); 1921 pageRule = rule.get(); 1922 m_parsedRules.append(rule.release()); 1923 } 1924 clearProperties(); 1925 return pageRule; 1926 } 1927 1928 StyleRuleBase* BisonCSSParser::createMarginAtRule(CSSSelector::MarginBoxType /* marginBox */) 1929 { 1930 // FIXME: Implement margin at-rule here, using: 1931 // - marginBox: margin box 1932 // - m_parsedProperties: properties at [m_numParsedPropertiesBeforeMarginBox, m_parsedProperties.size()] are for this at-rule. 1933 // Don't forget to also update the action for page symbol in CSSGrammar.y such that margin at-rule data is cleared if page_selector is invalid. 1934 1935 endDeclarationsForMarginBox(); 1936 return 0; // until this method is implemented. 1937 } 1938 1939 void BisonCSSParser::startDeclarationsForMarginBox() 1940 { 1941 m_numParsedPropertiesBeforeMarginBox = m_parsedProperties.size(); 1942 } 1943 1944 void BisonCSSParser::endDeclarationsForMarginBox() 1945 { 1946 rollbackLastProperties(m_parsedProperties.size() - m_numParsedPropertiesBeforeMarginBox); 1947 m_numParsedPropertiesBeforeMarginBox = INVALID_NUM_PARSED_PROPERTIES; 1948 } 1949 1950 StyleKeyframe* BisonCSSParser::createKeyframe(CSSParserValueList* keys) 1951 { 1952 OwnPtr<Vector<double> > keyVector = StyleKeyframe::createKeyList(keys); 1953 if (keyVector->isEmpty()) 1954 return 0; 1955 1956 RefPtrWillBeRawPtr<StyleKeyframe> keyframe = StyleKeyframe::create(); 1957 keyframe->setKeys(keyVector.release()); 1958 keyframe->setProperties(createStylePropertySet()); 1959 1960 clearProperties(); 1961 1962 StyleKeyframe* keyframePtr = keyframe.get(); 1963 m_parsedKeyframes.append(keyframe.release()); 1964 return keyframePtr; 1965 } 1966 1967 void BisonCSSParser::invalidBlockHit() 1968 { 1969 if (m_styleSheet && !m_hadSyntacticallyValidCSSRule) 1970 m_styleSheet->setHasSyntacticallyValidCSSHeader(false); 1971 } 1972 1973 void BisonCSSParser::startRule() 1974 { 1975 if (!m_observer) 1976 return; 1977 1978 ASSERT(m_ruleHasHeader); 1979 m_ruleHasHeader = false; 1980 } 1981 1982 void BisonCSSParser::endRule(bool valid) 1983 { 1984 if (!m_observer) 1985 return; 1986 1987 if (m_ruleHasHeader) 1988 m_observer->endRuleBody(m_tokenizer.safeUserStringTokenOffset(), !valid); 1989 m_ruleHasHeader = true; 1990 } 1991 1992 void BisonCSSParser::startRuleHeader(CSSRuleSourceData::Type ruleType) 1993 { 1994 resumeErrorLogging(); 1995 m_ruleHeaderType = ruleType; 1996 m_ruleHeaderStartOffset = m_tokenizer.safeUserStringTokenOffset(); 1997 m_ruleHeaderStartLineNumber = m_tokenizer.m_tokenStartLineNumber; 1998 if (m_observer) { 1999 ASSERT(!m_ruleHasHeader); 2000 m_observer->startRuleHeader(ruleType, m_ruleHeaderStartOffset); 2001 m_ruleHasHeader = true; 2002 } 2003 } 2004 2005 void BisonCSSParser::endRuleHeader() 2006 { 2007 ASSERT(m_ruleHeaderType != CSSRuleSourceData::UNKNOWN_RULE); 2008 m_ruleHeaderType = CSSRuleSourceData::UNKNOWN_RULE; 2009 if (m_observer) { 2010 ASSERT(m_ruleHasHeader); 2011 m_observer->endRuleHeader(m_tokenizer.safeUserStringTokenOffset()); 2012 } 2013 } 2014 2015 void BisonCSSParser::startSelector() 2016 { 2017 if (m_observer) 2018 m_observer->startSelector(m_tokenizer.safeUserStringTokenOffset()); 2019 } 2020 2021 void BisonCSSParser::endSelector() 2022 { 2023 if (m_observer) 2024 m_observer->endSelector(m_tokenizer.safeUserStringTokenOffset()); 2025 } 2026 2027 void BisonCSSParser::startRuleBody() 2028 { 2029 if (m_observer) 2030 m_observer->startRuleBody(m_tokenizer.safeUserStringTokenOffset()); 2031 } 2032 2033 void BisonCSSParser::startProperty() 2034 { 2035 resumeErrorLogging(); 2036 if (m_observer) 2037 m_observer->startProperty(m_tokenizer.safeUserStringTokenOffset()); 2038 } 2039 2040 void BisonCSSParser::endProperty(bool isImportantFound, bool isPropertyParsed, CSSParserError errorType) 2041 { 2042 m_id = CSSPropertyInvalid; 2043 if (m_observer) 2044 m_observer->endProperty(isImportantFound, isPropertyParsed, m_tokenizer.safeUserStringTokenOffset(), errorType); 2045 } 2046 2047 StyleRuleBase* BisonCSSParser::createViewportRule() 2048 { 2049 // Allow @viewport rules from UA stylesheets even if the feature is disabled. 2050 if (!RuntimeEnabledFeatures::cssViewportEnabled() && !isUASheetBehavior(m_context.mode())) 2051 return 0; 2052 2053 m_allowImportRules = m_allowNamespaceDeclarations = false; 2054 2055 RefPtrWillBeRawPtr<StyleRuleViewport> rule = StyleRuleViewport::create(); 2056 2057 rule->setProperties(createStylePropertySet()); 2058 clearProperties(); 2059 2060 StyleRuleViewport* result = rule.get(); 2061 m_parsedRules.append(rule.release()); 2062 2063 return result; 2064 } 2065 2066 } 2067
