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