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