#include "core/CSSValueKeywords.h"
#include "core/MediaTypeNames.h"
#include "core/StylePropertyShorthand.h"
-#include "core/css/CSSAspectRatioValue.h"
#include "core/css/CSSBasicShapes.h"
#include "core/css/CSSBorderImage.h"
#include "core/css/CSSCanvasValue.h"
#include "core/css/StyleRule.h"
#include "core/css/StyleRuleImport.h"
#include "core/css/StyleSheetContents.h"
-#include "core/css/parser/CSSParserIdioms.h"
#include "core/dom/Document.h"
#include "core/frame/FrameConsole.h"
#include "core/frame/FrameHost.h"
return m_supportsCondition;
}
-static inline bool isColorPropertyID(CSSPropertyID propertyId)
-{
- switch (propertyId) {
- case CSSPropertyColor:
- case CSSPropertyBackgroundColor:
- case CSSPropertyBorderBottomColor:
- case CSSPropertyBorderLeftColor:
- case CSSPropertyBorderRightColor:
- case CSSPropertyBorderTopColor:
- case CSSPropertyOutlineColor:
- case CSSPropertyWebkitBorderAfterColor:
- case CSSPropertyWebkitBorderBeforeColor:
- case CSSPropertyWebkitBorderEndColor:
- case CSSPropertyWebkitBorderStartColor:
- case CSSPropertyWebkitColumnRuleColor:
- case CSSPropertyWebkitTextEmphasisColor:
- case CSSPropertyWebkitTextFillColor:
- case CSSPropertyWebkitTextStrokeColor:
- case CSSPropertyTextDecorationColor:
- return true;
- default:
- return false;
- }
-}
-
-static bool parseColorValue(MutableStylePropertySet* declaration, CSSPropertyID propertyId, const String& string, bool important, CSSParserMode cssParserMode)
-{
- ASSERT(!string.isEmpty());
- bool quirksMode = isQuirksModeBehavior(cssParserMode);
- if (!isColorPropertyID(propertyId))
- return false;
- CSSParserString cssString;
- cssString.init(string);
- CSSValueID valueID = cssValueKeywordID(cssString);
- bool validPrimitive = false;
- if (valueID == CSSValueWebkitText) {
- validPrimitive = true;
- } else if (valueID == CSSValueCurrentcolor) {
- validPrimitive = true;
- } else if ((valueID >= CSSValueAqua && valueID <= CSSValueWindowtext) || valueID == CSSValueMenu
- || (quirksMode && valueID >= CSSValueWebkitFocusRingColor && valueID < CSSValueWebkitText)) {
- validPrimitive = true;
- }
-
- if (validPrimitive) {
- RefPtrWillBeRawPtr<CSSValue> value = cssValuePool().createIdentifierValue(valueID);
- declaration->addParsedProperty(CSSProperty(propertyId, value.release(), important));
- return true;
- }
- RGBA32 color;
- if (!CSSPropertyParser::fastParseColor(color, string, !quirksMode && string[0] != '#'))
- return false;
- RefPtrWillBeRawPtr<CSSValue> value = cssValuePool().createColorValue(color);
- declaration->addParsedProperty(CSSProperty(propertyId, value.release(), important));
- return true;
-}
-
-static inline bool isSimpleLengthPropertyID(CSSPropertyID propertyId, bool& acceptsNegativeNumbers)
-{
- switch (propertyId) {
- case CSSPropertyFontSize:
- case CSSPropertyHeight:
- case CSSPropertyWidth:
- case CSSPropertyMinHeight:
- case CSSPropertyMinWidth:
- case CSSPropertyPaddingBottom:
- case CSSPropertyPaddingLeft:
- case CSSPropertyPaddingRight:
- case CSSPropertyPaddingTop:
- case CSSPropertyWebkitLogicalWidth:
- case CSSPropertyWebkitLogicalHeight:
- case CSSPropertyWebkitMinLogicalWidth:
- case CSSPropertyWebkitMinLogicalHeight:
- case CSSPropertyWebkitPaddingAfter:
- case CSSPropertyWebkitPaddingBefore:
- case CSSPropertyWebkitPaddingEnd:
- case CSSPropertyWebkitPaddingStart:
- acceptsNegativeNumbers = false;
- return true;
- case CSSPropertyShapeMargin:
- acceptsNegativeNumbers = false;
- return true;
- case CSSPropertyBottom:
- case CSSPropertyLeft:
- case CSSPropertyMarginBottom:
- case CSSPropertyMarginLeft:
- case CSSPropertyMarginRight:
- case CSSPropertyMarginTop:
- case CSSPropertyRight:
- case CSSPropertyTop:
- case CSSPropertyWebkitMarginAfter:
- case CSSPropertyWebkitMarginBefore:
- case CSSPropertyWebkitMarginEnd:
- case CSSPropertyWebkitMarginStart:
- acceptsNegativeNumbers = true;
- return true;
- default:
- return false;
- }
-}
-
-template <typename CharacterType>
-static inline bool parseSimpleLength(const CharacterType* characters, unsigned length, CSSPrimitiveValue::UnitType& unit, double& number)
-{
- if (length > 2 && (characters[length - 2] | 0x20) == 'p' && (characters[length - 1] | 0x20) == 'x') {
- length -= 2;
- unit = CSSPrimitiveValue::CSS_PX;
- } else if (length > 1 && characters[length - 1] == '%') {
- length -= 1;
- unit = CSSPrimitiveValue::CSS_PERCENTAGE;
- }
-
- // We rely on charactersToDouble for validation as well. The function
- // will set "ok" to "false" if the entire passed-in character range does
- // not represent a double.
- bool ok;
- number = charactersToDouble(characters, length, &ok);
- return ok;
-}
-
-static bool parseSimpleLengthValue(MutableStylePropertySet* declaration, CSSPropertyID propertyId, const String& string, bool important, CSSParserMode cssParserMode)
-{
- ASSERT(!string.isEmpty());
- bool acceptsNegativeNumbers = false;
-
- // In @viewport, width and height are shorthands, not simple length values.
- if (isCSSViewportParsingEnabledForMode(cssParserMode) || !isSimpleLengthPropertyID(propertyId, acceptsNegativeNumbers))
- return false;
-
- unsigned length = string.length();
- double number;
- CSSPrimitiveValue::UnitType unit = CSSPrimitiveValue::CSS_NUMBER;
-
- if (string.is8Bit()) {
- if (!parseSimpleLength(string.characters8(), length, unit, number))
- return false;
- } else {
- if (!parseSimpleLength(string.characters16(), length, unit, number))
- return false;
- }
-
- if (unit == CSSPrimitiveValue::CSS_NUMBER) {
- bool quirksMode = isQuirksModeBehavior(cssParserMode);
- if (number && !quirksMode)
- return false;
- unit = CSSPrimitiveValue::CSS_PX;
- }
- if (number < 0 && !acceptsNegativeNumbers)
- return false;
-
- RefPtrWillBeRawPtr<CSSValue> value = cssValuePool().createValue(number, unit);
- declaration->addParsedProperty(CSSProperty(propertyId, value.release(), important));
- return true;
-}
-
-bool isValidKeywordPropertyAndValue(CSSPropertyID propertyId, CSSValueID valueID, const CSSParserContext& parserContext)
-{
- if (valueID == CSSValueInvalid)
- return false;
-
- switch (propertyId) {
- case CSSPropertyAll:
- return valueID == CSSValueUnset;
- case CSSPropertyBackgroundRepeatX: // repeat | no-repeat
- case CSSPropertyBackgroundRepeatY: // repeat | no-repeat
- return valueID == CSSValueRepeat || valueID == CSSValueNoRepeat;
- case CSSPropertyBorderCollapse: // collapse | separate
- return valueID == CSSValueCollapse || valueID == CSSValueSeparate;
- case CSSPropertyBorderTopStyle: // <border-style>
- case CSSPropertyBorderRightStyle: // Defined as: none | hidden | dotted | dashed |
- case CSSPropertyBorderBottomStyle: // solid | double | groove | ridge | inset | outset
- case CSSPropertyBorderLeftStyle:
- case CSSPropertyWebkitBorderAfterStyle:
- case CSSPropertyWebkitBorderBeforeStyle:
- case CSSPropertyWebkitBorderEndStyle:
- case CSSPropertyWebkitBorderStartStyle:
- case CSSPropertyWebkitColumnRuleStyle:
- return valueID >= CSSValueNone && valueID <= CSSValueDouble;
- case CSSPropertyBoxSizing:
- return valueID == CSSValueBorderBox || valueID == CSSValueContentBox;
- case CSSPropertyCaptionSide: // top | bottom | left | right
- return valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueTop || valueID == CSSValueBottom;
- case CSSPropertyClear: // none | left | right | both
- return valueID == CSSValueNone || valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueBoth;
- case CSSPropertyDirection: // ltr | rtl
- return valueID == CSSValueLtr || valueID == CSSValueRtl;
- case CSSPropertyDisplay:
- // inline | block | list-item | inline-block | table |
- // inline-table | table-row-group | table-header-group | table-footer-group | table-row |
- // table-column-group | table-column | table-cell | table-caption | -webkit-box | -webkit-inline-box | none
- // flex | inline-flex | -webkit-flex | -webkit-inline-flex | grid | inline-grid
- return (valueID >= CSSValueInline && valueID <= CSSValueInlineFlex) || valueID == CSSValueWebkitFlex || valueID == CSSValueWebkitInlineFlex || valueID == CSSValueNone
- || (RuntimeEnabledFeatures::cssGridLayoutEnabled() && (valueID == CSSValueGrid || valueID == CSSValueInlineGrid));
- case CSSPropertyEmptyCells: // show | hide
- return valueID == CSSValueShow || valueID == CSSValueHide;
- case CSSPropertyFloat: // left | right | none | center (for buggy CSS, maps to none)
- return valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueNone || valueID == CSSValueCenter;
- case CSSPropertyFontStyle: // normal | italic | oblique
- return valueID == CSSValueNormal || valueID == CSSValueItalic || valueID == CSSValueOblique;
- case CSSPropertyFontStretch: // normal | ultra-condensed | extra-condensed | condensed | semi-condensed | semi-expanded | expanded | extra-expanded | ultra-expanded
- return valueID == CSSValueNormal || (valueID >= CSSValueUltraCondensed && valueID <= CSSValueUltraExpanded);
- case CSSPropertyImageRendering: // auto | optimizeContrast | pixelated
- return valueID == CSSValueAuto || valueID == CSSValueWebkitOptimizeContrast || (RuntimeEnabledFeatures::imageRenderingPixelatedEnabled() && valueID == CSSValuePixelated);
- case CSSPropertyIsolation: // auto | isolate
- ASSERT(RuntimeEnabledFeatures::cssCompositingEnabled());
- return valueID == CSSValueAuto || valueID == CSSValueIsolate;
- case CSSPropertyListStylePosition: // inside | outside
- return valueID == CSSValueInside || valueID == CSSValueOutside;
- case CSSPropertyListStyleType:
- // See section CSS_PROP_LIST_STYLE_TYPE of file CSSValueKeywords.in
- // for the list of supported list-style-types.
- return (valueID >= CSSValueDisc && valueID <= CSSValueKatakanaIroha) || valueID == CSSValueNone;
- case CSSPropertyObjectFit:
- return valueID == CSSValueFill || valueID == CSSValueContain || valueID == CSSValueCover || valueID == CSSValueNone || valueID == CSSValueScaleDown;
- case CSSPropertyOutlineStyle: // (<border-style> except hidden) | auto
- return valueID == CSSValueAuto || valueID == CSSValueNone || (valueID >= CSSValueInset && valueID <= CSSValueDouble);
- case CSSPropertyOverflowWrap: // normal | break-word
- case CSSPropertyWordWrap:
- return valueID == CSSValueNormal || valueID == CSSValueBreakWord;
- case CSSPropertyOverflowX: // visible | hidden | scroll | auto | overlay
- return valueID == CSSValueVisible || valueID == CSSValueHidden || valueID == CSSValueScroll || valueID == CSSValueAuto || valueID == CSSValueOverlay;
- case CSSPropertyOverflowY: // visible | hidden | scroll | auto | overlay | -webkit-paged-x | -webkit-paged-y
- return valueID == CSSValueVisible || valueID == CSSValueHidden || valueID == CSSValueScroll || valueID == CSSValueAuto || valueID == CSSValueOverlay || valueID == CSSValueWebkitPagedX || valueID == CSSValueWebkitPagedY;
- case CSSPropertyPageBreakAfter: // auto | always | avoid | left | right
- case CSSPropertyPageBreakBefore:
- case CSSPropertyWebkitColumnBreakAfter:
- case CSSPropertyWebkitColumnBreakBefore:
- return valueID == CSSValueAuto || valueID == CSSValueAlways || valueID == CSSValueAvoid || valueID == CSSValueLeft || valueID == CSSValueRight;
- case CSSPropertyPageBreakInside: // avoid | auto
- case CSSPropertyWebkitColumnBreakInside:
- return valueID == CSSValueAuto || valueID == CSSValueAvoid;
- case CSSPropertyPointerEvents:
- // none | visiblePainted | visibleFill | visibleStroke | visible |
- // painted | fill | stroke | auto | all | bounding-box
- return valueID == CSSValueVisible || valueID == CSSValueNone || valueID == CSSValueAll || valueID == CSSValueAuto || (valueID >= CSSValueVisiblepainted && valueID <= CSSValueBoundingBox);
- case CSSPropertyPosition: // static | relative | absolute | fixed
- return valueID == CSSValueStatic || valueID == CSSValueRelative || valueID == CSSValueAbsolute || valueID == CSSValueFixed;
- case CSSPropertyResize: // none | both | horizontal | vertical | auto
- return valueID == CSSValueNone || valueID == CSSValueBoth || valueID == CSSValueHorizontal || valueID == CSSValueVertical || valueID == CSSValueAuto;
- case CSSPropertyScrollBehavior: // instant | smooth
- ASSERT(RuntimeEnabledFeatures::cssomSmoothScrollEnabled());
- return valueID == CSSValueInstant || valueID == CSSValueSmooth;
- case CSSPropertySpeak: // none | normal | spell-out | digits | literal-punctuation | no-punctuation
- return valueID == CSSValueNone || valueID == CSSValueNormal || valueID == CSSValueSpellOut || valueID == CSSValueDigits || valueID == CSSValueLiteralPunctuation || valueID == CSSValueNoPunctuation;
- case CSSPropertyTableLayout: // auto | fixed
- return valueID == CSSValueAuto || valueID == CSSValueFixed;
- case CSSPropertyTextAlignLast:
- // auto | start | end | left | right | center | justify
- ASSERT(RuntimeEnabledFeatures::css3TextEnabled());
- return (valueID >= CSSValueLeft && valueID <= CSSValueJustify) || valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueAuto;
- case CSSPropertyTextDecorationStyle:
- // solid | double | dotted | dashed | wavy
- ASSERT(RuntimeEnabledFeatures::css3TextDecorationsEnabled());
- return valueID == CSSValueSolid || valueID == CSSValueDouble || valueID == CSSValueDotted || valueID == CSSValueDashed || valueID == CSSValueWavy;
- case CSSPropertyTextJustify:
- // auto | none | inter-word | distribute
- ASSERT(RuntimeEnabledFeatures::css3TextEnabled());
- return valueID == CSSValueInterWord || valueID == CSSValueDistribute || valueID == CSSValueAuto || valueID == CSSValueNone;
- case CSSPropertyTextOverflow: // clip | ellipsis
- return valueID == CSSValueClip || valueID == CSSValueEllipsis;
- case CSSPropertyTextRendering: // auto | optimizeSpeed | optimizeLegibility | geometricPrecision
- return valueID == CSSValueAuto || valueID == CSSValueOptimizespeed || valueID == CSSValueOptimizelegibility || valueID == CSSValueGeometricprecision;
- case CSSPropertyTextTransform: // capitalize | uppercase | lowercase | none
- return (valueID >= CSSValueCapitalize && valueID <= CSSValueLowercase) || valueID == CSSValueNone;
- case CSSPropertyUnicodeBidi:
- return valueID == CSSValueNormal || valueID == CSSValueEmbed
- || valueID == CSSValueBidiOverride || valueID == CSSValueWebkitIsolate
- || valueID == CSSValueWebkitIsolateOverride || valueID == CSSValueWebkitPlaintext;
- case CSSPropertyTouchActionDelay: // none | script
- ASSERT(RuntimeEnabledFeatures::cssTouchActionDelayEnabled());
- return valueID == CSSValueScript || valueID == CSSValueNone;
- case CSSPropertyVisibility: // visible | hidden | collapse
- return valueID == CSSValueVisible || valueID == CSSValueHidden || valueID == CSSValueCollapse;
- case CSSPropertyWebkitAppearance:
- return (valueID >= CSSValueCheckbox && valueID <= CSSValueTextarea) || valueID == CSSValueNone;
- case CSSPropertyBackfaceVisibility:
- case CSSPropertyWebkitBackfaceVisibility:
- return valueID == CSSValueVisible || valueID == CSSValueHidden;
- case CSSPropertyMixBlendMode:
- ASSERT(RuntimeEnabledFeatures::cssCompositingEnabled());
- return valueID == CSSValueNormal || valueID == CSSValueMultiply || valueID == CSSValueScreen || valueID == CSSValueOverlay
- || valueID == CSSValueDarken || valueID == CSSValueLighten || valueID == CSSValueColorDodge || valueID == CSSValueColorBurn
- || valueID == CSSValueHardLight || valueID == CSSValueSoftLight || valueID == CSSValueDifference || valueID == CSSValueExclusion
- || valueID == CSSValueHue || valueID == CSSValueSaturation || valueID == CSSValueColor || valueID == CSSValueLuminosity;
- case CSSPropertyWebkitBorderFit:
- return valueID == CSSValueBorder || valueID == CSSValueLines;
- case CSSPropertyWebkitBoxAlign:
- return valueID == CSSValueStretch || valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline;
- case CSSPropertyWebkitBoxDecorationBreak:
- return valueID == CSSValueClone || valueID == CSSValueSlice;
- case CSSPropertyWebkitBoxDirection:
- return valueID == CSSValueNormal || valueID == CSSValueReverse;
- case CSSPropertyWebkitBoxLines:
- return valueID == CSSValueSingle || valueID == CSSValueMultiple;
- case CSSPropertyWebkitBoxOrient:
- return valueID == CSSValueHorizontal || valueID == CSSValueVertical || valueID == CSSValueInlineAxis || valueID == CSSValueBlockAxis;
- case CSSPropertyWebkitBoxPack:
- return valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueCenter || valueID == CSSValueJustify;
- case CSSPropertyColumnFill:
- ASSERT(RuntimeEnabledFeatures::regionBasedColumnsEnabled());
- return valueID == CSSValueAuto || valueID == CSSValueBalance;
- case CSSPropertyAlignContent:
- // FIXME: Per CSS alignment, this property should accept an optional <overflow-position>. We should share this parsing code with 'justify-self'.
- return valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueSpaceBetween || valueID == CSSValueSpaceAround || valueID == CSSValueStretch;
- case CSSPropertyAlignItems:
- // FIXME: Per CSS alignment, this property should accept the same arguments as 'justify-self' so we should share its parsing code.
- return valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline || valueID == CSSValueStretch;
- case CSSPropertyAlignSelf:
- // FIXME: Per CSS alignment, this property should accept the same arguments as 'justify-self' so we should share its parsing code.
- return valueID == CSSValueAuto || valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline || valueID == CSSValueStretch;
- case CSSPropertyFlexDirection:
- return valueID == CSSValueRow || valueID == CSSValueRowReverse || valueID == CSSValueColumn || valueID == CSSValueColumnReverse;
- case CSSPropertyFlexWrap:
- return valueID == CSSValueNowrap || valueID == CSSValueWrap || valueID == CSSValueWrapReverse;
- case CSSPropertyJustifyContent:
- // FIXME: Per CSS alignment, this property should accept an optional <overflow-position>. We should share this parsing code with 'justify-self'.
- return valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueSpaceBetween || valueID == CSSValueSpaceAround;
- case CSSPropertyFontKerning:
- return valueID == CSSValueAuto || valueID == CSSValueNormal || valueID == CSSValueNone;
- case CSSPropertyWebkitFontSmoothing:
- return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueAntialiased || valueID == CSSValueSubpixelAntialiased;
- case CSSPropertyWebkitLineBreak: // auto | loose | normal | strict | after-white-space
- return valueID == CSSValueAuto || valueID == CSSValueLoose || valueID == CSSValueNormal || valueID == CSSValueStrict || valueID == CSSValueAfterWhiteSpace;
- case CSSPropertyWebkitMarginAfterCollapse:
- case CSSPropertyWebkitMarginBeforeCollapse:
- case CSSPropertyWebkitMarginBottomCollapse:
- case CSSPropertyWebkitMarginTopCollapse:
- return valueID == CSSValueCollapse || valueID == CSSValueSeparate || valueID == CSSValueDiscard;
- case CSSPropertyInternalMarqueeDirection:
- return valueID == CSSValueForwards || valueID == CSSValueBackwards || valueID == CSSValueAhead || valueID == CSSValueReverse || valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueDown
- || valueID == CSSValueUp || valueID == CSSValueAuto;
- case CSSPropertyInternalMarqueeStyle:
- return valueID == CSSValueNone || valueID == CSSValueSlide || valueID == CSSValueScroll || valueID == CSSValueAlternate;
- case CSSPropertyWebkitPrintColorAdjust:
- return valueID == CSSValueExact || valueID == CSSValueEconomy;
- case CSSPropertyWebkitRtlOrdering:
- return valueID == CSSValueLogical || valueID == CSSValueVisual;
- case CSSPropertyWebkitRubyPosition:
- return valueID == CSSValueBefore || valueID == CSSValueAfter;
- case CSSPropertyWebkitTextCombine:
- return valueID == CSSValueNone || valueID == CSSValueHorizontal;
- case CSSPropertyWebkitTextEmphasisPosition:
- return valueID == CSSValueOver || valueID == CSSValueUnder;
- case CSSPropertyWebkitTextSecurity: // disc | circle | square | none
- return valueID == CSSValueDisc || valueID == CSSValueCircle || valueID == CSSValueSquare || valueID == CSSValueNone;
- case CSSPropertyTransformStyle:
- case CSSPropertyWebkitTransformStyle:
- return valueID == CSSValueFlat || valueID == CSSValuePreserve3d;
- case CSSPropertyWebkitUserDrag: // auto | none | element
- return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueElement;
- case CSSPropertyWebkitUserModify: // read-only | read-write
- return valueID == CSSValueReadOnly || valueID == CSSValueReadWrite || valueID == CSSValueReadWritePlaintextOnly;
- case CSSPropertyWebkitUserSelect: // auto | none | text | all
- return valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueText || valueID == CSSValueAll;
- case CSSPropertyWebkitWritingMode:
- return valueID >= CSSValueHorizontalTb && valueID <= CSSValueHorizontalBt;
- case CSSPropertyWhiteSpace: // normal | pre | nowrap
- return valueID == CSSValueNormal || valueID == CSSValuePre || valueID == CSSValuePreWrap || valueID == CSSValuePreLine || valueID == CSSValueNowrap;
- case CSSPropertyWordBreak: // normal | break-all | break-word (this is a custom extension)
- return valueID == CSSValueNormal || valueID == CSSValueBreakAll || valueID == CSSValueBreakWord;
- default:
- ASSERT_NOT_REACHED();
- return false;
- }
- return false;
-}
-
-bool isKeywordPropertyID(CSSPropertyID propertyId)
-{
- switch (propertyId) {
- case CSSPropertyAll:
- case CSSPropertyMixBlendMode:
- case CSSPropertyIsolation:
- case CSSPropertyBackgroundRepeatX:
- case CSSPropertyBackgroundRepeatY:
- case CSSPropertyBorderBottomStyle:
- case CSSPropertyBorderCollapse:
- case CSSPropertyBorderLeftStyle:
- case CSSPropertyBorderRightStyle:
- case CSSPropertyBorderTopStyle:
- case CSSPropertyBoxSizing:
- case CSSPropertyCaptionSide:
- case CSSPropertyClear:
- case CSSPropertyDirection:
- case CSSPropertyDisplay:
- case CSSPropertyEmptyCells:
- case CSSPropertyFloat:
- case CSSPropertyFontStyle:
- case CSSPropertyFontStretch:
- case CSSPropertyImageRendering:
- case CSSPropertyListStylePosition:
- case CSSPropertyListStyleType:
- case CSSPropertyObjectFit:
- case CSSPropertyOutlineStyle:
- case CSSPropertyOverflowWrap:
- case CSSPropertyOverflowX:
- case CSSPropertyOverflowY:
- case CSSPropertyPageBreakAfter:
- case CSSPropertyPageBreakBefore:
- case CSSPropertyPageBreakInside:
- case CSSPropertyPointerEvents:
- case CSSPropertyPosition:
- case CSSPropertyResize:
- case CSSPropertyScrollBehavior:
- case CSSPropertySpeak:
- case CSSPropertyTableLayout:
- case CSSPropertyTextAlignLast:
- case CSSPropertyTextDecorationStyle:
- case CSSPropertyTextJustify:
- case CSSPropertyTextOverflow:
- case CSSPropertyTextRendering:
- case CSSPropertyTextTransform:
- case CSSPropertyTouchActionDelay:
- case CSSPropertyUnicodeBidi:
- case CSSPropertyVisibility:
- case CSSPropertyWebkitAppearance:
- case CSSPropertyBackfaceVisibility:
- case CSSPropertyWebkitBackfaceVisibility:
- case CSSPropertyWebkitBorderAfterStyle:
- case CSSPropertyWebkitBorderBeforeStyle:
- case CSSPropertyWebkitBorderEndStyle:
- case CSSPropertyWebkitBorderFit:
- case CSSPropertyWebkitBorderStartStyle:
- case CSSPropertyWebkitBoxAlign:
- case CSSPropertyWebkitBoxDecorationBreak:
- case CSSPropertyWebkitBoxDirection:
- case CSSPropertyWebkitBoxLines:
- case CSSPropertyWebkitBoxOrient:
- case CSSPropertyWebkitBoxPack:
- case CSSPropertyWebkitColumnBreakAfter:
- case CSSPropertyWebkitColumnBreakBefore:
- case CSSPropertyWebkitColumnBreakInside:
- case CSSPropertyColumnFill:
- case CSSPropertyWebkitColumnRuleStyle:
- case CSSPropertyAlignContent:
- case CSSPropertyFlexDirection:
- case CSSPropertyFlexWrap:
- case CSSPropertyJustifyContent:
- case CSSPropertyFontKerning:
- case CSSPropertyWebkitFontSmoothing:
- case CSSPropertyWebkitLineBreak:
- case CSSPropertyWebkitMarginAfterCollapse:
- case CSSPropertyWebkitMarginBeforeCollapse:
- case CSSPropertyWebkitMarginBottomCollapse:
- case CSSPropertyWebkitMarginTopCollapse:
- case CSSPropertyInternalMarqueeDirection:
- case CSSPropertyInternalMarqueeStyle:
- case CSSPropertyWebkitPrintColorAdjust:
- case CSSPropertyWebkitRtlOrdering:
- case CSSPropertyWebkitRubyPosition:
- case CSSPropertyWebkitTextCombine:
- case CSSPropertyWebkitTextEmphasisPosition:
- case CSSPropertyWebkitTextSecurity:
- case CSSPropertyTransformStyle:
- case CSSPropertyWebkitTransformStyle:
- case CSSPropertyWebkitUserDrag:
- case CSSPropertyWebkitUserModify:
- case CSSPropertyWebkitUserSelect:
- case CSSPropertyWebkitWritingMode:
- case CSSPropertyWhiteSpace:
- case CSSPropertyWordBreak:
- case CSSPropertyWordWrap:
- return true;
- case CSSPropertyAlignItems:
- case CSSPropertyAlignSelf:
- return !RuntimeEnabledFeatures::cssGridLayoutEnabled();
- default:
- return false;
- }
-}
-
-static bool parseKeywordValue(MutableStylePropertySet* declaration, CSSPropertyID propertyId, const String& string, bool important, const CSSParserContext& parserContext)
-{
- ASSERT(!string.isEmpty());
-
- if (!isKeywordPropertyID(propertyId)) {
- // All properties accept the values of "initial" and "inherit".
- String lowerCaseString = string.lower();
- if (lowerCaseString != "initial" && lowerCaseString != "inherit")
- return false;
-
- // Parse initial/inherit shorthands using the BisonCSSParser.
- if (shorthandForProperty(propertyId).length())
- return false;
- }
-
- CSSParserString cssString;
- cssString.init(string);
- CSSValueID valueID = cssValueKeywordID(cssString);
-
- if (!valueID)
- return false;
-
- RefPtrWillBeRawPtr<CSSValue> value = nullptr;
- if (valueID == CSSValueInherit)
- value = cssValuePool().createInheritedValue();
- else if (valueID == CSSValueInitial)
- value = cssValuePool().createExplicitInitialValue();
- else if (isValidKeywordPropertyAndValue(propertyId, valueID, parserContext))
- value = cssValuePool().createIdentifierValue(valueID);
- else
- return false;
-
- declaration->addParsedProperty(CSSProperty(propertyId, value.release(), important));
- return true;
-}
-
-template <typename CharType>
-static bool parseTransformTranslateArguments(CharType*& pos, CharType* end, unsigned expectedCount, CSSTransformValue* transformValue)
-{
- while (expectedCount) {
- size_t delimiter = WTF::find(pos, end - pos, expectedCount == 1 ? ')' : ',');
- if (delimiter == kNotFound)
- return false;
- unsigned argumentLength = static_cast<unsigned>(delimiter);
- CSSPrimitiveValue::UnitType unit = CSSPrimitiveValue::CSS_NUMBER;
- double number;
- if (!parseSimpleLength(pos, argumentLength, unit, number))
- return false;
- if (unit != CSSPrimitiveValue::CSS_PX && (number || unit != CSSPrimitiveValue::CSS_NUMBER))
- return false;
- transformValue->append(cssValuePool().createValue(number, CSSPrimitiveValue::CSS_PX));
- pos += argumentLength + 1;
- --expectedCount;
- }
- return true;
-}
-
-template <typename CharType>
-static bool parseTransformNumberArguments(CharType*& pos, CharType* end, unsigned expectedCount, CSSTransformValue* transformValue)
-{
- while (expectedCount) {
- size_t delimiter = WTF::find(pos, end - pos, expectedCount == 1 ? ')' : ',');
- if (delimiter == kNotFound)
- return false;
- unsigned argumentLength = static_cast<unsigned>(delimiter);
- bool ok;
- double number = charactersToDouble(pos, argumentLength, &ok);
- if (!ok)
- return false;
- transformValue->append(cssValuePool().createValue(number, CSSPrimitiveValue::CSS_NUMBER));
- pos += argumentLength + 1;
- --expectedCount;
- }
- return true;
-}
-
-template <typename CharType>
-static PassRefPtrWillBeRawPtr<CSSTransformValue> parseSimpleTransformValue(CharType*& pos, CharType* end)
-{
- static const int shortestValidTransformStringLength = 12;
-
- if (end - pos < shortestValidTransformStringLength)
- return nullptr;
-
- const bool isTranslate = toASCIILower(pos[0]) == 't'
- && toASCIILower(pos[1]) == 'r'
- && toASCIILower(pos[2]) == 'a'
- && toASCIILower(pos[3]) == 'n'
- && toASCIILower(pos[4]) == 's'
- && toASCIILower(pos[5]) == 'l'
- && toASCIILower(pos[6]) == 'a'
- && toASCIILower(pos[7]) == 't'
- && toASCIILower(pos[8]) == 'e';
-
- if (isTranslate) {
- CSSTransformValue::TransformOperationType transformType;
- unsigned expectedArgumentCount = 1;
- unsigned argumentStart = 11;
- CharType c9 = toASCIILower(pos[9]);
- if (c9 == 'x' && pos[10] == '(') {
- transformType = CSSTransformValue::TranslateXTransformOperation;
- } else if (c9 == 'y' && pos[10] == '(') {
- transformType = CSSTransformValue::TranslateYTransformOperation;
- } else if (c9 == 'z' && pos[10] == '(') {
- transformType = CSSTransformValue::TranslateZTransformOperation;
- } else if (c9 == '(') {
- transformType = CSSTransformValue::TranslateTransformOperation;
- expectedArgumentCount = 2;
- argumentStart = 10;
- } else if (c9 == '3' && toASCIILower(pos[10]) == 'd' && pos[11] == '(') {
- transformType = CSSTransformValue::Translate3DTransformOperation;
- expectedArgumentCount = 3;
- argumentStart = 12;
- } else {
- return nullptr;
- }
- pos += argumentStart;
- RefPtrWillBeRawPtr<CSSTransformValue> transformValue = CSSTransformValue::create(transformType);
- if (!parseTransformTranslateArguments(pos, end, expectedArgumentCount, transformValue.get()))
- return nullptr;
- return transformValue.release();
- }
-
- const bool isMatrix3d = toASCIILower(pos[0]) == 'm'
- && toASCIILower(pos[1]) == 'a'
- && toASCIILower(pos[2]) == 't'
- && toASCIILower(pos[3]) == 'r'
- && toASCIILower(pos[4]) == 'i'
- && toASCIILower(pos[5]) == 'x'
- && pos[6] == '3'
- && toASCIILower(pos[7]) == 'd'
- && pos[8] == '(';
-
- if (isMatrix3d) {
- pos += 9;
- RefPtrWillBeRawPtr<CSSTransformValue> transformValue = CSSTransformValue::create(CSSTransformValue::Matrix3DTransformOperation);
- if (!parseTransformNumberArguments(pos, end, 16, transformValue.get()))
- return nullptr;
- return transformValue.release();
- }
-
- const bool isScale3d = toASCIILower(pos[0]) == 's'
- && toASCIILower(pos[1]) == 'c'
- && toASCIILower(pos[2]) == 'a'
- && toASCIILower(pos[3]) == 'l'
- && toASCIILower(pos[4]) == 'e'
- && pos[5] == '3'
- && toASCIILower(pos[6]) == 'd'
- && pos[7] == '(';
-
- if (isScale3d) {
- pos += 8;
- RefPtrWillBeRawPtr<CSSTransformValue> transformValue = CSSTransformValue::create(CSSTransformValue::Scale3DTransformOperation);
- if (!parseTransformNumberArguments(pos, end, 3, transformValue.get()))
- return nullptr;
- return transformValue.release();
- }
-
- return nullptr;
-}
-
-template <typename CharType>
-static PassRefPtrWillBeRawPtr<CSSValueList> parseSimpleTransformList(CharType*& pos, CharType* end)
-{
- RefPtrWillBeRawPtr<CSSValueList> transformList = nullptr;
- while (pos < end) {
- while (pos < end && isCSSSpace(*pos))
- ++pos;
- RefPtrWillBeRawPtr<CSSTransformValue> transformValue = parseSimpleTransformValue(pos, end);
- if (!transformValue)
- return nullptr;
- if (!transformList)
- transformList = CSSValueList::createSpaceSeparated();
- transformList->append(transformValue.release());
- if (pos < end) {
- if (isCSSSpace(*pos))
- return nullptr;
- }
- }
- return transformList.release();
-}
-
-static bool parseSimpleTransform(MutableStylePropertySet* properties, CSSPropertyID propertyID, const String& string, bool important)
-{
- if (propertyID != CSSPropertyTransform && propertyID != CSSPropertyWebkitTransform)
- return false;
- if (string.isEmpty())
- return false;
- RefPtrWillBeRawPtr<CSSValueList> transformList = nullptr;
- if (string.is8Bit()) {
- const LChar* pos = string.characters8();
- const LChar* end = pos + string.length();
- transformList = parseSimpleTransformList(pos, end);
- if (!transformList)
- return false;
- } else {
- const UChar* pos = string.characters16();
- const UChar* end = pos + string.length();
- transformList = parseSimpleTransformList(pos, end);
- if (!transformList)
- return false;
- }
- properties->addParsedProperty(CSSProperty(propertyID, transformList.release(), important));
- return true;
-}
-
bool BisonCSSParser::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important, const CSSParserContext& context)
{
ASSERT(!string.isEmpty());
-
- if (parseSimpleLengthValue(declaration, propertyID, string, important, context.mode()))
- return true;
- if (parseColorValue(declaration, propertyID, string, important, context.mode()))
- return true;
- if (parseKeywordValue(declaration, propertyID, string, important, context))
- return true;
-
BisonCSSParser parser(context);
- return parser.parseValue(declaration, propertyID, string, important, static_cast<StyleSheetContents*>(0));
+ return parser.parseValue(declaration, propertyID, string, important);
}
-bool BisonCSSParser::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important, CSSParserMode cssParserMode, StyleSheetContents* contextStyleSheet)
-{
- ASSERT(!string.isEmpty());
- if (parseSimpleLengthValue(declaration, propertyID, string, important, cssParserMode))
- return true;
- if (parseColorValue(declaration, propertyID, string, important, cssParserMode))
- return true;
-
- CSSParserContext context(cssParserMode, 0);
- if (contextStyleSheet) {
- context = contextStyleSheet->parserContext();
- context.setMode(cssParserMode);
- }
-
- if (parseKeywordValue(declaration, propertyID, string, important, context))
- return true;
- if (parseSimpleTransform(declaration, propertyID, string, important))
- return true;
-
- BisonCSSParser parser(context);
- return parser.parseValue(declaration, propertyID, string, important, contextStyleSheet);
-}
-
-bool BisonCSSParser::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important, StyleSheetContents* contextStyleSheet)
+bool BisonCSSParser::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important)
{
if (m_context.useCounter())
m_context.useCounter()->count(m_context, propertyID);
- setStyleSheet(contextStyleSheet);
-
setupParser("@-internal-value ", string, "");
m_id = propertyID;
return CSSPropertyParser::parseValue(propId, important, m_valueList.get(), m_context, m_inViewport, m_parsedProperties, m_ruleHeaderType);
}
-
-class TransformOperationInfo {
-public:
- TransformOperationInfo(const CSSParserString& name)
- : m_type(CSSTransformValue::UnknownTransformOperation)
- , m_argCount(1)
- , m_allowSingleArgument(false)
- , m_unit(CSSPropertyParser::FUnknown)
- {
- const UChar* characters;
- unsigned nameLength = name.length();
-
- const unsigned longestNameLength = 11;
- UChar characterBuffer[longestNameLength];
- if (name.is8Bit()) {
- unsigned length = std::min(longestNameLength, nameLength);
- const LChar* characters8 = name.characters8();
- for (unsigned i = 0; i < length; ++i)
- characterBuffer[i] = characters8[i];
- characters = characterBuffer;
- } else
- characters = name.characters16();
-
- SWITCH(characters, nameLength) {
- CASE("skew") {
- m_unit = CSSPropertyParser::FAngle;
- m_type = CSSTransformValue::SkewTransformOperation;
- m_allowSingleArgument = true;
- m_argCount = 3;
- }
- CASE("scale") {
- m_unit = CSSPropertyParser::FNumber;
- m_type = CSSTransformValue::ScaleTransformOperation;
- m_allowSingleArgument = true;
- m_argCount = 3;
- }
- CASE("skewx") {
- m_unit = CSSPropertyParser::FAngle;
- m_type = CSSTransformValue::SkewXTransformOperation;
- }
- CASE("skewy") {
- m_unit = CSSPropertyParser::FAngle;
- m_type = CSSTransformValue::SkewYTransformOperation;
- }
- CASE("matrix") {
- m_unit = CSSPropertyParser::FNumber;
- m_type = CSSTransformValue::MatrixTransformOperation;
- m_argCount = 11;
- }
- CASE("rotate") {
- m_unit = CSSPropertyParser::FAngle;
- m_type = CSSTransformValue::RotateTransformOperation;
- }
- CASE("scalex") {
- m_unit = CSSPropertyParser::FNumber;
- m_type = CSSTransformValue::ScaleXTransformOperation;
- }
- CASE("scaley") {
- m_unit = CSSPropertyParser::FNumber;
- m_type = CSSTransformValue::ScaleYTransformOperation;
- }
- CASE("scalez") {
- m_unit = CSSPropertyParser::FNumber;
- m_type = CSSTransformValue::ScaleZTransformOperation;
- }
- CASE("scale3d") {
- m_unit = CSSPropertyParser::FNumber;
- m_type = CSSTransformValue::Scale3DTransformOperation;
- m_argCount = 5;
- }
- CASE("rotatex") {
- m_unit = CSSPropertyParser::FAngle;
- m_type = CSSTransformValue::RotateXTransformOperation;
- }
- CASE("rotatey") {
- m_unit = CSSPropertyParser::FAngle;
- m_type = CSSTransformValue::RotateYTransformOperation;
- }
- CASE("rotatez") {
- m_unit = CSSPropertyParser::FAngle;
- m_type = CSSTransformValue::RotateZTransformOperation;
- }
- CASE("matrix3d") {
- m_unit = CSSPropertyParser::FNumber;
- m_type = CSSTransformValue::Matrix3DTransformOperation;
- m_argCount = 31;
- }
- CASE("rotate3d") {
- m_unit = CSSPropertyParser::FNumber;
- m_type = CSSTransformValue::Rotate3DTransformOperation;
- m_argCount = 7;
- }
- CASE("translate") {
- m_unit = CSSPropertyParser::FLength | CSSPropertyParser::FPercent;
- m_type = CSSTransformValue::TranslateTransformOperation;
- m_allowSingleArgument = true;
- m_argCount = 3;
- }
- CASE("translatex") {
- m_unit = CSSPropertyParser::FLength | CSSPropertyParser::FPercent;
- m_type = CSSTransformValue::TranslateXTransformOperation;
- }
- CASE("translatey") {
- m_unit = CSSPropertyParser::FLength | CSSPropertyParser::FPercent;
- m_type = CSSTransformValue::TranslateYTransformOperation;
- }
- CASE("translatez") {
- m_unit = CSSPropertyParser::FLength | CSSPropertyParser::FPercent;
- m_type = CSSTransformValue::TranslateZTransformOperation;
- }
- CASE("perspective") {
- m_unit = CSSPropertyParser::FNumber;
- m_type = CSSTransformValue::PerspectiveTransformOperation;
- }
- CASE("translate3d") {
- m_unit = CSSPropertyParser::FLength | CSSPropertyParser::FPercent;
- m_type = CSSTransformValue::Translate3DTransformOperation;
- m_argCount = 5;
- }
- }
- }
-
- CSSTransformValue::TransformOperationType type() const { return m_type; }
- unsigned argCount() const { return m_argCount; }
- CSSPropertyParser::Units unit() const { return m_unit; }
-
- bool unknown() const { return m_type == CSSTransformValue::UnknownTransformOperation; }
- bool hasCorrectArgCount(unsigned argCount) { return m_argCount == argCount || (m_allowSingleArgument && argCount == 1); }
-
-private:
- CSSTransformValue::TransformOperationType m_type;
- unsigned m_argCount;
- bool m_allowSingleArgument;
- CSSPropertyParser::Units m_unit;
-};
-
-PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseTransform(CSSPropertyID propId)
-{
- if (!m_valueList)
- return nullptr;
-
- RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
- for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
- RefPtrWillBeRawPtr<CSSValue> parsedTransformValue = parseTransformValue(propId, value);
- if (!parsedTransformValue)
- return nullptr;
-
- list->append(parsedTransformValue.release());
- }
-
- return list.release();
-}
-
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseTransformValue(CSSPropertyID propId, CSSParserValue *value)
-{
- if (value->unit != CSSParserValue::Function || !value->function)
- return nullptr;
-
- // Every primitive requires at least one argument.
- CSSParserValueList* args = value->function->args.get();
- if (!args)
- return nullptr;
-
- // See if the specified primitive is one we understand.
- TransformOperationInfo info(value->function->name);
- if (info.unknown())
- return nullptr;
-
- if (!info.hasCorrectArgCount(args->size()))
- return nullptr;
-
- // The transform is a list of functional primitives that specify transform operations.
- // We collect a list of CSSTransformValues, where each value specifies a single operation.
-
- // Create the new CSSTransformValue for this operation and add it to our list.
- RefPtrWillBeRawPtr<CSSTransformValue> transformValue = CSSTransformValue::create(info.type());
-
- // Snag our values.
- CSSParserValue* a = args->current();
- unsigned argNumber = 0;
- while (a) {
- CSSPropertyParser::Units unit = info.unit();
-
- if (info.type() == CSSTransformValue::Rotate3DTransformOperation && argNumber == 3) {
- // 4th param of rotate3d() is an angle rather than a bare number, validate it as such
- if (!validUnit(a, FAngle, HTMLStandardMode))
- return nullptr;
- } else if (info.type() == CSSTransformValue::Translate3DTransformOperation && argNumber == 2) {
- // 3rd param of translate3d() cannot be a percentage
- if (!validUnit(a, FLength, HTMLStandardMode))
- return nullptr;
- } else if (info.type() == CSSTransformValue::TranslateZTransformOperation && !argNumber) {
- // 1st param of translateZ() cannot be a percentage
- if (!validUnit(a, FLength, HTMLStandardMode))
- return nullptr;
- } else if (info.type() == CSSTransformValue::PerspectiveTransformOperation && !argNumber) {
- // 1st param of perspective() must be a non-negative number (deprecated) or length.
- if ((propId == CSSPropertyWebkitTransform && !validUnit(a, FNumber | FLength | FNonNeg, HTMLStandardMode))
- || (propId == CSSPropertyTransform && !validUnit(a, FLength | FNonNeg, HTMLStandardMode)))
- return nullptr;
- } else if (!validUnit(a, unit, HTMLStandardMode)) {
- return nullptr;
- }
-
- // Add the value to the current transform operation.
- transformValue->append(createPrimitiveNumericValue(a));
-
- a = args->next();
- if (!a)
- break;
- if (a->unit != CSSParserValue::Operator || a->iValue != ',')
- return nullptr;
- a = args->next();
-
- argNumber++;
- }
-
- return transformValue.release();
-}
-
void BisonCSSParser::ensureLineEndings()
{
if (!m_lineEndings)
return adoptPtr(list);
}
-CSSParserFunction* BisonCSSParser::createFloatingFunction()
+CSSParserFunction* BisonCSSParser::createFloatingFunction(const CSSParserString& name, PassOwnPtr<CSSParserValueList> args)
{
CSSParserFunction* function = new CSSParserFunction;
m_floatingFunctions.append(function);
- return function;
-}
-
-CSSParserFunction* BisonCSSParser::createFloatingFunction(const CSSParserString& name, PassOwnPtr<CSSParserValueList> args)
-{
- CSSParserFunction* function = createFloatingFunction();
- function->name = name;
+ function->id = cssValueKeywordID(name);
function->args = args;
return function;
}
return value;
}
+void BisonCSSParser::startMediaValue()
+{
+ if (!m_observer)
+ return;
+ m_mediaQueryValueStartOffset = m_tokenizer.safeUserStringTokenOffset();
+}
+
+void BisonCSSParser::endMediaValue()
+{
+ if (!m_observer)
+ return;
+ m_mediaQueryValueEndOffset = m_tokenizer.safeUserStringTokenOffset();
+}
+
+void BisonCSSParser::startMediaQuery()
+{
+ if (!m_observer)
+ return;
+ m_observer->startMediaQuery();
+}
+
MediaQueryExp* BisonCSSParser::createFloatingMediaQueryExp(const AtomicString& mediaFeature, CSSParserValueList* values)
{
m_floatingMediaQueryExp = MediaQueryExp::createIfValid(mediaFeature, values);
+ if (m_observer && m_floatingMediaQueryExp.get() && values) {
+ m_observer->startMediaQueryExp(m_mediaQueryValueStartOffset);
+ m_observer->endMediaQueryExp(m_mediaQueryValueEndOffset);
+ }
return m_floatingMediaQueryExp.get();
}
MediaQuery* BisonCSSParser::createFloatingMediaQuery(MediaQuery::Restrictor restrictor, const AtomicString& mediaType, PassOwnPtrWillBeRawPtr<WillBeHeapVector<OwnPtrWillBeMember<MediaQueryExp> > > expressions)
{
m_floatingMediaQuery = adoptPtrWillBeNoop(new MediaQuery(restrictor, mediaType, expressions));
+ if (m_observer)
+ m_observer->endMediaQuery();
return m_floatingMediaQuery.get();
}
CSSParserSelector* BisonCSSParser::rewriteSpecifiersWithElementNameForCustomPseudoElement(const QualifiedName& tag, const AtomicString& elementName, CSSParserSelector* specifiers, bool tagIsForNamespaceRule)
{
- if (m_context.useCounter() && specifiers->pseudoType() == CSSSelector::PseudoUserAgentCustomElement)
- m_context.useCounter()->count(UseCounter::CSSPseudoElementUserAgentCustomPseudo);
-
CSSParserSelector* lastShadowPseudo = specifiers;
CSSParserSelector* history = specifiers;
while (history->tagHistory()) {
// We therefore create a new Selector with that combinator here in any case, even if matching any (host) element in any namespace (i.e. '*').
OwnPtr<CSSParserSelector> elementNameSelector = adoptPtr(new CSSParserSelector(tag));
last->setTagHistory(elementNameSelector.release());
- last->setRelation(CSSSelector::SubSelector);
return specifiers;
}
projects / platform / framework / web / crosswalk.git / blobdiff