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