Remove @keyframe parsing.

sky/engine/core/css/parser/CSSGrammar.y

 %{
 
 /*
  *  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
@@ skipping 11 matching lines @@
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  *
  */
 
 #include "config.h"
 
 #include "CSSPropertyNames.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/css/CSSSelector.h"
 #include "core/css/CSSSelectorList.h"
-#include "core/css/StyleKeyframe.h"
 #include "core/css/StyleRule.h"
-#include "core/css/StyleRuleKeyframes.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/parser/BisonCSSParser.h"
 #include "core/css/parser/CSSParserMode.h"
 #include "core/dom/Document.h"
 #include "wtf/FastMalloc.h"
 #include <stdlib.h>
 #include <string.h>
 
 using namespace blink;
 
@@ skipping 18 matching lines @@
 
 %union {
     bool boolean;
     char character;
     int integer;
     double number;
     CSSParserString string;
 
     StyleRuleBase* rule;
     // The content of the three below HeapVectors are guaranteed to be kept alive by
-    // the corresponding m_parsedRules, and m_parsedKeyFrames
+    // the corresponding m_parsedRules.
     // lists in BisonCSSParser.h.
     Vector<RefPtr<StyleRuleBase> >* ruleList;
-    Vector<RefPtr<StyleKeyframe> >* keyframeRuleList;
     CSSParserSelector* selector;
     Vector<OwnPtr<CSSParserSelector> >* selectorList;
     CSSSelector::AttributeMatchType attributeMatchType;
     CSSParserValue value;
     CSSParserValueList* valueList;
-    StyleKeyframe* keyframe;
     float val;
     CSSPropertyID id;
     CSSParserLocation location;
 }
 
 %{
 
 static inline int cssyyerror(void*, const char*)
 {
     return 1;
@@ skipping 67 matching lines @@
 %nonassoc error
 %left '|'
 
 %token SUPPORTS_SYM
 %token FONT_FACE_SYM
 %token CHARSET_SYM
 %token INTERNAL_DECLS_SYM
 %token INTERNAL_RULE_SYM
 %token INTERNAL_SELECTOR_SYM
 %token INTERNAL_VALUE_SYM
-%token INTERNAL_KEYFRAME_RULE_SYM
-%token INTERNAL_KEYFRAME_KEY_LIST_SYM
 %token INTERNAL_SUPPORTS_CONDITION_SYM
-%token KEYFRAMES_SYM
 
 %token ATKEYWORD
 
 %token SUPPORTS_NOT
 %token SUPPORTS_AND
 %token SUPPORTS_OR
 
 %token <number> CHS
 %token <number> EMS
 %token <number> EXS
@@ skipping 28 matching lines @@
 %token <string> URI
 %token <string> FUNCTION
 %token <string> NOTFUNCTION
 %token <string> CALCFUNCTION
 %token <string> HOSTFUNCTION
 
 %token <string> UNICODERANGE
 
 %type <rule> ruleset
 %type <rule> font_face
-%type <rule> keyframes
 %type <rule> rule
 %type <rule> valid_rule
 %type <ruleList> block_rule_body
 %type <ruleList> block_rule_list
 %type <rule> block_rule
 %type <rule> block_valid_rule
 %type <rule> supports
-%type <boolean> keyframes_rule_start
 
 %type <string> ident_or_string
 
 %type <boolean> supports_condition
 %type <boolean> supports_condition_in_parens
 %type <boolean> supports_negation
 %type <boolean> supports_conjunction
 %type <boolean> supports_disjunction
 %type <boolean> supports_declaration_condition
 
-%type <string> keyframe_name
-%type <keyframe> keyframe_rule
-%type <keyframeRuleList> keyframes_rule
-%type <keyframeRuleList> keyframe_rule_list
-%type <valueList> key_list
-%type <value> key
-
 %type <id> property
 
 %type <selector> specifier
 %type <selector> specifier_list
 %type <selector> simple_selector
 %type <selector> selector
 %type <selectorList> selector_list
 %type <selectorList> simple_selector_list
 %type <selector> class
 %type <selector> attrib
@@ skipping 29 matching lines @@
 %type <value> track_names_list
 
 %%
 
 stylesheet:
     maybe_charset maybe_sgml rule_list
   | internal_decls
   | internal_rule
   | internal_selector
   | internal_value
-  | internal_keyframe_rule
-  | internal_keyframe_key_list
   | internal_supports_condition
   ;
 
 internal_rule:
     INTERNAL_RULE_SYM maybe_space valid_rule maybe_space TOKEN_EOF {
         parser->m_rule = $3;
     }
 ;
 
-internal_keyframe_rule:
-    INTERNAL_KEYFRAME_RULE_SYM maybe_space keyframe_rule maybe_space TOKEN_EOF {
-        parser->m_keyframe = $3;
-    }
-;
-
-internal_keyframe_key_list:
-    INTERNAL_KEYFRAME_KEY_LIST_SYM maybe_space key_list TOKEN_EOF {
-        parser->m_valueList = parser->sinkFloatingValueList($3);
-    }
-;
-
 internal_decls:
     INTERNAL_DECLS_SYM maybe_space_before_declaration declaration_list TOKEN_EOF {
         /* can be empty */
     }
 ;
 
 internal_value:
     INTERNAL_VALUE_SYM maybe_space expr TOKEN_EOF {
         parser->m_valueList = parser->sinkFloatingValueList($3);
         int oldParsedProperties = parser->m_parsedProperties.size();
@@ skipping 65 matching lines @@
    /* empty */
  | rule_list rule maybe_sgml {
      if ($2 && parser->m_styleSheet)
          parser->m_styleSheet->parserAppendRule($2);
  }
  ;
 
 valid_rule:
     ruleset
   | font_face
-  | keyframes
   | supports
   ;
 
 before_rule:
     /* empty */ {
         parser->startRule();
     }
   ;
 
 rule:
@@ skipping 22 matching lines @@
 
 block_rule_recovery:
     before_rule invalid_rule_header {
         parser->endRule(false);
     }
   ;
 
 block_valid_rule:
     ruleset
   | font_face
-  | keyframes
   | supports
   ;
 
 block_rule:
     before_rule block_valid_rule {
         $$ = $2;
         parser->endRule(!!$$);
     }
   | before_rule invalid_rule {
         $$ = 0;
@@ skipping 89 matching lines @@
         }
         parser->m_valueList = nullptr;
         parser->endProperty(false);
     }
     | '(' maybe_space IDENT maybe_space ':' maybe_space error error_recovery closing_parenthesis maybe_space {
         $$ = false;
         parser->endProperty(false, GeneralCSSError);
     }
     ;
 
-before_keyframes_rule:
-    /* empty */ {
-        parser->startRuleHeader(CSSRuleSourceData::KEYFRAMES_RULE);
-    }
-    ;
-
-keyframes_rule_start:
-    before_keyframes_rule KEYFRAMES_SYM maybe_space {
-        $$ = false;
-    }
-    ;
-
-keyframes:
-    keyframes_rule_start keyframe_name at_rule_header_end_maybe_space '{' at_rule_body_start maybe_space location_label keyframes_rule closing_brace {
-        $$ = parser->createKeyframesRule($2, parser->sinkFloatingKeyframeVector($8), $1 /* isPrefixed */);
-    }
-    ;
-
-keyframe_name:
-    IDENT
-    | STRING
-    ;
-
-keyframes_rule:
-    keyframe_rule_list
-    | keyframe_rule_list keyframes_error_recovery {
-        parser->clearProperties();
-    };
-
-keyframe_rule_list:
-    /* empty */ {
-        $$ = parser->createFloatingKeyframeVector();
-    }
-    |  keyframe_rule_list keyframe_rule maybe_space location_label {
-        $$ = $1;
-        $$->append($2);
-    }
-    | keyframe_rule_list keyframes_error_recovery invalid_block maybe_space location_label {
-        parser->clearProperties();
-    }
-    ;
-
-keyframe_rule:
-    key_list '{' maybe_space declaration_list closing_brace {
-        $$ = parser->createKeyframe($1);
-    }
-    ;
-
-key_list:
-    key maybe_space {
-        $$ = parser->createFloatingValueList();
-        $$->addValue(parser->sinkFloatingValue($1));
-    }
-    | key_list ',' maybe_space key maybe_space {
-        $$ = $1;
-        $$->addValue(parser->sinkFloatingValue($4));
-    }
-    ;
-
-key:
-    maybe_unary_operator PERCENTAGE {
-        $$.setFromNumber($1 * $2);
-    }
-    | IDENT {
-        if ($1.equalIgnoringCase("from"))
-            $$.setFromNumber(0);
-        else if ($1.equalIgnoringCase("to"))
-            $$.setFromNumber(100);
-        else {
-            YYERROR;
-        }
-    }
-    ;
-
-keyframes_error_recovery:
-    error rule_error_recovery {
-        parser->reportError(parser->lastLocationLabel(), InvalidKeyframeSelectorCSSError);
-    }
-    ;
-
 before_font_face_rule:
     /* empty */ {
         parser->startRuleHeader(CSSRuleSourceData::FONT_FACE_RULE);
     }
     ;
 
 font_face:
     before_font_face_rule FONT_FACE_SYM at_rule_header_end_maybe_space
     '{' at_rule_body_start maybe_space_before_declaration declaration_list closing_brace {
         $$ = parser->createFontFaceRule();
@@ skipping 551 matching lines @@
         parser->reportError($2, InvalidRuleCSSError);
     }
     ;
 
 at_rule_end:
     at_invalid_rule_header_end semi_or_eof
   | at_invalid_rule_header_end invalid_block
     ;
 
 regular_invalid_at_rule_header:
-    keyframes_rule_start at_rule_header_recovery
-  | before_font_face_rule FONT_FACE_SYM at_rule_header_recovery
+    before_font_face_rule FONT_FACE_SYM at_rule_header_recovery
   | before_supports_rule SUPPORTS_SYM error error_location rule_error_recovery {
         parser->reportError($4, InvalidSupportsConditionCSSError);
         parser->popSupportsRuleData();
     }
   | error_location invalid_at at_rule_header_recovery {
         parser->reportError($1, InvalidRuleCSSError);
     }
   ;
 
 invalid_rule:
@@ skipping 32 matching lines @@
 
 opening_parenthesis:
     '(' | FUNCTION | CALCFUNCTION | NOTFUNCTION | HOSTFUNCTION
     ;
 
 error_location: {
         $$ = parser->currentLocation();
     }
     ;
 
-location_label: {
-        parser->setLocationLabel(parser->currentLocation());
-    }
-    ;
-
 error_recovery:
     /* empty */
   | error_recovery error
   | error_recovery invalid_block
   | error_recovery invalid_square_brackets_block
   | error_recovery invalid_parentheses_block
     ;
 
 rule_error_recovery:
     /* empty */
   | rule_error_recovery error
   | rule_error_recovery invalid_square_brackets_block
   | rule_error_recovery invalid_parentheses_block
     ;
 
 %%