Make sure to use CSSValueID and CSSPropertyID rather than integers.

Source/core/css/CSSGrammar.y.in

 /*
  *  Copyright (C) 2002-2003 Lars Knoll (knoll@kde.org)
  *  Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  *  Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *  Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  *  Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
@@ skipping 1652 matching lines @@
 valid_expr:
     term {
         $$ = parser->createFloatingValueList();
         $$->addValue(parser->sinkFloatingValue($1));
     }
     | valid_expr operator term {
         $$ = $1;
         if ($$) {
             if ($2) {
                 CSSParserValue v;
-                v.id = 0;
+                v.id = CSSValueInvalid;
                 v.unit = CSSParserValue::Operator;
                 v.iValue = $2;
                 $$->addValue(v);
             }
             $$->addValue(parser->sinkFloatingValue($3));
         }
     }
   ;
 
 expr_recovery:
@@ skipping 10 matching lines @@
         $$ = ',';
     }
   | /* empty */ {
         $$ = 0;
   }
   ;
 
 term:
   unary_term maybe_space { $$ = $1; }
   | unary_operator unary_term maybe_space { $$ = $2; $$.fValue *= $1; }
-  | STRING maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_STRING; }
+  | STRING maybe_space { $$.id = CSSValueInvalid; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_STRING; }
   | IDENT maybe_space {
       $$.id = cssValueKeywordID($1);
       $$.unit = CSSPrimitiveValue::CSS_IDENT;
       $$.string = $1;
   }
   /* We might need to actually parse the number from a dimension, but we can't just put something that uses $$.string into unary_term. */
-  | DIMEN maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_DIMENSION; }
-  | unary_operator DIMEN maybe_space { $$.id = 0; $$.string = $2; $$.unit = CSSPrimitiveValue::CSS_DIMENSION; }
-  | URI maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_URI; }
-  | UNICODERANGE maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_UNICODE_RANGE; }
-  | HEX maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_PARSER_HEXCOLOR; }
-  | '#' maybe_space { $$.id = 0; $$.string = CSSParserString(); $$.unit = CSSPrimitiveValue::CSS_PARSER_HEXCOLOR; } /* Handle error case: "color: #;" */
+  | DIMEN maybe_space { $$.id = CSSValueInvalid; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_DIMENSION; }
+  | unary_operator DIMEN maybe_space { $$.id = CSSValueInvalid; $$.string = $2; $$.unit = CSSPrimitiveValue::CSS_DIMENSION; }
+  | URI maybe_space { $$.id = CSSValueInvalid; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_URI; }
+  | UNICODERANGE maybe_space { $$.id = CSSValueInvalid; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_UNICODE_RANGE; }
+  | HEX maybe_space { $$.id = CSSValueInvalid; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_PARSER_HEXCOLOR; }
+  | '#' maybe_space { $$.id = CSSValueInvalid; $$.string = CSSParserString(); $$.unit = CSSPrimitiveValue::CSS_PARSER_HEXCOLOR; } /* Handle error case: "color: #;" */
   | VARFUNCTION maybe_space IDENT closing_parenthesis maybe_space {
-      $$.id = 0;
+      $$.id = CSSValueInvalid;
       $$.string = $3;
       $$.unit = CSSPrimitiveValue::CSS_VARIABLE_NAME;
   }
   /* FIXME: according to the specs a function can have a unary_operator in front. I know no case where this makes sense */
   | function maybe_space {
       $$ = $1;
   }
   | calc_function maybe_space {
       $$ = $1;
   }
   | min_or_max_function maybe_space {
       $$ = $1;
   }
   | '%' maybe_space { /* Handle width: %; */
-      $$.id = 0; $$.unit = 0;
+      $$.id = CSSValueInvalid; $$.unit = 0;
   }
   ;
 
 unary_term:
   INTEGER { $$.setFromNumber($1); $$.isInt = true; }
   | FLOATTOKEN { $$.setFromNumber($1); }
   | PERCENTAGE { $$.setFromNumber($1, CSSPrimitiveValue::CSS_PERCENTAGE); }
   | PXS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_PX); }
   | CMS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_CM); }
   | MMS { $$.setFromNumber($1, CSSPrimitiveValue::CSS_MM); }
@@ skipping 26 matching lines @@
   | DPCM { $$.setFromNumber($1, CSSPrimitiveValue::CSS_DPCM); }
   | FR { $$.setFromNumber($1, CSSPrimitiveValue::CSS_FR); }
   ;
 
 function:
     FUNCTION maybe_space expr closing_parenthesis {
         if ($3) {
             CSSParserFunction* f = parser->createFloatingFunction();
             f->name = $1;
             f->args = parser->sinkFloatingValueList($3);
-            $$.id = 0;
+            $$.id = CSSValueInvalid;
             $$.unit = CSSParserValue::Function;
             $$.function = f;
         } else
             YYERROR;
     } |
     FUNCTION maybe_space closing_parenthesis {
         CSSParserFunction* f = parser->createFloatingFunction();
         f->name = $1;
         CSSParserValueList* valueList = parser->createFloatingValueList();
         f->args = parser->sinkFloatingValueList(valueList);
-        $$.id = 0;
+        $$.id = CSSValueInvalid;
         $$.unit = CSSParserValue::Function;
         $$.function = f;
     } |
     FUNCTION maybe_space expr_recovery closing_parenthesis {
         YYERROR;
     }
   ;
 
 calc_func_term:
   unary_term { $$ = $1; }
   | VARFUNCTION maybe_space IDENT closing_parenthesis {
-      $$.id = 0;
+      $$.id = CSSValueInvalid;
       $$.string = $3;
       $$.unit = CSSPrimitiveValue::CSS_VARIABLE_NAME;
   }
   | unary_operator unary_term { $$ = $2; $$.fValue *= $1; }
   ;
 
 calc_func_operator:
     WHITESPACE '+' WHITESPACE {
         $$ = '+';
     }
@@ skipping 11 matching lines @@
 calc_maybe_space:
     /* empty */
     | WHITESPACE
   ;
 
 calc_func_paren_expr:
     '(' maybe_space calc_func_expr calc_maybe_space closing_parenthesis {
         if ($3) {
             $$ = $3;
             CSSParserValue v;
-            v.id = 0;
+            v.id = CSSValueInvalid;
             v.unit = CSSParserValue::Operator;
             v.iValue = '(';
             $$->insertValueAt(0, v);
             v.iValue = ')';
             $$->addValue(v);
         } else
             YYERROR;
     }
     | '(' maybe_space expr_recovery closing_parenthesis {
         YYERROR;
     }
   ;
 
 calc_func_expr:
     valid_calc_func_expr
     | valid_calc_func_expr expr_recovery { $$ = 0; }
   ;
 
 valid_calc_func_expr:
     calc_func_term {
         $$ = parser->createFloatingValueList();
         $$->addValue(parser->sinkFloatingValue($1));
     }
     | calc_func_expr calc_func_operator calc_func_term {
         if ($1 && $2) {
             $$ = $1;
             CSSParserValue v;
-            v.id = 0;
+            v.id = CSSValueInvalid;
             v.unit = CSSParserValue::Operator;
             v.iValue = $2;
             $$->addValue(v);
             $$->addValue(parser->sinkFloatingValue($3));
         } else
             YYERROR;
 
     }
     | calc_func_expr calc_func_operator calc_func_paren_expr {
         if ($1 && $2 && $3) {
             $$ = $1;
             CSSParserValue v;
-            v.id = 0;
+            v.id = CSSValueInvalid;
             v.unit = CSSParserValue::Operator;
             v.iValue = $2;
             $$->addValue(v);
             $$->extend(*($3));
         } else 
             YYERROR;
     }
     | calc_func_paren_expr
   ;
 
 calc_func_expr_list:
     calc_func_expr calc_maybe_space {
         $$ = $1;
     }    
     | calc_func_expr_list ',' maybe_space calc_func_expr calc_maybe_space {
         if ($1 && $4) {
             $$ = $1;
             CSSParserValue v;
-            v.id = 0;
+            v.id = CSSValueInvalid;
             v.unit = CSSParserValue::Operator;
             v.iValue = ',';
             $$->addValue(v);
             $$->extend(*($4));
         } else
             YYERROR;
     }
   ;
 
 calc_function:
     CALCFUNCTION maybe_space calc_func_expr calc_maybe_space closing_parenthesis {
         CSSParserFunction* f = parser->createFloatingFunction();
         f->name = $1;
         f->args = parser->sinkFloatingValueList($3);
-        $$.id = 0;
+        $$.id = CSSValueInvalid;
         $$.unit = CSSParserValue::Function;
         $$.function = f;
     }
     | CALCFUNCTION maybe_space expr_recovery closing_parenthesis {
         YYERROR;
     }
     ;
 
 
 min_or_max:
     MINFUNCTION {
         $$ = $1;
     }
     | MAXFUNCTION {
         $$ = $1;
     }
     ;
 
 min_or_max_function:
     min_or_max maybe_space calc_func_expr_list closing_parenthesis {
         CSSParserFunction* f = parser->createFloatingFunction();
         f->name = $1;
         f->args = parser->sinkFloatingValueList($3);
-        $$.id = 0;
+        $$.id = CSSValueInvalid;
         $$.unit = CSSParserValue::Function;
         $$.function = f;
     } 
     | min_or_max maybe_space expr_recovery closing_parenthesis {
         YYERROR;
     }
     ;
 
 invalid_at:
     ATKEYWORD at_rule_recovery {
@@ skipping 57 matching lines @@
 
 rule_error_recovery:
     /* empty */
   | rule_error_recovery error
   | rule_error_recovery invalid_square_brackets_block
   | rule_error_recovery invalid_parentheses_block
     ;
 
 %%