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