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