Rename CSS Exclusions "rect" value to "rectangle"
[WebKit-https.git] / Source / WebCore / css / CSSParser.cpp
1 /*
2  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
3  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
4  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
5  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
6  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
7  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
8  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Library General Public
12  * License as published by the Free Software Foundation; either
13  * version 2 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Library General Public License for more details.
19  *
20  * You should have received a copy of the GNU Library General Public License
21  * along with this library; see the file COPYING.LIB.  If not, write to
22  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
23  * Boston, MA 02110-1301, USA.
24  */
25
26 #include "config.h"
27 #include "CSSParser.h"
28
29 #include "CSSAspectRatioValue.h"
30 #include "CSSBorderImage.h"
31 #include "CSSCanvasValue.h"
32 #include "CSSCrossfadeValue.h"
33 #include "CSSCursorImageValue.h"
34 #include "CSSFontFaceRule.h"
35 #include "CSSFontFaceSrcValue.h"
36 #include "CSSFunctionValue.h"
37 #include "CSSGradientValue.h"
38 #if ENABLE(CSS_IMAGE_SET)
39 #include "CSSImageSetValue.h"
40 #endif
41 #include "CSSImageValue.h"
42 #include "CSSImportRule.h"
43 #include "CSSInheritedValue.h"
44 #include "CSSInitialValue.h"
45 #include "CSSLineBoxContainValue.h"
46 #include "CSSMediaRule.h"
47 #include "CSSPageRule.h"
48 #include "CSSPrimitiveValue.h"
49 #include "CSSProperty.h"
50 #include "CSSPropertySourceData.h"
51 #include "CSSReflectValue.h"
52 #include "CSSSelector.h"
53 #include "CSSStyleRule.h"
54 #include "CSSStyleSheet.h"
55 #include "CSSTimingFunctionValue.h"
56 #include "CSSUnicodeRangeValue.h"
57 #include "CSSValueKeywords.h"
58 #include "CSSValueList.h"
59 #include "CSSValuePool.h"
60 #include "CSSWrapShapes.h"
61 #include "Counter.h"
62 #include "Document.h"
63 #include "FloatConversion.h"
64 #include "FontFeatureValue.h"
65 #include "FontValue.h"
66 #include "HTMLParserIdioms.h"
67 #include "HashTools.h"
68 #include "MediaList.h"
69 #include "MediaQueryExp.h"
70 #include "Page.h"
71 #include "Pair.h"
72 #include "Rect.h"
73 #include "RenderTheme.h"
74 #include "Settings.h"
75 #include "ShadowValue.h"
76 #include "StylePropertySet.h"
77 #include "StylePropertyShorthand.h"
78 #include "StyleRule.h"
79 #if ENABLE(CSS_FILTERS)
80 #include "WebKitCSSFilterValue.h"
81 #endif
82 #include "WebKitCSSKeyframeRule.h"
83 #include "WebKitCSSKeyframesRule.h"
84 #include "WebKitCSSRegionRule.h"
85 #include "WebKitCSSTransformValue.h"
86 #if ENABLE(CSS_SHADERS)
87 #include "WebKitCSSShaderValue.h"
88 #endif
89 #include <limits.h>
90 #include <wtf/HexNumber.h>
91 #include <wtf/dtoa.h>
92 #include <wtf/text/StringBuffer.h>
93 #include <wtf/text/StringBuilder.h>
94
95 #if ENABLE(DASHBOARD_SUPPORT)
96 #include "DashboardRegion.h"
97 #endif
98
99 #define YYDEBUG 0
100
101 #if YYDEBUG > 0
102 extern int cssyydebug;
103 #endif
104
105 extern int cssyyparse(void* parser);
106
107 using namespace std;
108 using namespace WTF;
109
110 namespace {
111
112 enum PropertyType {
113     PropertyExplicit,
114     PropertyImplicit
115 };
116
117 class ImplicitScope {
118     WTF_MAKE_NONCOPYABLE(ImplicitScope);
119 public:
120     ImplicitScope(WebCore::CSSParser* parser, PropertyType propertyType)
121         : m_parser(parser)
122     {
123         m_parser->m_implicitShorthand = propertyType == PropertyImplicit;
124     }
125
126     ~ImplicitScope()
127     {
128         m_parser->m_implicitShorthand = false;
129     }
130
131 private:
132     WebCore::CSSParser* m_parser;
133 };
134
135 } // namespace
136
137 namespace WebCore {
138
139 static const unsigned INVALID_NUM_PARSED_PROPERTIES = UINT_MAX;
140 static const double MAX_SCALE = 1000000;
141
142 static bool equal(const CSSParserString& a, const char* b)
143 {
144     for (int i = 0; i < a.length; ++i) {
145         if (!b[i])
146             return false;
147         if (a.characters[i] != b[i])
148             return false;
149     }
150     return !b[a.length];
151 }
152
153 static bool equalIgnoringCase(const CSSParserString& a, const char* b)
154 {
155     for (int i = 0; i < a.length; ++i) {
156         if (!b[i])
157             return false;
158         ASSERT(!isASCIIUpper(b[i]));
159         if (toASCIILower(a.characters[i]) != b[i])
160             return false;
161     }
162     return !b[a.length];
163 }
164
165 static bool hasPrefix(const char* string, unsigned length, const char* prefix)
166 {
167     for (unsigned i = 0; i < length; ++i) {
168         if (!prefix[i])
169             return true;
170         if (string[i] != prefix[i])
171             return false;
172     }
173     return false;
174 }
175
176 inline void CSSParser::ensureCSSValuePool()
177 {
178     if (!m_cssValuePool)
179         m_cssValuePool = CSSValuePool::create();
180 }
181
182 CSSParser::CSSParser(CSSParserMode cssParserMode)
183     : m_cssParserMode(cssParserMode)
184     , m_important(false)
185     , m_id(CSSPropertyInvalid)
186     , m_styleSheet(0)
187     , m_inParseShorthand(0)
188     , m_currentShorthand(CSSPropertyInvalid)
189     , m_implicitShorthand(false)
190     , m_hasFontFaceOnlyValues(false)
191     , m_hadSyntacticallyValidCSSRule(false)
192     , m_defaultNamespace(starAtom)
193     , m_inStyleRuleOrDeclaration(false)
194     , m_selectorListRange(0, 0)
195     , m_ruleBodyRange(0, 0)
196     , m_propertyRange(UINT_MAX, UINT_MAX)
197     , m_ruleRangeMap(0)
198     , m_currentRuleData(0)
199     , m_parsingMode(NormalMode)
200     , m_currentCharacter(0)
201     , m_token(0)
202     , m_lineNumber(0)
203     , m_lastSelectorLineNumber(0)
204     , m_allowImportRules(true)
205     , m_allowNamespaceDeclarations(true)
206 {
207 #if YYDEBUG > 0
208     cssyydebug = 1;
209 #endif
210     CSSPropertySourceData::init();
211 }
212
213 CSSParser::~CSSParser()
214 {
215     clearProperties();
216
217     fastDeleteAllValues(m_floatingSelectors);
218     deleteAllValues(m_floatingSelectorVectors);
219     deleteAllValues(m_floatingValueLists);
220     deleteAllValues(m_floatingFunctions);
221 }
222
223 void CSSParserString::lower()
224 {
225     // FIXME: If we need Unicode lowercasing here, then we probably want the real kind
226     // that can potentially change the length of the string rather than the character
227     // by character kind. If we don't need Unicode lowercasing, it would be good to
228     // simplify this function.
229
230     if (charactersAreAllASCII(characters, length)) {
231         // Fast case for all-ASCII.
232         for (int i = 0; i < length; i++)
233             characters[i] = toASCIILower(characters[i]);
234     } else {
235         for (int i = 0; i < length; i++)
236             characters[i] = Unicode::toLower(characters[i]);
237     }
238 }
239
240 void CSSParser::setupParser(const char* prefix, const String& string, const char* suffix)
241 {
242     int length = string.length() + strlen(prefix) + strlen(suffix) + 1;
243
244     m_dataStart = adoptArrayPtr(new UChar[length]);
245     for (unsigned i = 0; i < strlen(prefix); i++)
246         m_dataStart[i] = prefix[i];
247
248     memcpy(m_dataStart.get() + strlen(prefix), string.characters(), string.length() * sizeof(UChar));
249
250     unsigned start = strlen(prefix) + string.length();
251     unsigned end = start + strlen(suffix);
252     for (unsigned i = start; i < end; i++)
253         m_dataStart[i] = suffix[i - start];
254
255     m_dataStart[length - 1] = 0;
256
257     m_currentCharacter = m_tokenStart = m_dataStart.get();
258     resetRuleBodyMarks();
259 }
260
261 void CSSParser::parseSheet(CSSStyleSheet* sheet, const String& string, int startLineNumber, StyleRuleRangeMap* ruleRangeMap)
262 {
263     setStyleSheet(sheet);
264     m_defaultNamespace = starAtom; // Reset the default namespace.
265     m_ruleRangeMap = ruleRangeMap;
266     if (ruleRangeMap) {
267         m_currentRuleData = CSSRuleSourceData::create();
268         m_currentRuleData->styleSourceData = CSSStyleSourceData::create();
269     }
270
271     m_lineNumber = startLineNumber;
272     setupParser("", string, "");
273     cssyyparse(this);
274     m_ruleRangeMap = 0;
275     m_currentRuleData = 0;
276     m_rule = 0;
277 }
278
279 PassRefPtr<StyleRuleBase> CSSParser::parseRule(CSSStyleSheet* sheet, const String& string)
280 {
281     setStyleSheet(sheet);
282     m_allowNamespaceDeclarations = false;
283     setupParser("@-webkit-rule{", string, "} ");
284     cssyyparse(this);
285     return m_rule.release();
286 }
287
288 PassRefPtr<StyleKeyframe> CSSParser::parseKeyframeRule(CSSStyleSheet *sheet, const String &string)
289 {
290     setStyleSheet(sheet);
291     setupParser("@-webkit-keyframe-rule{ ", string, "} ");
292     cssyyparse(this);
293     return m_keyframe.release();
294 }
295
296 static inline bool isColorPropertyID(CSSPropertyID propertyId)
297 {
298     switch (propertyId) {
299     case CSSPropertyColor:
300     case CSSPropertyBackgroundColor:
301     case CSSPropertyBorderBottomColor:
302     case CSSPropertyBorderLeftColor:
303     case CSSPropertyBorderRightColor:
304     case CSSPropertyBorderTopColor:
305     case CSSPropertyOutlineColor:
306     case CSSPropertyTextLineThroughColor:
307     case CSSPropertyTextOverlineColor:
308     case CSSPropertyTextUnderlineColor:
309     case CSSPropertyWebkitBorderAfterColor:
310     case CSSPropertyWebkitBorderBeforeColor:
311     case CSSPropertyWebkitBorderEndColor:
312     case CSSPropertyWebkitBorderStartColor:
313     case CSSPropertyWebkitColumnRuleColor:
314     case CSSPropertyWebkitTextEmphasisColor:
315     case CSSPropertyWebkitTextFillColor:
316     case CSSPropertyWebkitTextStrokeColor:
317         return true;
318     default:
319         return false;
320     }
321 }
322
323 static bool parseColorValue(StylePropertySet* declaration, CSSPropertyID propertyId, const String& string, bool important, CSSParserMode cssParserMode, CSSStyleSheet* contextStyleSheet)
324 {
325     bool strict = isStrictParserMode(cssParserMode);
326     if (!string.length())
327         return false;
328     if (!isColorPropertyID(propertyId))
329         return false;
330     CSSParserString cssString;
331     cssString.characters = const_cast<UChar*>(string.characters());
332     cssString.length = string.length();
333     int valueID = cssValueKeywordID(cssString);
334     bool validPrimitive = false;
335     if (valueID == CSSValueWebkitText)
336         validPrimitive = true;
337     else if (valueID == CSSValueCurrentcolor)
338         validPrimitive = true;
339     else if ((valueID >= CSSValueAqua && valueID <= CSSValueWindowtext) || valueID == CSSValueMenu
340              || (valueID >= CSSValueWebkitFocusRingColor && valueID < CSSValueWebkitText && !strict)) {
341         validPrimitive = true;
342     }
343
344     Document* document = contextStyleSheet->findDocument();
345     if (validPrimitive) {
346         RefPtr<CSSValue> value;
347         if (document)
348             value = document->cssValuePool()->createIdentifierValue(valueID);
349         else
350             value = CSSPrimitiveValue::createIdentifier(valueID);
351         declaration->addParsedProperty(CSSProperty(propertyId, value.release(), important));
352         return true;
353     }
354     RGBA32 color;
355     if (!CSSParser::fastParseColor(color, string, strict && string[0] != '#'))
356         return false;
357     RefPtr<CSSValue> value;
358     if (document)
359         value = document->cssValuePool()->createColorValue(color);
360     else
361         value = CSSPrimitiveValue::createColor(color);
362     declaration->addParsedProperty(CSSProperty(propertyId, value.release(), important));
363     return true;
364 }
365
366 static inline bool isSimpleLengthPropertyID(CSSPropertyID propertyId, bool& acceptsNegativeNumbers)
367 {
368     switch (propertyId) {
369     case CSSPropertyFontSize:
370     case CSSPropertyHeight:
371     case CSSPropertyWidth:
372     case CSSPropertyMinHeight:
373     case CSSPropertyMinWidth:
374     case CSSPropertyPaddingBottom:
375     case CSSPropertyPaddingLeft:
376     case CSSPropertyPaddingRight:
377     case CSSPropertyPaddingTop:
378     case CSSPropertyWebkitLogicalWidth:
379     case CSSPropertyWebkitLogicalHeight:
380     case CSSPropertyWebkitMinLogicalWidth:
381     case CSSPropertyWebkitMinLogicalHeight:
382     case CSSPropertyWebkitPaddingAfter:
383     case CSSPropertyWebkitPaddingBefore:
384     case CSSPropertyWebkitPaddingEnd:
385     case CSSPropertyWebkitPaddingStart:
386     case CSSPropertyWebkitWrapMargin:
387     case CSSPropertyWebkitWrapPadding:
388         acceptsNegativeNumbers = false;
389         return true;
390     case CSSPropertyBottom:
391     case CSSPropertyLeft:
392     case CSSPropertyMarginBottom:
393     case CSSPropertyMarginLeft:
394     case CSSPropertyMarginRight:
395     case CSSPropertyMarginTop:
396     case CSSPropertyRight:
397     case CSSPropertyTextIndent:
398     case CSSPropertyTop:
399     case CSSPropertyWebkitMarginAfter:
400     case CSSPropertyWebkitMarginBefore:
401     case CSSPropertyWebkitMarginEnd:
402     case CSSPropertyWebkitMarginStart:
403         acceptsNegativeNumbers = true;
404         return true;
405     default:
406         return false;
407     }
408 }
409
410 static bool parseSimpleLengthValue(StylePropertySet* declaration, CSSPropertyID propertyId, const String& string, bool important, CSSParserMode cssParserMode, CSSStyleSheet* contextStyleSheet)
411 {
412     bool acceptsNegativeNumbers;
413     bool strict = isStrictParserMode(cssParserMode);
414     unsigned length = string.length();
415
416     if (!length)
417         return false;
418
419     double number;
420     bool ok;
421     CSSPrimitiveValue::UnitTypes unit = CSSPrimitiveValue::CSS_NUMBER;
422
423     if (string.is8Bit()) {
424         const LChar* characters8 = string.characters8();
425         if (!characters8)
426             return false;
427
428         if (!isSimpleLengthPropertyID(propertyId, acceptsNegativeNumbers))
429             return false;
430
431         if (length > 2 && (characters8[length - 2] | 0x20) == 'p' && (characters8[length - 1] | 0x20) == 'x') {
432             length -= 2;
433             unit = CSSPrimitiveValue::CSS_PX;
434         } else if (length > 1 && characters8[length - 1] == '%') {
435             length -= 1;
436             unit = CSSPrimitiveValue::CSS_PERCENTAGE;
437         }
438
439         // We rely on charactersToDouble for validation as well. The function
440         // will set "ok" to "false" if the entire passed-in character range does
441         // not represent a double.
442         number = charactersToDouble(characters8, length, &ok);
443     } else {
444         const UChar* characters16 = string.characters16();
445         if (!characters16)
446             return false;
447
448         if (!isSimpleLengthPropertyID(propertyId, acceptsNegativeNumbers))
449             return false;
450
451         if (length > 2 && (characters16[length - 2] | 0x20) == 'p' && (characters16[length - 1] | 0x20) == 'x') {
452             length -= 2;
453             unit = CSSPrimitiveValue::CSS_PX;
454         } else if (length > 1 && characters16[length - 1] == '%') {
455             length -= 1;
456             unit = CSSPrimitiveValue::CSS_PERCENTAGE;
457         }
458
459         // We rely on charactersToDouble for validation as well. The function
460         // will set "ok" to "false" if the entire passed-in character range does
461         // not represent a double.
462         number = charactersToDouble(characters16, length, &ok);
463     }
464
465     if (!ok)
466         return false;
467     if (unit == CSSPrimitiveValue::CSS_NUMBER) {
468         if (number && strict)
469             return false;
470         unit = CSSPrimitiveValue::CSS_PX;
471     }
472     if (number < 0 && !acceptsNegativeNumbers)
473         return false;
474
475     Document* document = contextStyleSheet->findDocument();
476     RefPtr<CSSValue> value;
477     if (document)
478         value = document->cssValuePool()->createValue(number, unit);
479     else
480         value = CSSPrimitiveValue::create(number, unit);
481     declaration->addParsedProperty(CSSProperty(propertyId, value.release(), important));
482     return true;
483 }
484
485 static inline bool isValidKeywordPropertyAndValue(CSSPropertyID propertyId, int valueID)
486 {
487     if (!valueID)
488         return false;
489
490     switch (propertyId) {
491     case CSSPropertyBorderCollapse: // collapse | separate | inherit
492         if (valueID == CSSValueCollapse || valueID == CSSValueSeparate)
493             return true;
494         break;
495     case CSSPropertyBorderTopStyle: // <border-style> | inherit
496     case CSSPropertyBorderRightStyle: // Defined as: none | hidden | dotted | dashed |
497     case CSSPropertyBorderBottomStyle: // solid | double | groove | ridge | inset | outset
498     case CSSPropertyBorderLeftStyle:
499     case CSSPropertyWebkitBorderAfterStyle:
500     case CSSPropertyWebkitBorderBeforeStyle:
501     case CSSPropertyWebkitBorderEndStyle:
502     case CSSPropertyWebkitBorderStartStyle:
503     case CSSPropertyWebkitColumnRuleStyle:
504         if (valueID >= CSSValueNone && valueID <= CSSValueDouble)
505             return true;
506         break;
507     case CSSPropertyBoxSizing:
508          if (valueID == CSSValueBorderBox || valueID == CSSValueContentBox)
509              return true;
510          break;
511     case CSSPropertyCaptionSide: // top | bottom | left | right | inherit
512         if (valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueTop || valueID == CSSValueBottom)
513             return true;
514         break;
515     case CSSPropertyClear: // none | left | right | both | inherit
516         if (valueID == CSSValueNone || valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueBoth)
517             return true;
518         break;
519     case CSSPropertyDirection: // ltr | rtl | inherit
520         if (valueID == CSSValueLtr || valueID == CSSValueRtl)
521             return true;
522         break;
523     case CSSPropertyDisplay:
524         // inline | block | list-item | run-in | inline-block | table |
525         // inline-table | table-row-group | table-header-group | table-footer-group | table-row |
526         // table-column-group | table-column | table-cell | table-caption | -webkit-box | -webkit-inline-box | none | inherit
527         // -webkit-flexbox | -webkit-inline-flexbox | -webkit-grid | -webkit-inline-grid
528         if ((valueID >= CSSValueInline && valueID <= CSSValueWebkitInlineFlexbox) || valueID == CSSValueNone)
529             return true;
530 #if ENABLE(CSS_GRID_LAYOUT)
531         if (valueID == CSSValueWebkitGrid || valueID == CSSValueWebkitInlineGrid)
532             return true;
533 #endif
534         break;
535     case CSSPropertyEmptyCells: // show | hide | inherit
536         if (valueID == CSSValueShow || valueID == CSSValueHide)
537             return true;
538         break;
539     case CSSPropertyFloat: // left | right | none | positioned | center (for buggy CSS, maps to none)
540         if (valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueNone || valueID == CSSValueCenter || valueID == CSSValueWebkitPositioned)
541             return true;
542         break;
543     case CSSPropertyFontStyle: // normal | italic | oblique | inherit
544         if (valueID == CSSValueNormal || valueID == CSSValueItalic || valueID == CSSValueOblique)
545             return true;
546         break;
547     case CSSPropertyImageRendering: // auto | optimizeContrast
548         if (valueID == CSSValueAuto || valueID == CSSValueWebkitOptimizeContrast)
549             return true;
550         break;
551     case CSSPropertyListStylePosition: // inside | outside | inherit
552         if (valueID == CSSValueInside || valueID == CSSValueOutside)
553             return true;
554         break;
555     case CSSPropertyListStyleType:
556         // See section CSS_PROP_LIST_STYLE_TYPE of file CSSValueKeywords.in
557         // for the list of supported list-style-types.
558         if ((valueID >= CSSValueDisc && valueID <= CSSValueKatakanaIroha) || valueID == CSSValueNone)
559             return true;
560         break;
561     case CSSPropertyOutlineStyle: // (<border-style> except hidden) | auto | inherit
562         if (valueID == CSSValueAuto || valueID == CSSValueNone || (valueID >= CSSValueInset && valueID <= CSSValueDouble))
563             return true;
564         break;
565     case CSSPropertyOverflowX:
566     case CSSPropertyOverflowY: // visible | hidden | scroll | auto | marquee | overlay | inherit
567         if (valueID == CSSValueVisible || valueID == CSSValueHidden || valueID == CSSValueScroll || valueID == CSSValueAuto || valueID == CSSValueOverlay || valueID == CSSValueWebkitMarquee)
568             return true;
569         break;
570     case CSSPropertyPointerEvents:
571         // none | visiblePainted | visibleFill | visibleStroke | visible |
572         // painted | fill | stroke | auto | all | inherit
573         if (valueID == CSSValueVisible || valueID == CSSValueNone || valueID == CSSValueAll || valueID == CSSValueAuto || (valueID >= CSSValueVisiblepainted && valueID <= CSSValueStroke))
574             return true;
575         break;
576     case CSSPropertyPosition: // static | relative | absolute | fixed | inherit
577         if (valueID == CSSValueStatic || valueID == CSSValueRelative || valueID == CSSValueAbsolute || valueID == CSSValueFixed)
578             return true;
579         break;
580     case CSSPropertyResize: // none | both | horizontal | vertical | auto
581         if (valueID == CSSValueNone || valueID == CSSValueBoth || valueID == CSSValueHorizontal || valueID == CSSValueVertical || valueID == CSSValueAuto)
582             return true;
583         break;
584     case CSSPropertySpeak: // none | normal | spell-out | digits | literal-punctuation | no-punctuation | inherit
585         if (valueID == CSSValueNone || valueID == CSSValueNormal || valueID == CSSValueSpellOut || valueID == CSSValueDigits || valueID == CSSValueLiteralPunctuation || valueID == CSSValueNoPunctuation)
586             return true;
587         break;
588     case CSSPropertyTableLayout: // auto | fixed | inherit
589         if (valueID == CSSValueAuto || valueID == CSSValueFixed)
590             return true;
591         break;
592     case CSSPropertyTextLineThroughMode:
593     case CSSPropertyTextOverlineMode:
594     case CSSPropertyTextUnderlineMode:
595         if (valueID == CSSValueContinuous || valueID == CSSValueSkipWhiteSpace)
596             return true;
597         break;
598     case CSSPropertyTextLineThroughStyle:
599     case CSSPropertyTextOverlineStyle:
600     case CSSPropertyTextUnderlineStyle:
601         if (valueID == CSSValueNone || valueID == CSSValueSolid || valueID == CSSValueDouble || valueID == CSSValueDashed || valueID == CSSValueDotDash || valueID == CSSValueDotDotDash || valueID == CSSValueWave)
602             return true;
603         break;
604     case CSSPropertyTextOverflow: // clip | ellipsis
605         if (valueID == CSSValueClip || valueID == CSSValueEllipsis)
606             return true;
607         break;
608     case CSSPropertyTextRendering: // auto | optimizeSpeed | optimizeLegibility | geometricPrecision
609         if (valueID == CSSValueAuto || valueID == CSSValueOptimizespeed || valueID == CSSValueOptimizelegibility || valueID == CSSValueGeometricprecision)
610             return true;
611         break;
612     case CSSPropertyTextTransform: // capitalize | uppercase | lowercase | none | inherit
613         if ((valueID >= CSSValueCapitalize && valueID <= CSSValueLowercase) || valueID == CSSValueNone)
614             return true;
615         break;
616     case CSSPropertyVisibility: // visible | hidden | collapse | inherit
617         if (valueID == CSSValueVisible || valueID == CSSValueHidden || valueID == CSSValueCollapse)
618             return true;
619         break;
620     case CSSPropertyWebkitAppearance:
621         if ((valueID >= CSSValueCheckbox && valueID <= CSSValueTextarea) || valueID == CSSValueNone)
622             return true;
623         break;
624     case CSSPropertyWebkitBackfaceVisibility:
625         if (valueID == CSSValueVisible || valueID == CSSValueHidden)
626             return true;
627         break;
628     case CSSPropertyWebkitBorderFit:
629         if (valueID == CSSValueBorder || valueID == CSSValueLines)
630             return true;
631         break;
632     case CSSPropertyWebkitBoxAlign:
633         if (valueID == CSSValueStretch || valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline)
634             return true;
635         break;
636     case CSSPropertyWebkitBoxDirection:
637         if (valueID == CSSValueNormal || valueID == CSSValueReverse)
638             return true;
639         break;
640     case CSSPropertyWebkitBoxLines:
641         if (valueID == CSSValueSingle || valueID == CSSValueMultiple)
642                 return true;
643         break;
644     case CSSPropertyWebkitBoxOrient:
645         if (valueID == CSSValueHorizontal || valueID == CSSValueVertical || valueID == CSSValueInlineAxis || valueID == CSSValueBlockAxis)
646             return true;
647         break;
648     case CSSPropertyWebkitBoxPack:
649         if (valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueCenter || valueID == CSSValueJustify)
650             return true;
651         break;
652     case CSSPropertyWebkitColorCorrection:
653         if (valueID == CSSValueSrgb || valueID == CSSValueDefault)
654             return true;
655         break;
656     case CSSPropertyWebkitFlexAlign:
657         if (valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline || valueID == CSSValueStretch)
658             return true;
659         break;
660     case CSSPropertyWebkitFlexDirection:
661         if (valueID == CSSValueRow || valueID == CSSValueRowReverse || valueID == CSSValueColumn || valueID == CSSValueColumnReverse)
662                 return true;
663         break;
664     case CSSPropertyWebkitFlexItemAlign:
665         if (valueID == CSSValueAuto || valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline || valueID == CSSValueStretch)
666             return true;
667         break;
668     case CSSPropertyWebkitFlexLinePack:
669          if (valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueCenter || valueID == CSSValueJustify || valueID == CSSValueDistribute || valueID == CSSValueStretch)
670              return true;
671          break;
672     case CSSPropertyWebkitFlexPack:
673         if (valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueCenter || valueID == CSSValueJustify || valueID == CSSValueDistribute)
674             return true;
675         break;
676     case CSSPropertyWebkitFlexWrap:
677         if (valueID == CSSValueNone || valueID == CSSValueWrap || valueID == CSSValueWrapReverse)
678              return true;
679         break;
680     case CSSPropertyWebkitFontKerning:
681         if (valueID == CSSValueAuto || valueID == CSSValueNormal || valueID == CSSValueNone)
682             return true;
683         break;
684     case CSSPropertyWebkitFontSmoothing:
685         if (valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueAntialiased || valueID == CSSValueSubpixelAntialiased)
686             return true;
687         break;
688     case CSSPropertyWebkitHyphens:
689         if (valueID == CSSValueNone || valueID == CSSValueManual || valueID == CSSValueAuto)
690             return true;
691         break;
692     case CSSPropertyWebkitLineAlign:
693         if (valueID == CSSValueNone || valueID == CSSValueEdges)
694             return true;
695         break;
696     case CSSPropertyWebkitLineBreak: // normal | after-white-space
697         if (valueID == CSSValueNormal || valueID == CSSValueAfterWhiteSpace)
698             return true;
699         break;
700     case CSSPropertyWebkitLineSnap:
701         if (valueID == CSSValueNone || valueID == CSSValueBaseline || valueID == CSSValueContain)
702             return true;
703         break;
704     case CSSPropertyWebkitMarginAfterCollapse:
705     case CSSPropertyWebkitMarginBeforeCollapse:
706     case CSSPropertyWebkitMarginBottomCollapse:
707     case CSSPropertyWebkitMarginTopCollapse:
708         if (valueID == CSSValueCollapse || valueID == CSSValueSeparate || valueID == CSSValueDiscard)
709             return true;
710         break;
711     case CSSPropertyWebkitMarqueeDirection:
712         if (valueID == CSSValueForwards || valueID == CSSValueBackwards || valueID == CSSValueAhead || valueID == CSSValueReverse || valueID == CSSValueLeft || valueID == CSSValueRight || valueID == CSSValueDown
713             || valueID == CSSValueUp || valueID == CSSValueAuto)
714             return true;
715         break;
716     case CSSPropertyWebkitMarqueeStyle:
717         if (valueID == CSSValueNone || valueID == CSSValueSlide || valueID == CSSValueScroll || valueID == CSSValueAlternate)
718             return true;
719         break;
720     case CSSPropertyWebkitMatchNearestMailBlockquoteColor: // normal | match
721         if (valueID == CSSValueNormal || valueID == CSSValueMatch)
722             return true;
723         break;
724     case CSSPropertyWebkitNbspMode: // normal | space
725         if (valueID == CSSValueNormal || valueID == CSSValueSpace)
726             return true;
727         break;
728 #if ENABLE(OVERFLOW_SCROLLING)
729     case CSSPropertyWebkitOverflowScrolling:
730         if (valueID == CSSValueAuto || valueID == CSSValueTouch)
731             return true;
732         break;
733 #endif
734     case CSSPropertyWebkitPrintColorAdjust:
735         if (valueID == CSSValueExact || valueID == CSSValueEconomy)
736             return true;
737         break;
738     case CSSPropertyWebkitRtlOrdering:
739         if (valueID == CSSValueLogical || valueID == CSSValueVisual)
740             return true;
741         break;
742     case CSSPropertyWebkitTextCombine:
743         if (valueID == CSSValueNone || valueID == CSSValueHorizontal)
744             return true;
745         break;
746     case CSSPropertyWebkitTextEmphasisPosition:
747         if (valueID == CSSValueOver || valueID == CSSValueUnder)
748             return true;
749         break;
750     case CSSPropertyWebkitTextSecurity:
751         // disc | circle | square | none | inherit
752         if (valueID == CSSValueDisc || valueID == CSSValueCircle || valueID == CSSValueSquare || valueID == CSSValueNone)
753             return true;
754         break;
755     case CSSPropertyWebkitTextSizeAdjust:
756         if (valueID == CSSValueAuto || valueID == CSSValueNone)
757             return true;
758         break;
759     case CSSPropertyWebkitTransformStyle:
760         if (valueID == CSSValueFlat || valueID == CSSValuePreserve3d)
761             return true;
762         break;
763     case CSSPropertyWebkitUserDrag: // auto | none | element
764         if (valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueElement)
765             return true;
766         break;
767     case CSSPropertyWebkitUserModify: // read-only | read-write
768         if (valueID == CSSValueReadOnly || valueID == CSSValueReadWrite || valueID == CSSValueReadWritePlaintextOnly)
769             return true;
770         break;
771     case CSSPropertyWebkitUserSelect: // auto | none | text
772         if (valueID == CSSValueAuto || valueID == CSSValueNone || valueID == CSSValueText)
773             return true;
774         break;
775     case CSSPropertyWebkitWrapFlow:
776         if (valueID == CSSValueAuto || valueID == CSSValueBoth || valueID == CSSValueStart || valueID == CSSValueEnd || valueID == CSSValueMaximum || valueID == CSSValueClear)
777             return true;
778         break;
779     case CSSPropertyWebkitWrapThrough:
780         if (valueID == CSSValueWrap || valueID == CSSValueNone)
781             return true;
782         break;
783     case CSSPropertyWebkitWritingMode:
784         if (valueID >= CSSValueHorizontalTb && valueID <= CSSValueHorizontalBt)
785             return true;
786         break;
787     case CSSPropertyWhiteSpace: // normal | pre | nowrap | inherit
788         if (valueID == CSSValueNormal || valueID == CSSValuePre || valueID == CSSValuePreWrap || valueID == CSSValuePreLine || valueID == CSSValueNowrap)
789             return true;
790         break;
791     case CSSPropertyWordBreak: // normal | break-all | break-word (this is a custom extension)
792         if (valueID == CSSValueNormal || valueID == CSSValueBreakAll || valueID == CSSValueBreakWord)
793             return true;
794         break;
795     case CSSPropertyWordWrap: // normal | break-word
796         if (valueID == CSSValueNormal || valueID == CSSValueBreakWord)
797             return true;
798         break;
799     default:
800         ASSERT_NOT_REACHED();
801         return false;
802     }
803     return false;
804 }
805
806 static inline bool isKeywordPropertyID(CSSPropertyID propertyId)
807 {
808     switch (propertyId) {
809     case CSSPropertyBorderBottomStyle:
810     case CSSPropertyBorderCollapse:
811     case CSSPropertyBorderLeftStyle:
812     case CSSPropertyBorderRightStyle:
813     case CSSPropertyBorderTopStyle:
814     case CSSPropertyBoxSizing:
815     case CSSPropertyCaptionSide:
816     case CSSPropertyClear:
817     case CSSPropertyDirection:
818     case CSSPropertyDisplay:
819     case CSSPropertyEmptyCells:
820     case CSSPropertyFloat:
821     case CSSPropertyFontStyle:
822     case CSSPropertyImageRendering:
823     case CSSPropertyListStylePosition:
824     case CSSPropertyListStyleType:
825     case CSSPropertyOutlineStyle:
826     case CSSPropertyOverflowX:
827     case CSSPropertyOverflowY:
828     case CSSPropertyPointerEvents:
829     case CSSPropertyPosition:
830     case CSSPropertyResize:
831     case CSSPropertySpeak:
832     case CSSPropertyTableLayout:
833     case CSSPropertyTextLineThroughMode:
834     case CSSPropertyTextLineThroughStyle:
835     case CSSPropertyTextOverflow:
836     case CSSPropertyTextOverlineMode:
837     case CSSPropertyTextOverlineStyle:
838     case CSSPropertyTextRendering:
839     case CSSPropertyTextTransform:
840     case CSSPropertyTextUnderlineMode:
841     case CSSPropertyTextUnderlineStyle:
842     case CSSPropertyVisibility:
843     case CSSPropertyWebkitAppearance:
844     case CSSPropertyWebkitBackfaceVisibility:
845     case CSSPropertyWebkitBorderAfterStyle:
846     case CSSPropertyWebkitBorderBeforeStyle:
847     case CSSPropertyWebkitBorderEndStyle:
848     case CSSPropertyWebkitBorderFit:
849     case CSSPropertyWebkitBorderStartStyle:
850     case CSSPropertyWebkitBoxAlign:
851     case CSSPropertyWebkitBoxDirection:
852     case CSSPropertyWebkitBoxLines:
853     case CSSPropertyWebkitBoxOrient:
854     case CSSPropertyWebkitBoxPack:
855     case CSSPropertyWebkitColorCorrection:
856     case CSSPropertyWebkitColumnRuleStyle:
857     case CSSPropertyWebkitFlexAlign:
858     case CSSPropertyWebkitFlexDirection:
859     case CSSPropertyWebkitFlexItemAlign:
860     case CSSPropertyWebkitFlexLinePack:
861     case CSSPropertyWebkitFlexPack:
862     case CSSPropertyWebkitFlexWrap:
863     case CSSPropertyWebkitFontKerning:
864     case CSSPropertyWebkitFontSmoothing:
865     case CSSPropertyWebkitHyphens:
866     case CSSPropertyWebkitLineAlign:
867     case CSSPropertyWebkitLineBreak:
868     case CSSPropertyWebkitLineSnap:
869     case CSSPropertyWebkitMarginAfterCollapse:
870     case CSSPropertyWebkitMarginBeforeCollapse:
871     case CSSPropertyWebkitMarginBottomCollapse:
872     case CSSPropertyWebkitMarginTopCollapse:
873     case CSSPropertyWebkitMarqueeDirection:
874     case CSSPropertyWebkitMarqueeStyle:
875     case CSSPropertyWebkitMatchNearestMailBlockquoteColor:
876     case CSSPropertyWebkitNbspMode:
877 #if ENABLE(OVERFLOW_SCROLLING)
878     case CSSPropertyWebkitOverflowScrolling:
879 #endif
880     case CSSPropertyWebkitPrintColorAdjust:
881     case CSSPropertyWebkitRtlOrdering:
882     case CSSPropertyWebkitTextCombine:
883     case CSSPropertyWebkitTextEmphasisPosition:
884     case CSSPropertyWebkitTextSecurity:
885     case CSSPropertyWebkitTextSizeAdjust:
886     case CSSPropertyWebkitTransformStyle:
887     case CSSPropertyWebkitUserDrag:
888     case CSSPropertyWebkitUserModify:
889     case CSSPropertyWebkitUserSelect:
890     case CSSPropertyWebkitWrapFlow:
891     case CSSPropertyWebkitWrapThrough:
892     case CSSPropertyWebkitWritingMode:
893     case CSSPropertyWhiteSpace:
894     case CSSPropertyWordBreak:
895     case CSSPropertyWordWrap:
896         return true;
897     default:
898         return false;
899     }
900 }
901
902 static bool parseKeywordValue(StylePropertySet* declaration, CSSPropertyID propertyId, const String& string, bool important, CSSStyleSheet* contextStyleSheet)
903 {
904     if (string.isEmpty())
905         return false;
906
907     if (!isKeywordPropertyID(propertyId))
908         return false;
909
910     CSSParserString cssString;
911     cssString.characters = const_cast<UChar*>(string.characters());
912     cssString.length = string.length();
913     int valueID = cssValueKeywordID(cssString);
914
915     if (!valueID)
916         return false;
917
918     Document* document = contextStyleSheet->findDocument();
919     RefPtr<CSSValue> value;
920     CSSValuePool* cssValuePool = document ? document->cssValuePool().get() : 0;
921     if (valueID == CSSValueInherit)
922         value = cssValuePool ? cssValuePool->createInheritedValue() : CSSInheritedValue::create();
923     else if (valueID == CSSValueInitial)
924         value = cssValuePool ? cssValuePool->createExplicitInitialValue() : CSSInitialValue::createExplicit();
925     else if (isValidKeywordPropertyAndValue(propertyId, valueID))
926         value = cssValuePool ? cssValuePool->createIdentifierValue(valueID) : CSSPrimitiveValue::createIdentifier(valueID);
927     else
928         return false;
929
930     declaration->addParsedProperty(CSSProperty(propertyId, value.release(), important));
931     return true;
932 }
933
934 PassRefPtr<CSSValueList> CSSParser::parseFontFaceValue(const AtomicString& string, CSSStyleSheet* contextStyleSheet)
935 {
936     RefPtr<StylePropertySet> dummyStyle = StylePropertySet::create();
937     if (!parseValue(dummyStyle.get(), CSSPropertyFontFamily, string, false, CSSQuirksMode, contextStyleSheet))
938         return 0;
939     return static_pointer_cast<CSSValueList>(dummyStyle->getPropertyCSSValue(CSSPropertyFontFamily));
940 }
941
942 bool CSSParser::parseValue(StylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important, CSSParserMode cssParserMode, CSSStyleSheet* contextStyleSheet)
943 {
944     if (parseSimpleLengthValue(declaration, propertyID, string, important, cssParserMode, contextStyleSheet))
945         return true;
946     if (parseColorValue(declaration, propertyID, string, important, cssParserMode, contextStyleSheet))
947         return true;
948     if (parseKeywordValue(declaration, propertyID, string, important, contextStyleSheet))
949         return true;
950     CSSParser parser(cssParserMode);
951     return parser.parseValue(declaration, propertyID, string, important, contextStyleSheet);
952 }
953
954 bool CSSParser::parseValue(StylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important, CSSStyleSheet* contextStyleSheet)
955 {
956     setStyleSheet(contextStyleSheet);
957
958     setupParser("@-webkit-value{", string, "} ");
959
960     m_id = propertyID;
961     m_important = important;
962
963     cssyyparse(this);
964
965     m_rule = 0;
966
967     bool ok = false;
968     if (m_hasFontFaceOnlyValues)
969         deleteFontFaceOnlyValues();
970     if (!m_parsedProperties.isEmpty()) {
971         ok = true;
972         declaration->addParsedProperties(m_parsedProperties.data(), m_parsedProperties.size());
973         clearProperties();
974     }
975
976     return ok;
977 }
978
979 // The color will only be changed when string contains a valid CSS color, so callers
980 // can set it to a default color and ignore the boolean result.
981 bool CSSParser::parseColor(RGBA32& color, const String& string, bool strict)
982 {
983     // First try creating a color specified by name, rgba(), rgb() or "#" syntax.
984     if (fastParseColor(color, string, strict))
985         return true;
986
987     CSSParser parser(CSSStrictMode);
988
989     // In case the fast-path parser didn't understand the color, try the full parser.
990     if (!parser.parseColor(string))
991         return false;
992
993     CSSValue* value = parser.m_parsedProperties.first().value();
994     if (!value->isPrimitiveValue())
995         return false;
996
997     CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
998     if (!primitiveValue->isRGBColor())
999         return false;
1000
1001     color = primitiveValue->getRGBA32Value();
1002     return true;
1003 }
1004
1005 bool CSSParser::parseColor(const String& string)
1006 {
1007     // This function may be called without a stylesheet set on the parser, so we need to
1008     // make sure that we have a CSSValuePool or we'll crash below cssyyparse().
1009     ensureCSSValuePool();
1010
1011     setupParser("@-webkit-decls{color:", string, "} ");
1012     cssyyparse(this);
1013     m_rule = 0;
1014
1015     return !m_parsedProperties.isEmpty() && m_parsedProperties.first().id() == CSSPropertyColor;
1016 }
1017
1018 bool CSSParser::parseSystemColor(RGBA32& color, const String& string, Document* document)
1019 {
1020     if (!document || !document->page())
1021         return false;
1022
1023     CSSParserString cssColor;
1024     cssColor.characters = const_cast<UChar*>(string.characters());
1025     cssColor.length = string.length();
1026     int id = cssValueKeywordID(cssColor);
1027     if (id <= 0)
1028         return false;
1029
1030     color = document->page()->theme()->systemColor(id).rgb();
1031     return true;
1032 }
1033
1034 void CSSParser::parseSelector(const String& string, Document* doc, CSSSelectorList& selectorList)
1035 {
1036     RefPtr<CSSStyleSheet> dummyStyleSheet = CSSStyleSheet::create(doc);
1037
1038     setStyleSheet(dummyStyleSheet.get());
1039     m_selectorListForParseSelector = &selectorList;
1040
1041     setupParser("@-webkit-selector{", string, "}");
1042
1043     cssyyparse(this);
1044
1045     m_selectorListForParseSelector = 0;
1046
1047     // The style sheet will be deleted right away, so it won't outlive the document.
1048     ASSERT(dummyStyleSheet->hasOneRef());
1049 }
1050
1051 bool CSSParser::parseDeclaration(StylePropertySet* declaration, const String& string, RefPtr<CSSStyleSourceData>* styleSourceData, CSSStyleSheet* contextStyleSheet)
1052 {
1053     // Length of the "@-webkit-decls{" prefix.
1054     static const unsigned prefixLength = 15;
1055
1056     setStyleSheet(contextStyleSheet);
1057
1058     if (styleSourceData) {
1059         m_currentRuleData = CSSRuleSourceData::create();
1060         m_currentRuleData->styleSourceData = CSSStyleSourceData::create();
1061         m_inStyleRuleOrDeclaration = true;
1062     }
1063
1064     setupParser("@-webkit-decls{", string, "} ");
1065     cssyyparse(this);
1066     m_rule = 0;
1067
1068     bool ok = false;
1069     if (m_hasFontFaceOnlyValues)
1070         deleteFontFaceOnlyValues();
1071     if (!m_parsedProperties.isEmpty()) {
1072         ok = true;
1073         declaration->addParsedProperties(m_parsedProperties.data(), m_parsedProperties.size());
1074         clearProperties();
1075     }
1076
1077     if (m_currentRuleData) {
1078         m_currentRuleData->styleSourceData->styleBodyRange.start = 0;
1079         m_currentRuleData->styleSourceData->styleBodyRange.end = string.length();
1080         for (Vector<CSSPropertySourceData>::iterator it = m_currentRuleData->styleSourceData->propertyData.begin(), endIt = m_currentRuleData->styleSourceData->propertyData.end(); it != endIt; ++it) {
1081             (*it).range.start -= prefixLength;
1082             (*it).range.end -= prefixLength;
1083         }
1084     }
1085
1086     if (styleSourceData) {
1087         *styleSourceData = m_currentRuleData->styleSourceData.release();
1088         m_currentRuleData = 0;
1089         m_inStyleRuleOrDeclaration = false;
1090     }
1091     return ok;
1092 }
1093
1094 PassOwnPtr<MediaQuery> CSSParser::parseMediaQuery(const String& string)
1095 {
1096     if (string.isEmpty())
1097         return nullptr;
1098
1099     ASSERT(!m_mediaQuery);
1100
1101     // can't use { because tokenizer state switches from mediaquery to initial state when it sees { token.
1102     // instead insert one " " (which is WHITESPACE in CSSGrammar.y)
1103     setupParser("@-webkit-mediaquery ", string, "} ");
1104     cssyyparse(this);
1105
1106     return m_mediaQuery.release();
1107 }
1108
1109 void CSSParser::addProperty(CSSPropertyID propId, PassRefPtr<CSSValue> value, bool important, bool implicit)
1110 {
1111     m_parsedProperties.append(CSSProperty(propId, value, important, m_currentShorthand, m_implicitShorthand || implicit));
1112 }
1113
1114 void CSSParser::rollbackLastProperties(int num)
1115 {
1116     ASSERT(num >= 0);
1117     ASSERT(m_parsedProperties.size() >= static_cast<unsigned>(num));
1118     m_parsedProperties.shrink(m_parsedProperties.size() - num);
1119 }
1120
1121 void CSSParser::clearProperties()
1122 {
1123     m_parsedProperties.clear();
1124     m_numParsedPropertiesBeforeMarginBox = INVALID_NUM_PARSED_PROPERTIES;
1125     m_hasFontFaceOnlyValues = false;
1126 }
1127
1128 void CSSParser::setStyleSheet(CSSStyleSheet* styleSheet)
1129 {
1130     m_styleSheet = styleSheet;
1131     Document* document = findDocument();
1132     m_cssValuePool = document ? document->cssValuePool() : CSSValuePool::create();
1133 }
1134
1135 Document* CSSParser::findDocument() const
1136 {
1137     if (!m_styleSheet)
1138         return 0;
1139     return m_styleSheet->findDocument();
1140 }
1141
1142 bool CSSParser::validCalculationUnit(CSSParserValue* value, Units unitflags)
1143 {
1144     bool mustBeNonNegative = unitflags & FNonNeg;
1145
1146     if (!parseCalculation(value, mustBeNonNegative ? CalculationRangeNonNegative : CalculationRangeAll))
1147         return false;
1148
1149     bool b = false;
1150     switch (m_parsedCalculation->category()) {
1151     case CalcLength:
1152         b = (unitflags & FLength);
1153         break;
1154     case CalcPercent:
1155         b = (unitflags & FPercent);
1156         if (b && mustBeNonNegative && m_parsedCalculation->isNegative())
1157             b = false;
1158         break;
1159     case CalcNumber:
1160         b = (unitflags & FNumber);
1161         if (!b && (unitflags & FInteger) && m_parsedCalculation->isInt())
1162             b = true;
1163         if (b && mustBeNonNegative && m_parsedCalculation->isNegative())
1164             b = false;
1165         break;
1166     case CalcPercentLength:
1167         b = (unitflags & FPercent) && (unitflags & FLength);
1168         break;
1169     case CalcPercentNumber:
1170         b = (unitflags & FPercent) && (unitflags & FNumber);
1171         break;
1172     case CalcOther:
1173         break;
1174     }
1175     if (!b)
1176         m_parsedCalculation.release();
1177     return b;    
1178 }
1179
1180 inline bool CSSParser::shouldAcceptUnitLessValues(CSSParserValue* value, Units unitflags, CSSParserMode cssParserMode)
1181 {
1182     // Qirks mode and svg presentation attributes accept unit less values.
1183     return (unitflags & (FLength | FAngle | FTime)) && (!value->fValue || cssParserMode == CSSQuirksMode || cssParserMode == SVGAttributeMode);
1184 }
1185
1186 bool CSSParser::validUnit(CSSParserValue* value, Units unitflags, CSSParserMode cssParserMode)
1187 {
1188     if (isCalculation(value))
1189         return validCalculationUnit(value, unitflags);
1190         
1191     bool b = false;
1192     switch (value->unit) {
1193     case CSSPrimitiveValue::CSS_NUMBER:
1194         b = (unitflags & FNumber);
1195         if (!b && shouldAcceptUnitLessValues(value, unitflags, cssParserMode)) {
1196             value->unit = (unitflags & FLength) ? CSSPrimitiveValue::CSS_PX :
1197                           ((unitflags & FAngle) ? CSSPrimitiveValue::CSS_DEG : CSSPrimitiveValue::CSS_MS);
1198             b = true;
1199         }
1200         if (!b && (unitflags & FInteger) && value->isInt)
1201             b = true;
1202         break;
1203     case CSSPrimitiveValue::CSS_PERCENTAGE:
1204         b = (unitflags & FPercent);
1205         break;
1206     case CSSParserValue::Q_EMS:
1207     case CSSPrimitiveValue::CSS_EMS:
1208     case CSSPrimitiveValue::CSS_REMS:
1209     case CSSPrimitiveValue::CSS_EXS:
1210     case CSSPrimitiveValue::CSS_PX:
1211     case CSSPrimitiveValue::CSS_CM:
1212     case CSSPrimitiveValue::CSS_MM:
1213     case CSSPrimitiveValue::CSS_IN:
1214     case CSSPrimitiveValue::CSS_PT:
1215     case CSSPrimitiveValue::CSS_PC:
1216     case CSSPrimitiveValue::CSS_VW:
1217     case CSSPrimitiveValue::CSS_VH:
1218     case CSSPrimitiveValue::CSS_VMIN:
1219         b = (unitflags & FLength);
1220         break;
1221     case CSSPrimitiveValue::CSS_MS:
1222     case CSSPrimitiveValue::CSS_S:
1223         b = (unitflags & FTime);
1224         break;
1225     case CSSPrimitiveValue::CSS_DEG:
1226     case CSSPrimitiveValue::CSS_RAD:
1227     case CSSPrimitiveValue::CSS_GRAD:
1228     case CSSPrimitiveValue::CSS_TURN:
1229         b = (unitflags & FAngle);
1230         break;
1231     case CSSPrimitiveValue::CSS_HZ:
1232     case CSSPrimitiveValue::CSS_KHZ:
1233     case CSSPrimitiveValue::CSS_DIMENSION:
1234     default:
1235         break;
1236     }
1237     if (b && unitflags & FNonNeg && value->fValue < 0)
1238         b = false;
1239     return b;
1240 }
1241
1242 inline PassRefPtr<CSSPrimitiveValue> CSSParser::createPrimitiveNumericValue(CSSParserValue* value)
1243 {
1244     if (m_parsedCalculation) {
1245         ASSERT(isCalculation(value));
1246         return CSSPrimitiveValue::create(m_parsedCalculation.release());
1247     }
1248                
1249     ASSERT((value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ)
1250            || (value->unit >= CSSPrimitiveValue::CSS_TURN && value->unit <= CSSPrimitiveValue::CSS_REMS)
1251            || (value->unit >= CSSPrimitiveValue::CSS_VW && value->unit <= CSSPrimitiveValue::CSS_VMIN));
1252     return cssValuePool()->createValue(value->fValue, static_cast<CSSPrimitiveValue::UnitTypes>(value->unit));
1253 }
1254
1255 inline PassRefPtr<CSSPrimitiveValue> CSSParser::createPrimitiveStringValue(CSSParserValue* value)
1256 {
1257     ASSERT(value->unit == CSSPrimitiveValue::CSS_STRING || value->unit == CSSPrimitiveValue::CSS_IDENT);
1258     return cssValuePool()->createValue(value->string, CSSPrimitiveValue::CSS_STRING);
1259 }
1260
1261 static int unitFromString(CSSParserValue* value)
1262 {
1263     if (value->unit != CSSPrimitiveValue::CSS_IDENT || value->id)
1264         return 0;
1265
1266     if (equal(value->string, "em"))
1267         return CSSPrimitiveValue::CSS_EMS;
1268     if (equal(value->string, "rem"))
1269         return CSSPrimitiveValue::CSS_REMS;
1270     if (equal(value->string, "ex"))
1271         return CSSPrimitiveValue::CSS_EXS;
1272     if (equal(value->string, "px"))
1273         return CSSPrimitiveValue::CSS_PX;
1274     if (equal(value->string, "cm"))
1275         return CSSPrimitiveValue::CSS_CM;
1276     if (equal(value->string, "mm"))
1277         return CSSPrimitiveValue::CSS_MM;
1278     if (equal(value->string, "in"))
1279         return CSSPrimitiveValue::CSS_IN;
1280     if (equal(value->string, "pt"))
1281         return CSSPrimitiveValue::CSS_PT;
1282     if (equal(value->string, "pc"))
1283         return CSSPrimitiveValue::CSS_PC;
1284     if (equal(value->string, "deg"))
1285         return CSSPrimitiveValue::CSS_DEG;
1286     if (equal(value->string, "rad"))
1287         return CSSPrimitiveValue::CSS_RAD;
1288     if (equal(value->string, "grad"))
1289         return CSSPrimitiveValue::CSS_GRAD;
1290     if (equal(value->string, "turn"))
1291         return CSSPrimitiveValue::CSS_TURN;
1292     if (equal(value->string, "ms"))
1293         return CSSPrimitiveValue::CSS_MS;
1294     if (equal(value->string, "s"))
1295         return CSSPrimitiveValue::CSS_S;
1296     if (equal(value->string, "Hz"))
1297         return CSSPrimitiveValue::CSS_HZ;
1298     if (equal(value->string, "kHz"))
1299         return CSSPrimitiveValue::CSS_KHZ;
1300     if (equal(value->string, "vw"))
1301         return CSSPrimitiveValue::CSS_VW;
1302     if (equal(value->string, "vh"))
1303         return CSSPrimitiveValue::CSS_VH;
1304     if (equal(value->string, "vmin"))
1305         return CSSPrimitiveValue::CSS_VMIN;
1306
1307     return 0;
1308 }
1309
1310 void CSSParser::checkForOrphanedUnits()
1311 {
1312     if (inStrictMode() || inShorthand())
1313         return;
1314
1315     // The purpose of this code is to implement the WinIE quirk that allows unit types to be separated from their numeric values
1316     // by whitespace, so e.g., width: 20 px instead of width:20px.  This is invalid CSS, so we don't do this in strict mode.
1317     CSSParserValue* numericVal = 0;
1318     unsigned size = m_valueList->size();
1319     for (unsigned i = 0; i < size; i++) {
1320         CSSParserValue* value = m_valueList->valueAt(i);
1321
1322         if (numericVal) {
1323             // Change the unit type of the numeric val to match.
1324             int unit = unitFromString(value);
1325             if (unit) {
1326                 numericVal->unit = unit;
1327                 numericVal = 0;
1328
1329                 // Now delete the bogus unit value.
1330                 m_valueList->deleteValueAt(i);
1331                 i--; // We're safe even though |i| is unsigned, since we only hit this code if we had a previous numeric value (so |i| is always > 0 here).
1332                 size--;
1333                 continue;
1334             }
1335         }
1336
1337         numericVal = (value->unit == CSSPrimitiveValue::CSS_NUMBER) ? value : 0;
1338     }
1339 }
1340
1341 inline PassRefPtr<CSSPrimitiveValue> CSSParser::parseValidPrimitive(int identifier, CSSParserValue* value)
1342 {
1343     if (identifier)
1344         return cssValuePool()->createIdentifierValue(identifier);
1345     if (value->unit == CSSPrimitiveValue::CSS_STRING)
1346         return createPrimitiveStringValue(value);
1347     if (value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ)
1348         return createPrimitiveNumericValue(value);
1349     if (value->unit >= CSSPrimitiveValue::CSS_TURN && value->unit <= CSSPrimitiveValue::CSS_REMS)
1350         return createPrimitiveNumericValue(value);
1351     if (value->unit >= CSSPrimitiveValue::CSS_VW && value->unit <= CSSPrimitiveValue::CSS_VMIN)
1352         return createPrimitiveNumericValue(value);
1353     if (value->unit >= CSSParserValue::Q_EMS)
1354         return CSSPrimitiveValue::createAllowingMarginQuirk(value->fValue, CSSPrimitiveValue::CSS_EMS);
1355     if (isCalculation(value))
1356         return CSSPrimitiveValue::create(m_parsedCalculation.release());
1357
1358     return 0;
1359 }
1360
1361 bool CSSParser::parseValue(CSSPropertyID propId, bool important)
1362 {
1363     if (!m_valueList)
1364         return false;
1365
1366     CSSParserValue* value = m_valueList->current();
1367
1368     if (!value)
1369         return false;
1370
1371     // Note: m_parsedCalculation is used to pass the calc value to validUnit and then cleared at the end of this function.
1372     // FIXME: This is to avoid having to pass parsedCalc to all validUnit callers.
1373     ASSERT(!m_parsedCalculation);
1374     
1375     int id = value->id;
1376
1377     // In quirks mode, we will look for units that have been incorrectly separated from the number they belong to
1378     // by a space.  We go ahead and associate the unit with the number even though it is invalid CSS.
1379     checkForOrphanedUnits();
1380
1381     int num = inShorthand() ? 1 : m_valueList->size();
1382
1383     if (id == CSSValueInherit) {
1384         if (num != 1)
1385             return false;
1386         addProperty(propId, cssValuePool()->createInheritedValue(), important);
1387         return true;
1388     }
1389     else if (id == CSSValueInitial) {
1390         if (num != 1)
1391             return false;
1392         addProperty(propId, cssValuePool()->createExplicitInitialValue(), important);
1393         return true;
1394     }
1395
1396     if (isKeywordPropertyID(propId)) {
1397         if (!isValidKeywordPropertyAndValue(propId, id))
1398             return false;
1399         if (m_valueList->next() && !inShorthand())
1400             return false;
1401         addProperty(propId, cssValuePool()->createIdentifierValue(id), important);
1402         return true;
1403     }
1404
1405     bool validPrimitive = false;
1406     RefPtr<CSSValue> parsedValue;
1407
1408     switch (propId) {
1409         /* The comment to the left defines all valid value of this properties as defined
1410          * in CSS 2, Appendix F. Property index
1411          */
1412
1413         /* All the CSS properties are not supported by the renderer at the moment.
1414          * Note that all the CSS2 Aural properties are only checked, if CSS_AURAL is defined
1415          * (see parseAuralValues). As we don't support them at all this seems reasonable.
1416          */
1417
1418     case CSSPropertySize:                 // <length>{1,2} | auto | [ <page-size> || [ portrait | landscape] ]
1419         return parseSize(propId, important);
1420
1421     case CSSPropertyQuotes:               // [<string> <string>]+ | none | inherit
1422         if (id)
1423             validPrimitive = true;
1424         else
1425             return parseQuotes(propId, important);
1426         break;
1427     case CSSPropertyUnicodeBidi: // normal | embed | (bidi-override || isolate) | plaintext | inherit
1428         if (id == CSSValueNormal
1429             || id == CSSValueEmbed
1430             || id == CSSValueWebkitPlaintext)
1431             validPrimitive = true;
1432         else {
1433             RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
1434             bool isValid = true;
1435             while (isValid && value) {
1436                 switch (value->id) {
1437                 case CSSValueBidiOverride:
1438                 case CSSValueWebkitIsolate:
1439                     list->append(cssValuePool()->createIdentifierValue(value->id));
1440                     break;
1441                 default:
1442                     isValid = false;
1443                 }
1444                 value = m_valueList->next();
1445             }
1446             if (list->length() && isValid) {
1447                 parsedValue = list.release();
1448                 m_valueList->next();
1449             }
1450         }
1451         break;
1452
1453     case CSSPropertyPageBreakAfter:       // auto | always | avoid | left | right | inherit
1454     case CSSPropertyPageBreakBefore:
1455     case CSSPropertyWebkitColumnBreakAfter:
1456     case CSSPropertyWebkitColumnBreakBefore:
1457     case CSSPropertyWebkitRegionBreakAfter:
1458     case CSSPropertyWebkitRegionBreakBefore:
1459         if (id == CSSValueAuto
1460             || id == CSSValueAlways
1461             || id == CSSValueAvoid
1462             || id == CSSValueLeft
1463             || id == CSSValueRight)
1464             validPrimitive = ((propId == CSSPropertyWebkitRegionBreakAfter) || (propId == CSSPropertyWebkitRegionBreakBefore)) ? cssRegionsEnabled() : true;
1465         break;
1466
1467     case CSSPropertyPageBreakInside:     // avoid | auto | inherit
1468     case CSSPropertyWebkitColumnBreakInside:
1469     case CSSPropertyWebkitRegionBreakInside:
1470         if (id == CSSValueAuto || id == CSSValueAvoid)
1471             validPrimitive = (propId == CSSPropertyWebkitRegionBreakInside) ? cssRegionsEnabled() : true;
1472         break;
1473
1474     case CSSPropertyContent:              // [ <string> | <uri> | <counter> | attr(X) | open-quote |
1475         // close-quote | no-open-quote | no-close-quote ]+ | inherit
1476         return parseContent(propId, important);
1477
1478     case CSSPropertyClip:                 // <shape> | auto | inherit
1479         if (id == CSSValueAuto)
1480             validPrimitive = true;
1481         else if (value->unit == CSSParserValue::Function)
1482             return parseClipShape(propId, important);
1483         break;
1484
1485     /* Start of supported CSS properties with validation. This is needed for parseShorthand to work
1486      * correctly and allows optimization in WebCore::applyRule(..)
1487      */
1488     case CSSPropertyOverflow: {
1489         ShorthandScope scope(this, propId);
1490         if (num != 1 || !parseValue(CSSPropertyOverflowX, important))
1491             return false;
1492         CSSValue* value = m_parsedProperties.last().value();
1493         addProperty(CSSPropertyOverflowY, value, important);
1494         return true;
1495     }
1496
1497     case CSSPropertyTextAlign:
1498         // left | right | center | justify | webkit_left | webkit_right | webkit_center | webkit_match_parent |
1499         // start | end | <string> | inherit
1500         if ((id >= CSSValueWebkitAuto && id <= CSSValueWebkitMatchParent) || id == CSSValueStart || id == CSSValueEnd
1501             || value->unit == CSSPrimitiveValue::CSS_STRING)
1502             validPrimitive = true;
1503         break;
1504
1505     case CSSPropertyFontWeight:  // normal | bold | bolder | lighter | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | inherit
1506         return parseFontWeight(important);
1507
1508     case CSSPropertyBorderSpacing: {
1509         if (num == 1) {
1510             ShorthandScope scope(this, CSSPropertyBorderSpacing);
1511             if (!parseValue(CSSPropertyWebkitBorderHorizontalSpacing, important))
1512                 return false;
1513             CSSValue* value = m_parsedProperties.last().value();
1514             addProperty(CSSPropertyWebkitBorderVerticalSpacing, value, important);
1515             return true;
1516         }
1517         else if (num == 2) {
1518             ShorthandScope scope(this, CSSPropertyBorderSpacing);
1519             if (!parseValue(CSSPropertyWebkitBorderHorizontalSpacing, important) || !parseValue(CSSPropertyWebkitBorderVerticalSpacing, important))
1520                 return false;
1521             return true;
1522         }
1523         return false;
1524     }
1525     case CSSPropertyWebkitBorderHorizontalSpacing:
1526     case CSSPropertyWebkitBorderVerticalSpacing:
1527         validPrimitive = validUnit(value, FLength | FNonNeg);
1528         break;
1529     case CSSPropertyOutlineColor:        // <color> | invert | inherit
1530         // Outline color has "invert" as additional keyword.
1531         // Also, we want to allow the special focus color even in strict parsing mode.
1532         if (id == CSSValueInvert || id == CSSValueWebkitFocusRingColor) {
1533             validPrimitive = true;
1534             break;
1535         }
1536         /* nobreak */
1537     case CSSPropertyBackgroundColor: // <color> | inherit
1538     case CSSPropertyBorderTopColor: // <color> | inherit
1539     case CSSPropertyBorderRightColor:
1540     case CSSPropertyBorderBottomColor:
1541     case CSSPropertyBorderLeftColor:
1542     case CSSPropertyWebkitBorderStartColor:
1543     case CSSPropertyWebkitBorderEndColor:
1544     case CSSPropertyWebkitBorderBeforeColor:
1545     case CSSPropertyWebkitBorderAfterColor:
1546     case CSSPropertyColor: // <color> | inherit
1547     case CSSPropertyTextLineThroughColor: // CSS3 text decoration colors
1548     case CSSPropertyTextUnderlineColor:
1549     case CSSPropertyTextOverlineColor:
1550     case CSSPropertyWebkitColumnRuleColor:
1551     case CSSPropertyWebkitTextEmphasisColor:
1552     case CSSPropertyWebkitTextFillColor:
1553     case CSSPropertyWebkitTextStrokeColor:
1554         if (id == CSSValueWebkitText)
1555             validPrimitive = true; // Always allow this, even when strict parsing is on,
1556                                     // since we use this in our UA sheets.
1557         else if (id == CSSValueCurrentcolor)
1558             validPrimitive = true;
1559         else if ((id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu ||
1560              (id >= CSSValueWebkitFocusRingColor && id < CSSValueWebkitText && inQuirksMode())) {
1561             validPrimitive = true;
1562         } else {
1563             parsedValue = parseColor();
1564             if (parsedValue)
1565                 m_valueList->next();
1566         }
1567         break;
1568
1569     case CSSPropertyCursor: {
1570         // [<uri>,]*  [ auto | crosshair | default | pointer | progress | move | e-resize | ne-resize |
1571         // nw-resize | n-resize | se-resize | sw-resize | s-resize | w-resize | ew-resize |
1572         // ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | text | wait | help |
1573         // vertical-text | cell | context-menu | alias | copy | no-drop | not-allowed | -webkit-zoom-in
1574         // -webkit-zoom-out | all-scroll | -webkit-grab | -webkit-grabbing ] ] | inherit
1575         RefPtr<CSSValueList> list;
1576         while (value && value->unit == CSSPrimitiveValue::CSS_URI) {
1577             if (!list)
1578                 list = CSSValueList::createCommaSeparated();
1579             String uri = value->string;
1580             Vector<int> coords;
1581             value = m_valueList->next();
1582             while (value && value->unit == CSSPrimitiveValue::CSS_NUMBER) {
1583                 coords.append(int(value->fValue));
1584                 value = m_valueList->next();
1585             }
1586             IntPoint hotSpot(-1, -1);
1587             int nrcoords = coords.size();
1588             if (nrcoords > 0 && nrcoords != 2)
1589                 return false;
1590             if (nrcoords == 2)
1591                 hotSpot = IntPoint(coords[0], coords[1]);
1592
1593             if (!uri.isNull() && m_styleSheet) {
1594                 // FIXME: The completeURL call should be done when using the CSSCursorImageValue,
1595                 // not when creating it.
1596                 list->append(CSSCursorImageValue::create(m_styleSheet->completeURL(uri), hotSpot));
1597             }
1598
1599             if ((inStrictMode() && !value) || (value && !(value->unit == CSSParserValue::Operator && value->iValue == ',')))
1600                 return false;
1601             value = m_valueList->next(); // comma
1602         }
1603         if (list) {
1604             if (!value) { // no value after url list (MSIE 5 compatibility)
1605                 if (list->length() != 1)
1606                     return false;
1607             } else if (inQuirksMode() && value->id == CSSValueHand) // MSIE 5 compatibility :/
1608                 list->append(cssValuePool()->createIdentifierValue(CSSValuePointer));
1609             else if (value && ((value->id >= CSSValueAuto && value->id <= CSSValueWebkitGrabbing) || value->id == CSSValueCopy || value->id == CSSValueNone))
1610                 list->append(cssValuePool()->createIdentifierValue(value->id));
1611             m_valueList->next();
1612             parsedValue = list.release();
1613             break;
1614         }
1615         id = value->id;
1616         if (inQuirksMode() && value->id == CSSValueHand) { // MSIE 5 compatibility :/
1617             id = CSSValuePointer;
1618             validPrimitive = true;
1619         } else if ((value->id >= CSSValueAuto && value->id <= CSSValueWebkitGrabbing) || value->id == CSSValueCopy || value->id == CSSValueNone)
1620             validPrimitive = true;
1621         break;
1622     }
1623
1624     case CSSPropertyBackgroundAttachment:
1625     case CSSPropertyBackgroundClip:
1626     case CSSPropertyWebkitBackgroundClip:
1627     case CSSPropertyWebkitBackgroundComposite:
1628     case CSSPropertyBackgroundImage:
1629     case CSSPropertyBackgroundOrigin:
1630     case CSSPropertyWebkitBackgroundOrigin:
1631     case CSSPropertyBackgroundPosition:
1632     case CSSPropertyBackgroundPositionX:
1633     case CSSPropertyBackgroundPositionY:
1634     case CSSPropertyBackgroundSize:
1635     case CSSPropertyWebkitBackgroundSize:
1636     case CSSPropertyBackgroundRepeat:
1637     case CSSPropertyBackgroundRepeatX:
1638     case CSSPropertyBackgroundRepeatY:
1639     case CSSPropertyWebkitMaskAttachment:
1640     case CSSPropertyWebkitMaskClip:
1641     case CSSPropertyWebkitMaskComposite:
1642     case CSSPropertyWebkitMaskImage:
1643     case CSSPropertyWebkitMaskOrigin:
1644     case CSSPropertyWebkitMaskPosition:
1645     case CSSPropertyWebkitMaskPositionX:
1646     case CSSPropertyWebkitMaskPositionY:
1647     case CSSPropertyWebkitMaskSize:
1648     case CSSPropertyWebkitMaskRepeat:
1649     case CSSPropertyWebkitMaskRepeatX:
1650     case CSSPropertyWebkitMaskRepeatY: {
1651         RefPtr<CSSValue> val1;
1652         RefPtr<CSSValue> val2;
1653         CSSPropertyID propId1, propId2;
1654         bool result = false;
1655         if (parseFillProperty(propId, propId1, propId2, val1, val2)) {
1656             OwnPtr<ShorthandScope> shorthandScope;
1657             if (propId == CSSPropertyBackgroundPosition ||
1658                 propId == CSSPropertyBackgroundRepeat ||
1659                 propId == CSSPropertyWebkitMaskPosition ||
1660                 propId == CSSPropertyWebkitMaskRepeat) {
1661                 shorthandScope = adoptPtr(new ShorthandScope(this, propId));
1662             }
1663             addProperty(propId1, val1.release(), important);
1664             if (val2)
1665                 addProperty(propId2, val2.release(), important);
1666             result = true;
1667         }
1668         m_implicitShorthand = false;
1669         return result;
1670     }
1671     case CSSPropertyListStyleImage:     // <uri> | none | inherit
1672     case CSSPropertyBorderImageSource:
1673     case CSSPropertyWebkitMaskBoxImageSource:
1674         if (id == CSSValueNone) {
1675             parsedValue = cssValuePool()->createIdentifierValue(CSSValueNone);
1676             m_valueList->next();
1677         } else if (value->unit == CSSPrimitiveValue::CSS_URI) {
1678             if (m_styleSheet) {
1679                 // FIXME: The completeURL call should be done when using the CSSImageValue,
1680                 // not when creating it.
1681                 parsedValue = CSSImageValue::create(m_styleSheet->completeURL(value->string));
1682                 m_valueList->next();
1683             }
1684         } else if (isGeneratedImageValue(value)) {
1685             if (parseGeneratedImage(m_valueList.get(), parsedValue))
1686                 m_valueList->next();
1687             else
1688                 return false;
1689         }
1690 #if ENABLE(CSS_IMAGE_SET)
1691         else if (value->unit == CSSParserValue::Function && equalIgnoringCase(value->function->name, "-webkit-image-set(")) {
1692             parsedValue = parseImageSet(m_valueList.get());
1693             if (!parsedValue)
1694                 return false;
1695             m_valueList->next();
1696         }
1697 #endif
1698         break;
1699
1700     case CSSPropertyWebkitTextStrokeWidth:
1701     case CSSPropertyOutlineWidth:        // <border-width> | inherit
1702     case CSSPropertyBorderTopWidth:     //// <border-width> | inherit
1703     case CSSPropertyBorderRightWidth:   //   Which is defined as
1704     case CSSPropertyBorderBottomWidth:  //   thin | medium | thick | <length>
1705     case CSSPropertyBorderLeftWidth:
1706     case CSSPropertyWebkitBorderStartWidth:
1707     case CSSPropertyWebkitBorderEndWidth:
1708     case CSSPropertyWebkitBorderBeforeWidth:
1709     case CSSPropertyWebkitBorderAfterWidth:
1710     case CSSPropertyWebkitColumnRuleWidth:
1711         if (id == CSSValueThin || id == CSSValueMedium || id == CSSValueThick)
1712             validPrimitive = true;
1713         else
1714             validPrimitive = validUnit(value, FLength | FNonNeg);
1715         break;
1716
1717     case CSSPropertyLetterSpacing:       // normal | <length> | inherit
1718     case CSSPropertyWordSpacing:         // normal | <length> | inherit
1719         if (id == CSSValueNormal)
1720             validPrimitive = true;
1721         else
1722             validPrimitive = validUnit(value, FLength);
1723         break;
1724
1725     case CSSPropertyTextIndent:          // <length> | <percentage> | inherit
1726         validPrimitive = (!id && validUnit(value, FLength | FPercent));
1727         break;
1728
1729     case CSSPropertyPaddingTop:          //// <padding-width> | inherit
1730     case CSSPropertyPaddingRight:        //   Which is defined as
1731     case CSSPropertyPaddingBottom:       //   <length> | <percentage>
1732     case CSSPropertyPaddingLeft:         ////
1733     case CSSPropertyWebkitPaddingStart:
1734     case CSSPropertyWebkitPaddingEnd:
1735     case CSSPropertyWebkitPaddingBefore:
1736     case CSSPropertyWebkitPaddingAfter:
1737         validPrimitive = (!id && validUnit(value, FLength | FPercent | FNonNeg));
1738         break;
1739
1740     case CSSPropertyMaxHeight:           // <length> | <percentage> | none | inherit
1741     case CSSPropertyMaxWidth:            // <length> | <percentage> | none | inherit
1742     case CSSPropertyWebkitMaxLogicalWidth:
1743     case CSSPropertyWebkitMaxLogicalHeight:
1744         if (id == CSSValueNone) {
1745             validPrimitive = true;
1746             break;
1747         }
1748         /* nobreak */
1749     case CSSPropertyMinHeight:           // <length> | <percentage> | inherit
1750     case CSSPropertyMinWidth:            // <length> | <percentage> | inherit
1751     case CSSPropertyWebkitMinLogicalWidth:
1752     case CSSPropertyWebkitMinLogicalHeight:
1753         if (id == CSSValueIntrinsic || id == CSSValueMinIntrinsic)
1754             validPrimitive = true;
1755         else
1756             validPrimitive = (!id && validUnit(value, FLength | FPercent | FNonNeg));
1757         break;
1758
1759     case CSSPropertyFontSize:
1760         // <absolute-size> | <relative-size> | <length> | <percentage> | inherit
1761         if (id >= CSSValueXxSmall && id <= CSSValueLarger)
1762             validPrimitive = true;
1763         else
1764             validPrimitive = (validUnit(value, FLength | FPercent | FNonNeg));
1765         break;
1766
1767     case CSSPropertyFontVariant:         // normal | small-caps | inherit
1768         return parseFontVariant(important);
1769
1770     case CSSPropertyVerticalAlign:
1771         // baseline | sub | super | top | text-top | middle | bottom | text-bottom |
1772         // <percentage> | <length> | inherit
1773
1774         if (id >= CSSValueBaseline && id <= CSSValueWebkitBaselineMiddle)
1775             validPrimitive = true;
1776         else
1777             validPrimitive = (!id && validUnit(value, FLength | FPercent));
1778         break;
1779
1780     case CSSPropertyHeight:               // <length> | <percentage> | auto | inherit
1781     case CSSPropertyWidth:                // <length> | <percentage> | auto | inherit
1782     case CSSPropertyWebkitLogicalWidth:
1783     case CSSPropertyWebkitLogicalHeight:
1784         if (id == CSSValueAuto || id == CSSValueIntrinsic || id == CSSValueMinIntrinsic)
1785             validPrimitive = true;
1786         else if (!id && validUnit(value, FLength | FPercent | FNonNeg))
1787             // ### handle multilength case where we allow relative units
1788             validPrimitive = true;
1789         break;
1790
1791     case CSSPropertyBottom:               // <length> | <percentage> | auto | inherit
1792     case CSSPropertyLeft:                 // <length> | <percentage> | auto | inherit
1793     case CSSPropertyRight:                // <length> | <percentage> | auto | inherit
1794     case CSSPropertyTop:                  // <length> | <percentage> | auto | inherit
1795     case CSSPropertyMarginTop:           //// <margin-width> | inherit
1796     case CSSPropertyMarginRight:         //   Which is defined as
1797     case CSSPropertyMarginBottom:        //   <length> | <percentage> | auto | inherit
1798     case CSSPropertyMarginLeft:          ////
1799     case CSSPropertyWebkitMarginStart:
1800     case CSSPropertyWebkitMarginEnd:
1801     case CSSPropertyWebkitMarginBefore:
1802     case CSSPropertyWebkitMarginAfter:
1803         if (id == CSSValueAuto)
1804             validPrimitive = true;
1805         else
1806             validPrimitive = (!id && validUnit(value, FLength | FPercent));
1807         break;
1808
1809     case CSSPropertyZIndex:              // auto | <integer> | inherit
1810         if (id == CSSValueAuto) {
1811             validPrimitive = true;
1812             break;
1813         }
1814         /* nobreak */
1815     case CSSPropertyOrphans:              // <integer> | inherit
1816     case CSSPropertyWidows:               // <integer> | inherit
1817         // ### not supported later on
1818         validPrimitive = (!id && validUnit(value, FInteger, CSSQuirksMode));
1819         break;
1820
1821     case CSSPropertyLineHeight:          // normal | <number> | <length> | <percentage> | inherit
1822         if (id == CSSValueNormal)
1823             validPrimitive = true;
1824         else
1825             validPrimitive = (!id && validUnit(value, FNumber | FLength | FPercent | FNonNeg));
1826         break;
1827     case CSSPropertyCounterIncrement:    // [ <identifier> <integer>? ]+ | none | inherit
1828         if (id != CSSValueNone)
1829             return parseCounter(propId, 1, important);
1830         validPrimitive = true;
1831         break;
1832     case CSSPropertyCounterReset:        // [ <identifier> <integer>? ]+ | none | inherit
1833         if (id != CSSValueNone)
1834             return parseCounter(propId, 0, important);
1835         validPrimitive = true;
1836         break;
1837     case CSSPropertyFontFamily:
1838         // [[ <family-name> | <generic-family> ],]* [<family-name> | <generic-family>] | inherit
1839     {
1840         parsedValue = parseFontFamily();
1841         break;
1842     }
1843
1844     case CSSPropertyTextDecoration:
1845     case CSSPropertyWebkitTextDecorationsInEffect:
1846         // none | [ underline || overline || line-through || blink ] | inherit
1847         if (id == CSSValueNone) {
1848             validPrimitive = true;
1849         } else {
1850             RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
1851             bool isValid = true;
1852             while (isValid && value) {
1853                 switch (value->id) {
1854                 case CSSValueBlink:
1855                     break;
1856                 case CSSValueUnderline:
1857                 case CSSValueOverline:
1858                 case CSSValueLineThrough:
1859                     list->append(cssValuePool()->createIdentifierValue(value->id));
1860                     break;
1861                 default:
1862                     isValid = false;
1863                 }
1864                 value = m_valueList->next();
1865             }
1866             if (list->length() && isValid) {
1867                 parsedValue = list.release();
1868                 m_valueList->next();
1869             }
1870         }
1871         break;
1872
1873     case CSSPropertyZoom:          // normal | reset | document | <number> | <percentage> | inherit
1874         if (id == CSSValueNormal || id == CSSValueReset || id == CSSValueDocument)
1875             validPrimitive = true;
1876         else
1877             validPrimitive = (!id && validUnit(value, FNumber | FPercent | FNonNeg, CSSStrictMode));
1878         break;
1879
1880     case CSSPropertySrc:  // Only used within @font-face, so cannot use inherit | initial or be !important.  This is a list of urls or local references.
1881         return parseFontFaceSrc();
1882
1883     case CSSPropertyUnicodeRange:
1884         return parseFontFaceUnicodeRange();
1885
1886     /* CSS3 properties */
1887
1888     case CSSPropertyBorderImage: {
1889         RefPtr<CSSValue> result;
1890         return parseBorderImage(propId, result, important);
1891     }
1892     case CSSPropertyWebkitBorderImage:
1893     case CSSPropertyWebkitMaskBoxImage: {
1894         RefPtr<CSSValue> result;
1895         if (parseBorderImage(propId, result)) {
1896             addProperty(propId, result, important);
1897             return true;
1898         }
1899         break;
1900     }
1901     case CSSPropertyBorderImageOutset:
1902     case CSSPropertyWebkitMaskBoxImageOutset: {
1903         RefPtr<CSSPrimitiveValue> result;
1904         if (parseBorderImageOutset(result)) {
1905             addProperty(propId, result, important);
1906             return true;
1907         }
1908         break;
1909     }
1910     case CSSPropertyBorderImageRepeat:
1911     case CSSPropertyWebkitMaskBoxImageRepeat: {
1912         RefPtr<CSSValue> result;
1913         if (parseBorderImageRepeat(result)) {
1914             addProperty(propId, result, important);
1915             return true;
1916         }
1917         break;
1918     }
1919     case CSSPropertyBorderImageSlice:
1920     case CSSPropertyWebkitMaskBoxImageSlice: {
1921         RefPtr<CSSBorderImageSliceValue> result;
1922         if (parseBorderImageSlice(propId, result)) {
1923             addProperty(propId, result, important);
1924             return true;
1925         }
1926         break;
1927     }
1928     case CSSPropertyBorderImageWidth:
1929     case CSSPropertyWebkitMaskBoxImageWidth: {
1930         RefPtr<CSSPrimitiveValue> result;
1931         if (parseBorderImageWidth(result)) {
1932             addProperty(propId, result, important);
1933             return true;
1934         }
1935         break;
1936     }
1937     case CSSPropertyBorderTopRightRadius:
1938     case CSSPropertyBorderTopLeftRadius:
1939     case CSSPropertyBorderBottomLeftRadius:
1940     case CSSPropertyBorderBottomRightRadius: {
1941         if (num != 1 && num != 2)
1942             return false;
1943         validPrimitive = validUnit(value, FLength | FPercent | FNonNeg);
1944         if (!validPrimitive)
1945             return false;
1946         RefPtr<CSSPrimitiveValue> parsedValue1 = createPrimitiveNumericValue(value);
1947         RefPtr<CSSPrimitiveValue> parsedValue2;
1948         if (num == 2) {
1949             value = m_valueList->next();
1950             validPrimitive = validUnit(value, FLength | FPercent | FNonNeg);
1951             if (!validPrimitive)
1952                 return false;
1953             parsedValue2 = createPrimitiveNumericValue(value);
1954         } else
1955             parsedValue2 = parsedValue1;
1956
1957         RefPtr<Pair> pair = Pair::create(parsedValue1.release(), parsedValue2.release());
1958         RefPtr<CSSPrimitiveValue> val = cssValuePool()->createValue(pair.release());
1959         addProperty(propId, val.release(), important);
1960         return true;
1961     }
1962     case CSSPropertyWebkitAspectRatio:
1963         return parseAspectRatio(important);
1964     case CSSPropertyBorderRadius:
1965     case CSSPropertyWebkitBorderRadius:
1966         return parseBorderRadius(propId, important);
1967     case CSSPropertyOutlineOffset:
1968         validPrimitive = validUnit(value, FLength | FPercent);
1969         break;
1970     case CSSPropertyTextShadow: // CSS2 property, dropped in CSS2.1, back in CSS3, so treat as CSS3
1971     case CSSPropertyBoxShadow:
1972     case CSSPropertyWebkitBoxShadow:
1973         if (id == CSSValueNone)
1974             validPrimitive = true;
1975         else {
1976             RefPtr<CSSValueList> shadowValueList = parseShadow(m_valueList.get(), propId);
1977             if (shadowValueList) {
1978                 addProperty(propId, shadowValueList.release(), important);
1979                 m_valueList->next();
1980                 return true;
1981             }
1982             return false;
1983         }
1984         break;
1985     case CSSPropertyWebkitBoxReflect:
1986         if (id == CSSValueNone)
1987             validPrimitive = true;
1988         else
1989             return parseReflect(propId, important);
1990         break;
1991     case CSSPropertyOpacity:
1992         validPrimitive = validUnit(value, FNumber);
1993         break;
1994     case CSSPropertyWebkitBoxFlex:
1995         validPrimitive = validUnit(value, FNumber);
1996         break;
1997     case CSSPropertyWebkitBoxFlexGroup:
1998     case CSSPropertyWebkitBoxOrdinalGroup:
1999         validPrimitive = validUnit(value, FInteger | FNonNeg, CSSStrictMode);
2000         break;
2001 #if ENABLE(CSS_FILTERS)
2002     case CSSPropertyWebkitFilter:
2003         if (id == CSSValueNone)
2004             validPrimitive = true;
2005         else {
2006             RefPtr<CSSValue> val = parseFilter();
2007             if (val) {
2008                 addProperty(propId, val, important);
2009                 return true;
2010             }
2011             return false;
2012         }
2013         break;
2014 #endif
2015     case CSSPropertyWebkitFlex:
2016         if (id == CSSValueNone)
2017             validPrimitive = true;
2018         else
2019             parsedValue = parseFlex(m_valueList.get());
2020         break;
2021     case CSSPropertyWebkitFlexOrder:
2022         if (validUnit(value, FInteger, CSSStrictMode)) {
2023             // We restrict the smallest value to int min + 2 because we use int min and int min + 1 as special values in a hash set.
2024             parsedValue = cssValuePool()->createValue(max(static_cast<double>(std::numeric_limits<int>::min() + 2), value->fValue),
2025                                                              static_cast<CSSPrimitiveValue::UnitTypes>(value->unit));
2026             m_valueList->next();
2027         }
2028         break;
2029     case CSSPropertyWebkitMarquee:
2030         return parseShorthand(propId, webkitMarqueeShorthand(), important);
2031     case CSSPropertyWebkitMarqueeIncrement:
2032         if (id == CSSValueSmall || id == CSSValueLarge || id == CSSValueMedium)
2033             validPrimitive = true;
2034         else
2035             validPrimitive = validUnit(value, FLength | FPercent);
2036         break;
2037     case CSSPropertyWebkitMarqueeRepetition:
2038         if (id == CSSValueInfinite)
2039             validPrimitive = true;
2040         else
2041             validPrimitive = validUnit(value, FInteger | FNonNeg);
2042         break;
2043     case CSSPropertyWebkitMarqueeSpeed:
2044         if (id == CSSValueNormal || id == CSSValueSlow || id == CSSValueFast)
2045             validPrimitive = true;
2046         else
2047             validPrimitive = validUnit(value, FTime | FInteger | FNonNeg);
2048         break;
2049     case CSSPropertyWebkitFlowInto:
2050         if (!cssRegionsEnabled())
2051             return false;
2052         return parseFlowThread(propId, important);
2053     case CSSPropertyWebkitFlowFrom:
2054         if (!cssRegionsEnabled())
2055             return false;
2056         return parseRegionThread(propId, important);
2057     case CSSPropertyWebkitRegionOverflow:
2058         if (cssRegionsEnabled() && (id == CSSValueAuto || id == CSSValueBreak))
2059             validPrimitive = true;
2060         break;
2061     case CSSPropertyWebkitTransform:
2062         if (id == CSSValueNone)
2063             validPrimitive = true;
2064         else {
2065             PassRefPtr<CSSValue> val = parseTransform();
2066             if (val) {
2067                 addProperty(propId, val, important);
2068                 return true;
2069             }
2070             return false;
2071         }
2072         break;
2073     case CSSPropertyWebkitTransformOrigin:
2074     case CSSPropertyWebkitTransformOriginX:
2075     case CSSPropertyWebkitTransformOriginY:
2076     case CSSPropertyWebkitTransformOriginZ: {
2077         RefPtr<CSSValue> val1;
2078         RefPtr<CSSValue> val2;
2079         RefPtr<CSSValue> val3;
2080         CSSPropertyID propId1, propId2, propId3;
2081         if (parseTransformOrigin(propId, propId1, propId2, propId3, val1, val2, val3)) {
2082             addProperty(propId1, val1.release(), important);
2083             if (val2)
2084                 addProperty(propId2, val2.release(), important);
2085             if (val3)
2086                 addProperty(propId3, val3.release(), important);
2087             return true;
2088         }
2089         return false;
2090     }
2091     case CSSPropertyWebkitPerspective:
2092         if (id == CSSValueNone)
2093             validPrimitive = true;
2094         else {
2095             // Accepting valueless numbers is a quirk of the -webkit prefixed version of the property.
2096             if (validUnit(value, FNumber | FLength | FNonNeg)) {
2097                 RefPtr<CSSValue> val = createPrimitiveNumericValue(value);
2098                 if (val) {
2099                     addProperty(propId, val.release(), important);
2100                     return true;
2101                 }
2102                 return false;
2103             }
2104         }
2105         break;
2106     case CSSPropertyWebkitPerspectiveOrigin:
2107     case CSSPropertyWebkitPerspectiveOriginX:
2108     case CSSPropertyWebkitPerspectiveOriginY: {
2109         RefPtr<CSSValue> val1;
2110         RefPtr<CSSValue> val2;
2111         CSSPropertyID propId1, propId2;
2112         if (parsePerspectiveOrigin(propId, propId1, propId2, val1, val2)) {
2113             addProperty(propId1, val1.release(), important);
2114             if (val2)
2115                 addProperty(propId2, val2.release(), important);
2116             return true;
2117         }
2118         return false;
2119     }
2120     case CSSPropertyWebkitAnimationDelay:
2121     case CSSPropertyWebkitAnimationDirection:
2122     case CSSPropertyWebkitAnimationDuration:
2123     case CSSPropertyWebkitAnimationFillMode:
2124     case CSSPropertyWebkitAnimationName:
2125     case CSSPropertyWebkitAnimationPlayState:
2126     case CSSPropertyWebkitAnimationIterationCount:
2127     case CSSPropertyWebkitAnimationTimingFunction:
2128     case CSSPropertyWebkitTransitionDelay:
2129     case CSSPropertyWebkitTransitionDuration:
2130     case CSSPropertyWebkitTransitionTimingFunction:
2131     case CSSPropertyWebkitTransitionProperty: {
2132         RefPtr<CSSValue> val;
2133         if (parseAnimationProperty(propId, val)) {
2134             addProperty(propId, val.release(), important);
2135             return true;
2136         }
2137         return false;
2138     }
2139 #if ENABLE(CSS_GRID_LAYOUT)
2140     case CSSPropertyWebkitGridColumns:
2141     case CSSPropertyWebkitGridRows:
2142         return parseGridTrackList(propId, important);
2143
2144     case CSSPropertyWebkitGridColumn:
2145     case CSSPropertyWebkitGridRow:
2146         validPrimitive = id == CSSValueAuto || validUnit(value, FInteger);
2147         break;
2148 #endif
2149     case CSSPropertyWebkitMarginCollapse: {
2150         if (num == 1) {
2151             ShorthandScope scope(this, CSSPropertyWebkitMarginCollapse);
2152             if (!parseValue(webkitMarginCollapseShorthand().properties()[0], important))
2153                 return false;
2154             CSSValue* value = m_parsedProperties.last().value();
2155             addProperty(webkitMarginCollapseShorthand().properties()[1], value, important);
2156             return true;
2157         }
2158         else if (num == 2) {
2159             ShorthandScope scope(this, CSSPropertyWebkitMarginCollapse);
2160             if (!parseValue(webkitMarginCollapseShorthand().properties()[0], important) || !parseValue(webkitMarginCollapseShorthand().properties()[1], important))
2161                 return false;
2162             return true;
2163         }
2164         return false;
2165     }
2166     case CSSPropertyTextLineThroughWidth:
2167     case CSSPropertyTextOverlineWidth:
2168     case CSSPropertyTextUnderlineWidth:
2169         if (id == CSSValueAuto || id == CSSValueNormal || id == CSSValueThin ||
2170             id == CSSValueMedium || id == CSSValueThick)
2171             validPrimitive = true;
2172         else
2173             validPrimitive = !id && validUnit(value, FNumber | FLength | FPercent);
2174         break;
2175     case CSSPropertyWebkitColumnCount:
2176         if (id == CSSValueAuto)
2177             validPrimitive = true;
2178         else
2179             validPrimitive = !id && validUnit(value, FInteger | FNonNeg, CSSQuirksMode);
2180         break;
2181     case CSSPropertyWebkitColumnGap:         // normal | <length>
2182         if (id == CSSValueNormal)
2183             validPrimitive = true;
2184         else
2185             validPrimitive = validUnit(value, FLength | FNonNeg);
2186         break;
2187     case CSSPropertyWebkitColumnAxis:
2188         if (id == CSSValueHorizontal || id == CSSValueVertical || id == CSSValueAuto)
2189             validPrimitive = true;
2190         break;
2191     case CSSPropertyWebkitColumnSpan:        // all | 1
2192         if (id == CSSValueAll)
2193             validPrimitive = true;
2194         else
2195             validPrimitive = validUnit(value, FNumber | FNonNeg) && value->fValue == 1;
2196         break;
2197     case CSSPropertyWebkitColumnWidth:         // auto | <length>
2198         if (id == CSSValueAuto)
2199             validPrimitive = true;
2200         else // Always parse this property in strict mode, since it would be ambiguous otherwise when used in the 'columns' shorthand property.
2201             validPrimitive = validUnit(value, FLength, CSSStrictMode);
2202         break;
2203     // End of CSS3 properties
2204
2205     // Apple specific properties.  These will never be standardized and are purely to
2206     // support custom WebKit-based Apple applications.
2207     case CSSPropertyWebkitLineClamp:
2208         // When specifying number of lines, don't allow 0 as a valid value
2209         // When specifying either type of unit, require non-negative integers
2210         validPrimitive = (!id && (value->unit == CSSPrimitiveValue::CSS_PERCENTAGE || value->fValue) && validUnit(value, FInteger | FPercent | FNonNeg, CSSQuirksMode));
2211         break;
2212
2213     case CSSPropertyWebkitFontSizeDelta:           // <length>
2214         validPrimitive = validUnit(value, FLength);
2215         break;
2216
2217     case CSSPropertyWebkitHighlight:
2218         if (id == CSSValueNone || value->unit == CSSPrimitiveValue::CSS_STRING)
2219             validPrimitive = true;
2220         break;
2221
2222     case CSSPropertyWebkitHyphenateCharacter:
2223         if (id == CSSValueAuto || value->unit == CSSPrimitiveValue::CSS_STRING)
2224             validPrimitive = true;
2225         break;
2226
2227     case CSSPropertyWebkitHyphenateLimitBefore:
2228     case CSSPropertyWebkitHyphenateLimitAfter:
2229         if (id == CSSValueAuto || validUnit(value, FInteger | FNonNeg, CSSStrictMode))
2230             validPrimitive = true;
2231         break;
2232
2233     case CSSPropertyWebkitHyphenateLimitLines:
2234         if (id == CSSValueNoLimit || validUnit(value, FInteger | FNonNeg, CSSStrictMode))
2235             validPrimitive = true;
2236         break;
2237
2238     case CSSPropertyWebkitLineGrid:
2239         if (id == CSSValueNone)
2240             validPrimitive = true;
2241         else if (value->unit == CSSPrimitiveValue::CSS_IDENT) {
2242             String lineGridValue = String(value->string);
2243             if (!lineGridValue.isEmpty()) {
2244                 addProperty(propId, cssValuePool()->createValue(lineGridValue, CSSPrimitiveValue::CSS_STRING), important);
2245                 return true;
2246             }
2247         }
2248         break;
2249     case CSSPropertyWebkitLocale:
2250         if (id == CSSValueAuto || value->unit == CSSPrimitiveValue::CSS_STRING)
2251             validPrimitive = true;
2252         break;
2253
2254 #if ENABLE(DASHBOARD_SUPPORT)
2255     case CSSPropertyWebkitDashboardRegion: // <dashboard-region> | <dashboard-region>
2256         if (value->unit == CSSParserValue::Function || id == CSSValueNone)
2257             return parseDashboardRegions(propId, important);
2258         break;
2259 #endif
2260     // End Apple-specific properties
2261
2262 #if ENABLE(TOUCH_EVENTS)
2263     case CSSPropertyWebkitTapHighlightColor:
2264         if ((id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu
2265             || (id >= CSSValueWebkitFocusRingColor && id < CSSValueWebkitText && inQuirksMode())) {
2266             validPrimitive = true;
2267         } else {
2268             parsedValue = parseColor();
2269             if (parsedValue)
2270                 m_valueList->next();
2271         }
2272         break;
2273 #endif
2274
2275         /* shorthand properties */
2276     case CSSPropertyBackground: {
2277         // Position must come before color in this array because a plain old "0" is a legal color
2278         // in quirks mode but it's usually the X coordinate of a position.
2279         // FIXME: Add CSSPropertyBackgroundSize to the shorthand.
2280         const CSSPropertyID properties[] = { CSSPropertyBackgroundImage, CSSPropertyBackgroundRepeat,
2281                                    CSSPropertyBackgroundAttachment, CSSPropertyBackgroundPosition, CSSPropertyBackgroundOrigin,
2282                                    CSSPropertyBackgroundClip, CSSPropertyBackgroundColor };
2283         return parseFillShorthand(propId, properties, 7, important);
2284     }
2285     case CSSPropertyWebkitMask: {
2286         const CSSPropertyID properties[] = { CSSPropertyWebkitMaskImage, CSSPropertyWebkitMaskRepeat,
2287                                    CSSPropertyWebkitMaskAttachment, CSSPropertyWebkitMaskPosition,
2288                                    CSSPropertyWebkitMaskOrigin, CSSPropertyWebkitMaskClip };
2289         return parseFillShorthand(propId, properties, 6, important);
2290     }
2291     case CSSPropertyBorder:
2292         // [ 'border-width' || 'border-style' || <color> ] | inherit
2293     {
2294         if (parseShorthand(propId, borderAbridgedShorthand(), important)) {
2295             // The CSS3 Borders and Backgrounds specification says that border also resets border-image. It's as
2296             // though a value of none was specified for the image.
2297             addProperty(CSSPropertyBorderImage, cssValuePool()->createImplicitInitialValue(), important);
2298             return true;
2299         }
2300         return false;
2301     }
2302     case CSSPropertyBorderTop:
2303         // [ 'border-top-width' || 'border-style' || <color> ] | inherit
2304         return parseShorthand(propId, borderTopShorthand(), important);
2305     case CSSPropertyBorderRight:
2306         // [ 'border-right-width' || 'border-style' || <color> ] | inherit
2307         return parseShorthand(propId, borderRightShorthand(), important);
2308     case CSSPropertyBorderBottom:
2309         // [ 'border-bottom-width' || 'border-style' || <color> ] | inherit
2310         return parseShorthand(propId, borderBottomShorthand(), important);
2311     case CSSPropertyBorderLeft:
2312         // [ 'border-left-width' || 'border-style' || <color> ] | inherit
2313         return parseShorthand(propId, borderLeftShorthand(), important);
2314     case CSSPropertyWebkitBorderStart:
2315         return parseShorthand(propId, webkitBorderStartShorthand(), important);
2316     case CSSPropertyWebkitBorderEnd:
2317         return parseShorthand(propId, webkitBorderEndShorthand(), important);
2318     case CSSPropertyWebkitBorderBefore:
2319         return parseShorthand(propId, webkitBorderBeforeShorthand(), important);
2320     case CSSPropertyWebkitBorderAfter:
2321         return parseShorthand(propId, webkitBorderAfterShorthand(), important);
2322     case CSSPropertyOutline:
2323         // [ 'outline-color' || 'outline-style' || 'outline-width' ] | inherit
2324         return parseShorthand(propId, outlineShorthand(), important);
2325     case CSSPropertyBorderColor:
2326         // <color>{1,4} | inherit
2327         return parse4Values(propId, borderColorShorthand().properties(), important);
2328     case CSSPropertyBorderWidth:
2329         // <border-width>{1,4} | inherit
2330         return parse4Values(propId, borderWidthShorthand().properties(), important);
2331     case CSSPropertyBorderStyle:
2332         // <border-style>{1,4} | inherit
2333         return parse4Values(propId, borderStyleShorthand().properties(), important);
2334     case CSSPropertyMargin:
2335         // <margin-width>{1,4} | inherit
2336         return parse4Values(propId, marginShorthand().properties(), important);
2337     case CSSPropertyPadding:
2338         // <padding-width>{1,4} | inherit
2339         return parse4Values(propId, paddingShorthand().properties(), important);
2340     case CSSPropertyWebkitFlexFlow:
2341         return parseShorthand(propId, webkitFlexFlowShorthand(), important);
2342     case CSSPropertyFont:
2343         // [ [ 'font-style' || 'font-variant' || 'font-weight' ]? 'font-size' [ / 'line-height' ]?
2344         // 'font-family' ] | caption | icon | menu | message-box | small-caption | status-bar | inherit
2345         if (id >= CSSValueCaption && id <= CSSValueStatusBar)
2346             validPrimitive = true;
2347         else
2348             return parseFont(important);
2349         break;
2350     case CSSPropertyListStyle:
2351         return parseShorthand(propId, listStyleShorthand(), important);
2352     case CSSPropertyWebkitColumns:
2353         return parseShorthand(propId, webkitColumnsShorthand(), important);
2354     case CSSPropertyWebkitColumnRule:
2355         return parseShorthand(propId, webkitColumnRuleShorthand(), important);
2356     case CSSPropertyWebkitTextStroke:
2357         return parseShorthand(propId, webkitTextStrokeShorthand(), important);
2358     case CSSPropertyWebkitAnimation:
2359         return parseAnimationShorthand(important);
2360     case CSSPropertyWebkitTransition:
2361         return parseTransitionShorthand(important);
2362     case CSSPropertyInvalid:
2363         return false;
2364     case CSSPropertyPage:
2365         return parsePage(propId, important);
2366     case CSSPropertyFontStretch:
2367     case CSSPropertyTextLineThrough:
2368     case CSSPropertyTextOverline:
2369     case CSSPropertyTextUnderline:
2370         return false;
2371     // CSS Text Layout Module Level 3: Vertical writing support
2372     case CSSPropertyWebkitTextEmphasis:
2373         return parseShorthand(propId, webkitTextEmphasisShorthand(), important);
2374
2375     case CSSPropertyWebkitTextEmphasisStyle:
2376         return parseTextEmphasisStyle(important);
2377
2378     case CSSPropertyWebkitTextOrientation:
2379         // FIXME: For now just support upright and vertical-right.
2380         if (id == CSSValueVerticalRight || id == CSSValueUpright)
2381             validPrimitive = true;
2382         break;
2383
2384     case CSSPropertyWebkitLineBoxContain:
2385         if (id == CSSValueNone)
2386             validPrimitive = true;
2387         else
2388             return parseLineBoxContain(important);
2389         break;
2390     case CSSPropertyWebkitFontFeatureSettings:
2391         if (id == CSSValueNormal)
2392             validPrimitive = true;
2393         else
2394             return parseFontFeatureSettings(important);
2395         break;
2396
2397     case CSSPropertyWebkitFontVariantLigatures:
2398         if (id == CSSValueNormal)
2399             validPrimitive = true;
2400         else
2401             return parseFontVariantLigatures(important);
2402         break;
2403
2404     case CSSPropertyWebkitShapeInside:
2405     case CSSPropertyWebkitShapeOutside:
2406         if (id == CSSValueAuto)
2407             validPrimitive = true;
2408         else if (value->unit == CSSParserValue::Function)
2409             return parseExclusionShape((propId == CSSPropertyWebkitShapeInside), important);
2410         break;
2411     case CSSPropertyWebkitWrapMargin:
2412     case CSSPropertyWebkitWrapPadding:
2413         validPrimitive = (!id && validUnit(value, FLength | FNonNeg));
2414         break;
2415     case CSSPropertyWebkitWrap:
2416         return parseShorthand(propId, webkitWrapShorthand(), important);
2417     case CSSPropertyBorderBottomStyle:
2418     case CSSPropertyBorderCollapse:
2419     case CSSPropertyBorderLeftStyle:
2420     case CSSPropertyBorderRightStyle:
2421     case CSSPropertyBorderTopStyle:
2422     case CSSPropertyBoxSizing:
2423     case CSSPropertyCaptionSide:
2424     case CSSPropertyClear:
2425     case CSSPropertyDirection:
2426     case CSSPropertyDisplay:
2427     case CSSPropertyEmptyCells:
2428     case CSSPropertyFloat:
2429     case CSSPropertyFontStyle:
2430     case CSSPropertyImageRendering:
2431     case CSSPropertyListStylePosition:
2432     case CSSPropertyListStyleType:
2433     case CSSPropertyOutlineStyle:
2434     case CSSPropertyOverflowX:
2435     case CSSPropertyOverflowY:
2436     case CSSPropertyPointerEvents:
2437     case CSSPropertyPosition:
2438     case CSSPropertyResize:
2439     case CSSPropertySpeak:
2440     case CSSPropertyTableLayout:
2441     case CSSPropertyTextLineThroughMode:
2442     case CSSPropertyTextLineThroughStyle:
2443     case CSSPropertyTextOverflow:
2444     case CSSPropertyTextOverlineMode:
2445     case CSSPropertyTextOverlineStyle:
2446     case CSSPropertyTextRendering:
2447     case CSSPropertyTextTransform:
2448     case CSSPropertyTextUnderlineMode:
2449     case CSSPropertyTextUnderlineStyle:
2450     case CSSPropertyVisibility:
2451     case CSSPropertyWebkitAppearance:
2452     case CSSPropertyWebkitBackfaceVisibility:
2453     case CSSPropertyWebkitBorderAfterStyle:
2454     case CSSPropertyWebkitBorderBeforeStyle:
2455     case CSSPropertyWebkitBorderEndStyle:
2456     case CSSPropertyWebkitBorderFit:
2457     case CSSPropertyWebkitBorderStartStyle:
2458     case CSSPropertyWebkitBoxAlign:
2459     case CSSPropertyWebkitBoxDirection:
2460     case CSSPropertyWebkitBoxLines:
2461     case CSSPropertyWebkitBoxOrient:
2462     case CSSPropertyWebkitBoxPack:
2463     case CSSPropertyWebkitColorCorrection:
2464     case CSSPropertyWebkitColumnRuleStyle:
2465     case CSSPropertyWebkitFlexAlign:
2466     case CSSPropertyWebkitFlexDirection:
2467     case CSSPropertyWebkitFlexItemAlign:
2468     case CSSPropertyWebkitFlexLinePack:
2469     case CSSPropertyWebkitFlexPack:
2470     case CSSPropertyWebkitFlexWrap:
2471     case CSSPropertyWebkitFontKerning:
2472     case CSSPropertyWebkitFontSmoothing:
2473     case CSSPropertyWebkitHyphens:
2474     case CSSPropertyWebkitLineAlign:
2475     case CSSPropertyWebkitLineBreak:
2476     case CSSPropertyWebkitLineSnap:
2477     case CSSPropertyWebkitMarginAfterCollapse:
2478     case CSSPropertyWebkitMarginBeforeCollapse:
2479     case CSSPropertyWebkitMarginBottomCollapse:
2480     case CSSPropertyWebkitMarginTopCollapse:
2481     case CSSPropertyWebkitMarqueeDirection:
2482     case CSSPropertyWebkitMarqueeStyle:
2483     case CSSPropertyWebkitMatchNearestMailBlockquoteColor:
2484     case CSSPropertyWebkitNbspMode:
2485 #if ENABLE(OVERFLOW_SCROLLING)
2486     case CSSPropertyWebkitOverflowScrolling:
2487 #endif
2488     case CSSPropertyWebkitPrintColorAdjust:
2489     case CSSPropertyWebkitRtlOrdering:
2490     case CSSPropertyWebkitTextCombine:
2491     case CSSPropertyWebkitTextEmphasisPosition:
2492     case CSSPropertyWebkitTextSecurity:
2493     case CSSPropertyWebkitTextSizeAdjust:
2494     case CSSPropertyWebkitTransformStyle:
2495     case CSSPropertyWebkitUserDrag:
2496     case CSSPropertyWebkitUserModify:
2497     case CSSPropertyWebkitUserSelect:
2498     case CSSPropertyWebkitWrapFlow:
2499     case CSSPropertyWebkitWrapThrough:
2500     case CSSPropertyWebkitWritingMode:
2501     case CSSPropertyWhiteSpace:
2502     case CSSPropertyWordBreak:
2503     case CSSPropertyWordWrap:
2504         // These properties should be handled before in isValidKeywordPropertyAndValue().
2505         ASSERT_NOT_REACHED();
2506         return false;
2507 #if ENABLE(SVG)
2508     default:
2509         return parseSVGValue(propId, important);
2510 #endif
2511     }
2512
2513     if (validPrimitive) {
2514         parsedValue = parseValidPrimitive(id, value);
2515         m_valueList->next();
2516     }
2517     ASSERT(!m_parsedCalculation);
2518     if (parsedValue) {
2519         if (!m_valueList->current() || inShorthand()) {
2520             addProperty(propId, parsedValue.release(), important);
2521             return true;
2522         }
2523     }
2524     return false;
2525 }
2526
2527 void CSSParser::addFillValue(RefPtr<CSSValue>& lval, PassRefPtr<CSSValue> rval)
2528 {
2529     if (lval) {
2530         if (lval->isValueList())
2531             static_cast<CSSValueList*>(lval.get())->append(rval);
2532         else {
2533             PassRefPtr<CSSValue> oldlVal(lval.release());
2534             PassRefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
2535             list->append(oldlVal);
2536             list->append(rval);
2537             lval = list;
2538         }
2539     }
2540     else
2541         lval = rval;
2542 }
2543
2544 static bool parseBackgroundClip(CSSParserValue* parserValue, RefPtr<CSSValue>& cssValue, CSSValuePool* cssValuePool)
2545 {
2546     if (parserValue->id == CSSValueBorderBox || parserValue->id == CSSValuePaddingBox
2547         || parserValue->id == CSSValueContentBox || parserValue->id == CSSValueWebkitText) {
2548         cssValue = cssValuePool->createIdentifierValue(parserValue->id);
2549         return true;
2550     }
2551     return false;
2552 }
2553
2554 const int cMaxFillProperties = 9;
2555
2556 bool CSSParser::parseFillShorthand(CSSPropertyID propId, const CSSPropertyID* properties, int numProperties, bool important)
2557 {
2558     ASSERT(numProperties <= cMaxFillProperties);
2559     if (numProperties > cMaxFillProperties)
2560         return false;
2561
2562     ShorthandScope scope(this, propId);
2563
2564     bool parsedProperty[cMaxFillProperties] = { false };
2565     RefPtr<CSSValue> values[cMaxFillProperties];
2566     RefPtr<CSSValue> clipValue;
2567     RefPtr<CSSValue> positionYValue;
2568     RefPtr<CSSValue> repeatYValue;
2569     bool foundClip = false;
2570     int i;
2571
2572     while (m_valueList->current()) {
2573         CSSParserValue* val = m_valueList->current();
2574         if (val->unit == CSSParserValue::Operator && val->iValue == ',') {
2575             // We hit the end.  Fill in all remaining values with the initial value.
2576             m_valueList->next();
2577             for (i = 0; i < numProperties; ++i) {
2578                 if (properties[i] == CSSPropertyBackgroundColor && parsedProperty[i])
2579                     // Color is not allowed except as the last item in a list for backgrounds.
2580                     // Reject the entire property.
2581                     return false;
2582
2583                 if (!parsedProperty[i] && properties[i] != CSSPropertyBackgroundColor) {
2584                     addFillValue(values[i], cssValuePool()->createImplicitInitialValue());
2585                     if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition)
2586                         addFillValue(positionYValue, cssValuePool()->createImplicitInitialValue());
2587                     if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat)
2588                         addFillValue(repeatYValue, cssValuePool()->createImplicitInitialValue());
2589                     if ((properties[i] == CSSPropertyBackgroundOrigin || properties[i] == CSSPropertyWebkitMaskOrigin) && !parsedProperty[i]) {
2590                         // If background-origin wasn't present, then reset background-clip also.
2591                         addFillValue(clipValue, cssValuePool()->createImplicitInitialValue());
2592                     }
2593                 }
2594                 parsedProperty[i] = false;
2595             }
2596             if (!m_valueList->current())
2597                 break;
2598         }
2599
2600         bool found = false;
2601         for (i = 0; !found && i < numProperties; ++i) {
2602             if (!parsedProperty[i]) {
2603                 RefPtr<CSSValue> val1;
2604                 RefPtr<CSSValue> val2;
2605                 CSSPropertyID propId1, propId2;
2606                 CSSParserValue* parserValue = m_valueList->current();
2607                 if (parseFillProperty(properties[i], propId1, propId2, val1, val2)) {
2608                     parsedProperty[i] = found = true;
2609                     addFillValue(values[i], val1.release());
2610                     if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition)
2611                         addFillValue(positionYValue, val2.release());
2612                     if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat)
2613                         addFillValue(repeatYValue, val2.release());
2614                     if (properties[i] == CSSPropertyBackgroundOrigin || properties[i] == CSSPropertyWebkitMaskOrigin) {
2615                         // Reparse the value as a clip, and see if we succeed.
2616                         if (parseBackgroundClip(parserValue, val1, cssValuePool()))
2617                             addFillValue(clipValue, val1.release()); // The property parsed successfully.
2618                         else
2619                             addFillValue(clipValue, cssValuePool()->createImplicitInitialValue()); // Some value was used for origin that is not supported by clip. Just reset clip instead.
2620                     }
2621                     if (properties[i] == CSSPropertyBackgroundClip || properties[i] == CSSPropertyWebkitMaskClip) {
2622                         // Update clipValue
2623                         addFillValue(clipValue, val1.release());
2624                         foundClip = true;
2625                     }
2626                 }
2627             }
2628         }
2629
2630         // if we didn't find at least one match, this is an
2631         // invalid shorthand and we have to ignore it
2632         if (!found)
2633             return false;
2634     }
2635
2636     // Now add all of the properties we found.
2637     for (i = 0; i < numProperties; i++) {
2638         // Fill in any remaining properties with the initial value.
2639         if (!parsedProperty[i]) {
2640             addFillValue(values[i], cssValuePool()->createImplicitInitialValue());
2641             if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition)
2642                 addFillValue(positionYValue, cssValuePool()->createImplicitInitialValue());
2643             if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat)
2644                 addFillValue(repeatYValue, cssValuePool()->createImplicitInitialValue());
2645             if ((properties[i] == CSSPropertyBackgroundOrigin || properties[i] == CSSPropertyWebkitMaskOrigin)) {
2646                 // If background-origin wasn't present, then reset background-clip also.
2647                 addFillValue(clipValue, cssValuePool()->createImplicitInitialValue());
2648             }
2649         }
2650         if (properties[i] == CSSPropertyBackgroundPosition) {
2651             addProperty(CSSPropertyBackgroundPositionX, values[i].release(), important);
2652             // it's OK to call positionYValue.release() since we only see CSSPropertyBackgroundPosition once
2653             addProperty(CSSPropertyBackgroundPositionY, positionYValue.release(), important);
2654         } else if (properties[i] == CSSPropertyWebkitMaskPosition) {
2655             addProperty(CSSPropertyWebkitMaskPositionX, values[i].release(), important);
2656             // it's OK to call positionYValue.release() since we only see CSSPropertyWebkitMaskPosition once
2657             addProperty(CSSPropertyWebkitMaskPositionY, positionYValue.release(), important);
2658         } else if (properties[i] == CSSPropertyBackgroundRepeat) {
2659             addProperty(CSSPropertyBackgroundRepeatX, values[i].release(), important);
2660             // it's OK to call repeatYValue.release() since we only see CSSPropertyBackgroundPosition once
2661             addProperty(CSSPropertyBackgroundRepeatY, repeatYValue.release(), important);
2662         } else if (properties[i] == CSSPropertyWebkitMaskRepeat) {
2663             addProperty(CSSPropertyWebkitMaskRepeatX, values[i].release(), important);
2664             // it's OK to call repeatYValue.release() since we only see CSSPropertyBackgroundPosition once
2665             addProperty(CSSPropertyWebkitMaskRepeatY, repeatYValue.release(), important);
2666         } else if ((properties[i] == CSSPropertyBackgroundClip || properties[i] == CSSPropertyWebkitMaskClip) && !foundClip)
2667             // Value is already set while updating origin
2668             continue;
2669         else
2670             addProperty(properties[i], values[i].release(), important);
2671
2672         // Add in clip values when we hit the corresponding origin property.
2673         if (properties[i] == CSSPropertyBackgroundOrigin && !foundClip)
2674             addProperty(CSSPropertyBackgroundClip, clipValue.release(), important);
2675         else if (properties[i] == CSSPropertyWebkitMaskOrigin && !foundClip)
2676             addProperty(CSSPropertyWebkitMaskClip, clipValue.release(), important);
2677     }
2678
2679     return true;
2680 }
2681
2682 void CSSParser::addAnimationValue(RefPtr<CSSValue>& lval, PassRefPtr<CSSValue> rval)
2683 {
2684     if (lval) {
2685         if (lval->isValueList())
2686             static_cast<CSSValueList*>(lval.get())->append(rval);
2687         else {
2688             PassRefPtr<CSSValue> oldVal(lval.release());
2689             PassRefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
2690             list->append(oldVal);
2691             list->append(rval);
2692             lval = list;
2693         }
2694     }
2695     else
2696         lval = rval;
2697 }
2698
2699 bool CSSParser::parseAnimationShorthand(bool important)
2700 {
2701     const unsigned numProperties = webkitAnimationShorthand().length();
2702     ShorthandScope scope(this, CSSPropertyWebkitAnimation);
2703
2704     bool parsedProperty[] = { false, false, false, false, false, false, false };
2705     RefPtr<CSSValue> values[7];
2706
2707     unsigned i;
2708     unsigned initialParsedPropertyIndex = 0;
2709     while (m_valueList->current()) {
2710         CSSParserValue* val = m_valueList->current();
2711         if (val->unit == CSSParserValue::Operator && val->iValue == ',') {
2712             // We hit the end.  Fill in all remaining values with the initial value.
2713             initialParsedPropertyIndex = 0;
2714             m_valueList->next();
2715             for (i = 0; i < numProperties; ++i) {
2716                 if (!parsedProperty[i])
2717                     addAnimationValue(values[i], cssValuePool()->createImplicitInitialValue());
2718                 parsedProperty[i] = false;
2719             }
2720             if (!m_valueList->current())
2721                 break;
2722         }
2723
2724         bool found = false;
2725         for (i = initialParsedPropertyIndex; !found && i < numProperties; ++i) {
2726             if (!parsedProperty[i]) {
2727                 RefPtr<CSSValue> val;
2728                 if (parseAnimationProperty(webkitAnimationShorthand().properties()[i], val)) {
2729                     parsedProperty[i] = found = true;
2730                     initialParsedPropertyIndex = 1;
2731                     addAnimationValue(values[i], val.release());
2732                 }
2733             }
2734         }
2735
2736         // if we didn't find at least one match, this is an
2737         // invalid shorthand and we have to ignore it
2738         if (!found)
2739             return false;
2740     }
2741
2742     // Fill in any remaining properties with the initial value.
2743     for (i = 0; i < numProperties; ++i) {
2744         if (!parsedProperty[i])
2745             addAnimationValue(values[i], cssValuePool()->createImplicitInitialValue());
2746     }
2747
2748     // Now add all of the properties we found.
2749     for (i = 0; i < numProperties; i++)
2750         addProperty(webkitAnimationShorthand().properties()[i], values[i].release(), important);
2751
2752     return true;
2753 }
2754
2755 bool CSSParser::parseTransitionShorthand(bool important)
2756 {
2757     const unsigned numProperties = webkitTransitionShorthand().length();
2758
2759     ShorthandScope scope(this, CSSPropertyWebkitTransition);
2760
2761     bool parsedProperty[] = { false, false, false, false };
2762     RefPtr<CSSValue> values[4];
2763
2764     unsigned i;
2765     while (m_valueList->current()) {
2766         CSSParserValue* val = m_valueList->current();
2767         if (val->unit == CSSParserValue::Operator && val->iValue == ',') {
2768             // We hit the end.  Fill in all remaining values with the initial value.
2769             m_valueList->next();
2770             for (i = 0; i < numProperties; ++i) {
2771                 if (!parsedProperty[i])
2772                     addAnimationValue(values[i], cssValuePool()->createImplicitInitialValue());
2773                 parsedProperty[i] = false;
2774             }
2775             if (!m_valueList->current())
2776                 break;
2777         }
2778
2779         bool found = false;
2780         for (i = 0; !found && i < numProperties; ++i) {
2781             if (!parsedProperty[i]) {
2782                 RefPtr<CSSValue> val;
2783                 if (parseAnimationProperty(webkitTransitionShorthand().properties()[i], val)) {
2784                     parsedProperty[i] = found = true;
2785                     addAnimationValue(values[i], val.release());
2786                 }
2787             }
2788         }
2789
2790         // if we didn't find at least one match, this is an
2791         // invalid shorthand and we have to ignore it
2792         if (!found)
2793             return false;
2794     }
2795
2796     // Fill in any remaining properties with the initial value.
2797     for (i = 0; i < numProperties; ++i) {
2798         if (!parsedProperty[i])
2799             addAnimationValue(values[i], cssValuePool()->createImplicitInitialValue());
2800     }
2801
2802     // Now add all of the properties we found.
2803     for (i = 0; i < numProperties; i++)
2804         addProperty(webkitTransitionShorthand().properties()[i], values[i].release(), important);
2805
2806     return true;
2807 }
2808
2809 bool CSSParser::parseShorthand(CSSPropertyID propId, const StylePropertyShorthand& shorthand, bool important)
2810 {
2811     // We try to match as many properties as possible
2812     // We set up an array of booleans to mark which property has been found,
2813     // and we try to search for properties until it makes no longer any sense.
2814     ShorthandScope scope(this, propId);
2815
2816     bool found = false;
2817     unsigned propertiesParsed = 0;
2818     bool propertyFound[6]= { false, false, false, false, false, false }; // 6 is enough size.
2819
2820     while (m_valueList->current()) {
2821         found = false;
2822         for (unsigned propIndex = 0; !found && propIndex < shorthand.length(); ++propIndex) {
2823             if (!propertyFound[propIndex] && parseValue(shorthand.properties()[propIndex], important)) {
2824                     propertyFound[propIndex] = found = true;
2825                     propertiesParsed++;
2826             }
2827         }
2828
2829         // if we didn't find at least one match, this is an
2830         // invalid shorthand and we have to ignore it
2831         if (!found)
2832             return false;
2833     }
2834
2835     if (propertiesParsed == shorthand.length())
2836         return true;
2837
2838     // Fill in any remaining properties with the initial value.
2839     ImplicitScope implicitScope(this, PropertyImplicit);
2840     const StylePropertyShorthand* const* const propertiesForInitialization = shorthand.propertiesForInitialization();
2841     for (unsigned i = 0; i < shorthand.length(); ++i) {
2842         if (propertyFound[i])
2843             continue;
2844
2845         if (propertiesForInitialization) {
2846             const StylePropertyShorthand& initProperties = *(propertiesForInitialization[i]);
2847             for (unsigned propIndex = 0; propIndex < initProperties.length(); ++propIndex)
2848                 addProperty(initProperties.properties()[propIndex], cssValuePool()->createImplicitInitialValue(), important);
2849         } else
2850             addProperty(shorthand.properties()[i], cssValuePool()->createImplicitInitialValue(), important);
2851     }
2852
2853     return true;
2854 }
2855
2856 bool CSSParser::parse4Values(CSSPropertyID propId, const CSSPropertyID *properties,  bool important)
2857 {
2858     /* From the CSS 2 specs, 8.3
2859      * If there is only one value, it applies to all sides. If there are two values, the top and
2860      * bottom margins are set to the first value and the right and left margins are set to the second.
2861      * If there are three values, the top is set to the first value, the left and right are set to the
2862      * second, and the bottom is set to the third. If there are four values, they apply to the top,
2863      * right, bottom, and left, respectively.
2864      */
2865
2866     int num = inShorthand() ? 1 : m_valueList->size();
2867
2868     ShorthandScope scope(this, propId);
2869
2870     // the order is top, right, bottom, left
2871     switch (num) {
2872         case 1: {
2873             if (!parseValue(properties[0], important))
2874                 return false;
2875             CSSValue *value = m_parsedProperties.last().value();
2876             ImplicitScope implicitScope(this, PropertyImplicit);
2877             addProperty(properties[1], value, important);
2878             addProperty(properties[2], value, important);
2879             addProperty(properties[3], value, important);
2880             break;
2881         }
2882         case 2: {
2883             if (!parseValue(properties[0], important) || !parseValue(properties[1], important))
2884                 return false;
2885             CSSValue *value = m_parsedProperties[m_parsedProperties.size() - 2].value();
2886             ImplicitScope implicitScope(this, PropertyImplicit);
2887             addProperty(properties[2], value, important);
2888             value = m_parsedProperties[m_parsedProperties.size() - 2].value();
2889             addProperty(properties[3], value, important);
2890             break;
2891         }
2892         case 3: {
2893             if (!parseValue(properties[0], important) || !parseValue(properties[1], important) || !parseValue(properties[2], important))
2894                 return false;
2895             CSSValue *value = m_parsedProperties[m_parsedProperties.size() - 2].value();
2896             ImplicitScope implicitScope(this, PropertyImplicit);
2897             addProperty(properties[3], value, important);
2898             break;
2899         }
2900         case 4: {
2901             if (!parseValue(properties[0], important) || !parseValue(properties[1], important) ||
2902                 !parseValue(properties[2], important) || !parseValue(properties[3], important))
2903                 return false;
2904             break;
2905         }
2906         default: {
2907             return false;
2908         }
2909     }
2910
2911     return true;
2912 }
2913
2914 // auto | <identifier>
2915 bool CSSParser::parsePage(CSSPropertyID propId, bool important)
2916 {
2917     ASSERT(propId == CSSPropertyPage);
2918
2919     if (m_valueList->size() != 1)
2920         return false;
2921
2922     CSSParserValue* value = m_valueList->current();
2923     if (!value)
2924         return false;
2925
2926     if (value->id == CSSValueAuto) {
2927         addProperty(propId, cssValuePool()->createIdentifierValue(value->id), important);
2928         return true;
2929     } else if (value->id == 0 && value->unit == CSSPrimitiveValue::CSS_IDENT) {
2930         addProperty(propId, createPrimitiveStringValue(value), important);
2931         return true;
2932     }
2933     return false;
2934 }
2935
2936 // <length>{1,2} | auto | [ <page-size> || [ portrait | landscape] ]
2937 bool CSSParser::parseSize(CSSPropertyID propId, bool important)
2938 {
2939     ASSERT(propId == CSSPropertySize);
2940
2941     if (m_valueList->size() > 2)
2942         return false;
2943
2944     CSSParserValue* value = m_valueList->current();
2945     if (!value)
2946         return false;
2947
2948     RefPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
2949
2950     // First parameter.
2951     SizeParameterType paramType = parseSizeParameter(parsedValues.get(), value, None);
2952     if (paramType == None)
2953         return false;
2954
2955     // Second parameter, if any.
2956     value = m_valueList->next();
2957     if (value) {
2958         paramType = parseSizeParameter(parsedValues.get(), value, paramType);
2959         if (paramType == None)
2960             return false;
2961     }
2962
2963     addProperty(propId, parsedValues.release(), important);
2964     return true;
2965 }
2966
2967 CSSParser::SizeParameterType CSSParser::parseSizeParameter(CSSValueList* parsedValues, CSSParserValue* value, SizeParameterType prevParamType)
2968 {
2969     switch (value->id) {
2970     case CSSValueAuto:
2971         if (prevParamType == None) {
2972             parsedValues->append(cssValuePool()->createIdentifierValue(value->id));
2973             return Auto;
2974         }
2975         return None;
2976     case CSSValueLandscape:
2977     case CSSValuePortrait:
2978         if (prevParamType == None || prevParamType == PageSize) {
2979             parsedValues->append(cssValuePool()->createIdentifierValue(value->id));
2980             return Orientation;
2981         }
2982         return None;
2983     case CSSValueA3:
2984     case CSSValueA4:
2985     case CSSValueA5:
2986     case CSSValueB4:
2987     case CSSValueB5:
2988     case CSSValueLedger:
2989     case CSSValueLegal:
2990     case CSSValueLetter:
2991         if (prevParamType == None || prevParamType == Orientation) {
2992             // Normalize to Page Size then Orientation order by prepending.
2993             // This is not specified by the CSS3 Paged Media specification, but for simpler processing later (CSSStyleSelector::applyPageSizeProperty).
2994             parsedValues->prepend(cssValuePool()->createIdentifierValue(value->id));
2995             return PageSize;
2996         }
2997         return None;
2998     case 0:
2999         if (validUnit(value, FLength | FNonNeg) && (prevParamType == None || prevParamType == Length)) {
3000             parsedValues->append(createPrimitiveNumericValue(value));
3001             return Length;
3002         }
3003         return None;
3004     default:
3005         return None;
3006     }
3007 }
3008
3009 // [ <string> <string> ]+ | inherit | none
3010 // inherit and none are handled in parseValue.
3011 bool CSSParser::parseQuotes(CSSPropertyID propId, bool important)
3012 {
3013     RefPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
3014     while (CSSParserValue* val = m_valueList->current()) {
3015         RefPtr<CSSValue> parsedValue;
3016         if (val->unit == CSSPrimitiveValue::CSS_STRING)
3017             parsedValue = CSSPrimitiveValue::create(val->string, CSSPrimitiveValue::CSS_STRING);
3018         else
3019             break;
3020         values->append(parsedValue.release());
3021         m_valueList->next();
3022     }
3023     if (values->length()) {
3024         addProperty(propId, values.release(), important);
3025         m_valueList->next();
3026         return true;
3027     }
3028     return false;
3029 }
3030
3031 // [ <string> | <uri> | <counter> | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit
3032 // in CSS 2.1 this got somewhat reduced:
3033 // [ <string> | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit
3034 bool CSSParser::parseContent(CSSPropertyID propId, bool important)
3035 {
3036     RefPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
3037
3038     while (CSSParserValue* val = m_valueList->current()) {
3039         RefPtr<CSSValue> parsedValue;
3040         if (val->unit == CSSPrimitiveValue::CSS_URI && m_styleSheet) {
3041             // url
3042             // FIXME: The completeURL call should be done when using the CSSImageValue,
3043             // not when creating it.
3044             parsedValue = CSSImageValue::create(m_styleSheet->completeURL(val->string));
3045         } else if (val->unit == CSSParserValue::Function) {
3046             // attr(X) | counter(X [,Y]) | counters(X, Y, [,Z]) | -webkit-gradient(...)
3047             CSSParserValueList* args = val->function->args.get();
3048             if (!args)
3049                 return false;
3050             if (equalIgnoringCase(val->function->name, "attr(")) {
3051                 parsedValue = parseAttr(args);
3052                 if (!parsedValue)
3053                     return false;
3054             } else if (equalIgnoringCase(val->function->name, "counter(")) {
3055                 parsedValue = parseCounterContent(args, false);
3056                 if (!parsedValue)
3057                     return false;
3058             } else if (equalIgnoringCase(val->function->name, "counters(")) {
3059                 parsedValue = parseCounterContent(args, true);
3060                 if (!parsedValue)
3061                     return false;
3062 #if ENABLE(CSS_IMAGE_SET)
3063             } else if (equalIgnoringCase(val->function->name, "-webkit-image-set(")) {
3064                 parsedValue = parseImageSet(m_valueList.get());
3065                 if (!parsedValue)
3066                     return false;
3067 #endif
3068             } else if (isGeneratedImageValue(val)) {
3069                 if (!parseGeneratedImage(m_valueList.get(), parsedValue))
3070                     return false;
3071             } else
3072                 return false;
3073         } else if (val->unit == CSSPrimitiveValue::CSS_IDENT) {
3074             // open-quote
3075             // close-quote
3076             // no-open-quote
3077             // no-close-quote
3078             // inherit
3079             // FIXME: These are not yet implemented (http://bugs.webkit.org/show_bug.cgi?id=6503).
3080             // none
3081             // normal
3082             switch (val->id) {
3083             case CSSValueOpenQuote:
3084             case CSSValueCloseQuote:
3085             case CSSValueNoOpenQuote:
3086             case CSSValueNoCloseQuote:
3087             case CSSValueNone:
3088             case CSSValueNormal:
3089                 parsedValue = cssValuePool()->createIdentifierValue(val->id);
3090             }
3091         } else if (val->unit == CSSPrimitiveValue::CSS_STRING) {
3092             parsedValue = createPrimitiveStringValue(val);
3093         }
3094         if (!parsedValue)
3095             break;
3096         values->append(parsedValue.release());
3097         m_valueList->next();
3098     }
3099
3100     if (values->length()) {
3101         addProperty(propId, values.release(), important);
3102         m_valueList->next();
3103         return true;
3104     }
3105
3106     return false;
3107 }
3108
3109 PassRefPtr<CSSValue> CSSParser::parseAttr(CSSParserValueList* args)
3110 {
3111     if (args->size() != 1)
3112         return 0;
3113
3114     CSSParserValue* a = args->current();
3115
3116     if (a->unit != CSSPrimitiveValue::CSS_IDENT)
3117         return 0;
3118
3119     String attrName = a->string;
3120     // CSS allows identifiers with "-" at the start, like "-webkit-mask-image".
3121     // But HTML attribute names can't have those characters, and we should not
3122     // even parse them inside attr().
3123     if (attrName[0] == '-')
3124         return 0;
3125
3126     Document* document = findDocument();
3127     if (document && document->isHTMLDocument())
3128         attrName = attrName.lower();
3129
3130     return cssValuePool()->createValue(attrName, CSSPrimitiveValue::CSS_ATTR);
3131 }
3132
3133 PassRefPtr<CSSValue> CSSParser::parseBackgroundColor()
3134 {
3135     int id = m_valueList->current()->id;
3136     if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu || id == CSSValueCurrentcolor ||
3137         (id >= CSSValueGrey && id < CSSValueWebkitText && inQuirksMode()))
3138         return cssValuePool()->createIdentifierValue(id);
3139     return parseColor();
3140 }
3141
3142 bool CSSParser::parseFillImage(CSSParserValueList* valueList, RefPtr<CSSValue>& value)
3143 {
3144     if (valueList->current()->id == CSSValueNone) {
3145         value = cssValuePool()->createIdentifierValue(CSSValueNone);
3146         return true;
3147     }
3148     if (valueList->current()->unit == CSSPrimitiveValue::CSS_URI) {
3149         // FIXME: The completeURL call should be done when using the CSSImageValue,
3150         // not when creating it.
3151         if (m_styleSheet)
3152             value = CSSImageValue::create(m_styleSheet->completeURL(valueList->current()->string));
3153         return true;
3154     }
3155
3156     if (isGeneratedImageValue(valueList->current()))
3157         return parseGeneratedImage(valueList, value);
3158     
3159 #if ENABLE(CSS_IMAGE_SET)
3160     if (valueList->current()->unit == CSSParserValue::Function && equalIgnoringCase(valueList->current()->function->name, "-webkit-image-set(")) {
3161         value = parseImageSet(m_valueList.get());
3162         if (value)
3163             return true;
3164     }
3165 #endif
3166
3167     return false;
3168 }
3169
3170 PassRefPtr<CSSValue> CSSParser::parseFillPositionX(CSSParserValueList* valueList)
3171 {
3172     int id = valueList->current()->id;
3173     if (id == CSSValueLeft || id == CSSValueRight || id == CSSValueCenter) {
3174         int percent = 0;
3175         if (id == CSSValueRight)
3176             percent = 100;
3177         else if (id == CSSValueCenter)
3178             percent = 50;
3179         return cssValuePool()->createValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE);
3180     }
3181     if (validUnit(valueList->current(), FPercent | FLength))
3182         return createPrimitiveNumericValue(valueList->current());
3183     return 0;
3184 }
3185
3186 PassRefPtr<CSSValue> CSSParser::parseFillPositionY(CSSParserValueList* valueList)
3187 {
3188     int id = valueList->current()->id;
3189     if (id == CSSValueTop || id == CSSValueBottom || id == CSSValueCenter) {
3190         int percent = 0;
3191         if (id == CSSValueBottom)
3192             percent = 100;
3193         else if (id == CSSValueCenter)
3194             percent = 50;
3195         return cssValuePool()->createValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE);
3196     }
3197     if (validUnit(valueList->current(), FPercent | FLength))
3198         return createPrimitiveNumericValue(valueList->current());
3199     return 0;
3200 }
3201
3202 PassRefPtr<CSSValue> CSSParser::parseFillPositionComponent(CSSParserValueList* valueList, unsigned& cumulativeFlags, FillPositionFlag& individualFlag)
3203 {
3204     int id = valueList->current()->id;
3205     if (id == CSSValueLeft || id == CSSValueTop || id == CSSValueRight || id == CSSValueBottom || id == CSSValueCenter) {
3206         int percent = 0;
3207         if (id == CSSValueLeft || id == CSSValueRight) {
3208             if (cumulativeFlags & XFillPosition)
3209                 return 0;
3210             cumulativeFlags |= XFillPosition;
3211             individualFlag = XFillPosition;
3212             if (id == CSSValueRight)
3213                 percent = 100;
3214         }
3215         else if (id == CSSValueTop || id == CSSValueBottom) {
3216             if (cumulativeFlags & YFillPosition)
3217                 return 0;
3218             cumulativeFlags |= YFillPosition;
3219             individualFlag = YFillPosition;
3220             if (id == CSSValueBottom)
3221                 percent = 100;
3222         } else if (id == CSSValueCenter) {
3223             // Center is ambiguous, so we're not sure which position we've found yet, an x or a y.
3224             percent = 50;
3225             cumulativeFlags |= AmbiguousFillPosition;
3226             individualFlag = AmbiguousFillPosition;
3227         }
3228         return cssValuePool()->createValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE);
3229     }
3230     if (validUnit(valueList->current(), FPercent | FLength)) {
3231         if (!cumulativeFlags) {
3232             cumulativeFlags |= XFillPosition;
3233             individualFlag = XFillPosition;
3234         } else if (cumulativeFlags & (XFillPosition | AmbiguousFillPosition)) {
3235             cumulativeFlags |= YFillPosition;
3236             individualFlag = YFillPosition;
3237         } else {
3238             if (m_parsedCalculation)
3239                 m_parsedCalculation.release();
3240             return 0;
3241         }
3242         return createPrimitiveNumericValue(valueList->current());
3243     }
3244     return 0;
3245 }
3246
3247 void CSSParser::parseFillPosition(CSSParserValueList* valueList, RefPtr<CSSValue>& value1, RefPtr<CSSValue>& value2)
3248 {
3249     CSSParserValue* value = valueList->current();
3250
3251     // Parse the first value.  We're just making sure that it is one of the valid keywords or a percentage/length.
3252     unsigned cumulativeFlags = 0;
3253     FillPositionFlag value1Flag = InvalidFillPosition;
3254     FillPositionFlag value2Flag = InvalidFillPosition;
3255     value1 = parseFillPositionComponent(valueList, cumulativeFlags, value1Flag);
3256     if (!value1)
3257         return;
3258
3259     // It only takes one value for background-position to be correctly parsed if it was specified in a shorthand (since we
3260     // can assume that any other values belong to the rest of the shorthand).  If we're not parsing a shorthand, though, the
3261     // value was explicitly specified for our property.
3262     value = valueList->next();
3263
3264     // First check for the comma.  If so, we are finished parsing this value or value pair.
3265     if (value && value->unit == CSSParserValue::Operator && value->iValue == ',')
3266         value = 0;
3267
3268     if (value) {
3269         value2 = parseFillPositionComponent(valueList, cumulativeFlags, value2Flag);
3270         if (value2)
3271             valueList->next();
3272         else {
3273             if (!inShorthand()) {
3274                 value1.clear();
3275                 return;
3276             }
3277         }
3278     }
3279
3280     if (!value2)
3281         // Only one value was specified.  If that value was not a keyword, then it sets the x position, and the y position
3282         // is simply 50%.  This is our default.
3283         // For keywords, the keyword was either an x-keyword (left/right), a y-keyword (top/bottom), or an ambiguous keyword (center).
3284         // For left/right/center, the default of 50% in the y is still correct.
3285         value2 = cssValuePool()->createValue(50, CSSPrimitiveValue::CSS_PERCENTAGE);
3286
3287     if (value1Flag == YFillPosition || value2Flag == XFillPosition)
3288         value1.swap(value2);
3289 }
3290
3291 void CSSParser::parseFillRepeat(RefPtr<CSSValue>& value1, RefPtr<CSSValue>& value2)
3292 {
3293     CSSParserValue* value = m_valueList->current();
3294
3295     int id = m_valueList->current()->id;
3296     if (id == CSSValueRepeatX) {
3297         m_implicitShorthand = true;
3298         value1 = cssValuePool()->createIdentifierValue(CSSValueRepeat);
3299         value2 = cssValuePool()->createIdentifierValue(CSSValueNoRepeat);
3300         m_valueList->next();
3301         return;
3302     }
3303     if (id == CSSValueRepeatY) {
3304         m_implicitShorthand = true;
3305         value1 = cssValuePool()->createIdentifierValue(CSSValueNoRepeat);
3306         value2 = cssValuePool()->createIdentifierValue(CSSValueRepeat);
3307         m_valueList->next();
3308         return;
3309     }
3310     if (id == CSSValueRepeat || id == CSSValueNoRepeat || id == CSSValueRound || id == CSSValueSpace)
3311         value1 = cssValuePool()->createIdentifierValue(id);
3312     else {
3313         value1 = 0;
3314         return;
3315     }
3316
3317     value = m_valueList->next();
3318
3319     // First check for the comma.  If so, we are finished parsing this value or value pair.
3320     if (value && value->unit == CSSParserValue::Operator && value->iValue == ',')
3321         value = 0;
3322
3323     if (value)
3324         id = m_valueList->current()->id;
3325
3326     if (value && (id == CSSValueRepeat || id == CSSValueNoRepeat || id == CSSValueRound || id == CSSValueSpace)) {
3327         value2 = cssValuePool()->createIdentifierValue(id);
3328         m_valueList->next();
3329     } else {
3330         // If only one value was specified, value2 is the same as value1.
3331         m_implicitShorthand = true;
3332         value2 = cssValuePool()->createIdentifierValue(static_cast<CSSPrimitiveValue*>(value1.get())->getIdent());
3333     }
3334 }
3335
3336 PassRefPtr<CSSValue> CSSParser::parseFillSize(CSSPropertyID propId, bool& allowComma)
3337 {
3338     allowComma = true;
3339     CSSParserValue* value = m_valueList->current();
3340
3341     if (value->id == CSSValueContain || value->id == CSSValueCover)
3342         return cssValuePool()->createIdentifierValue(value->id);
3343
3344     RefPtr<CSSPrimitiveValue> parsedValue1;
3345
3346     if (value->id == CSSValueAuto)
3347         parsedValue1 = cssValuePool()->createIdentifierValue(CSSValueAuto);
3348     else {
3349         if (!validUnit(value, FLength | FPercent))
3350             return 0;
3351         parsedValue1 = createPrimitiveNumericValue(value);
3352     }
3353
3354     RefPtr<CSSPrimitiveValue> parsedValue2;
3355     if ((value = m_valueList->next())) {
3356         if (value->unit == CSSParserValue::Operator && value->iValue == ',')
3357             allowComma = false;
3358         else if (value->id != CSSValueAuto) {
3359             if (!validUnit(value, FLength | FPercent))
3360                 return 0;
3361             parsedValue2 = createPrimitiveNumericValue(value);
3362         }
3363     } else if (!parsedValue2 && propId == CSSPropertyWebkitBackgroundSize) {
3364         // For backwards compatibility we set the second value to the first if it is omitted.
3365         // We only need to do this for -webkit-background-size. It should be safe to let masks match
3366         // the real property.
3367         parsedValue2 = parsedValue1;
3368     }
3369
3370     if (!parsedValue2)