Remove even more @keyframes related code.

sky/engine/core/css/parser/BisonCSSParser.h

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 - 2010  Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 41 matching lines @@
 class CSSBorderImageSliceValue;
 class CSSPrimitiveValue;
 class CSSSelectorList;
 class CSSValue;
 class CSSValueList;
 class Document;
 class Element;
 class ImmutableStylePropertySet;
 class MutableStylePropertySet;
 class StyleColor;
-class StyleKeyframe;
 class StylePropertyShorthand;
 class StyleRuleBase;
-class StyleRuleKeyframes;
 class StyleSheetContents;
 
 // FIXME: This class is shared with CSSTokenizer so should we rename it to CSSSourceLocation?
 struct CSSParserLocation {
     unsigned offset;
     unsigned lineNumber;
     CSSParserString token;
 };
 
 class BisonCSSParser {
     STACK_ALLOCATED();
     friend inline int cssyylex(void*, BisonCSSParser*);
 public:
     explicit BisonCSSParser(const CSSParserContext&);
     ~BisonCSSParser();
 
     void rollbackLastProperties(int num);
     void setCurrentProperty(CSSPropertyID);
 
     void parseSheet(StyleSheetContents*, const String&);
     PassRefPtr<StyleRuleBase> parseRule(StyleSheetContents*, const String&);
-    PassRefPtr<StyleKeyframe> parseKeyframeRule(StyleSheetContents*, const String&);
     bool parseSupportsCondition(const String&);
     static bool parseValue(MutableStylePropertySet*, CSSPropertyID, const String&, CSSParserMode, StyleSheetContents*);
     static bool parseColor(RGBA32& color, const String&, bool strict = false);
     static StyleColor colorFromRGBColorString(const String&);
     static bool parseSystemColor(RGBA32& color, const String&);
     static PassRefPtr<CSSValueList> parseFontFaceValue(const AtomicString&);
     static PassRefPtr<CSSValue> parseAnimationTimingFunctionValue(const String&);
     bool parseDeclaration(MutableStylePropertySet*, const String&, CSSParserObserver*, StyleSheetContents* contextStyleSheet);
     static PassRefPtr<ImmutableStylePropertySet> parseInlineStyleDeclaration(const String&, Element*);
-    PassOwnPtr<Vector<double> > parseKeyframeKeyList(const String&);
     bool parseAttributeMatchType(CSSSelector::AttributeMatchType&, const String&);
 
     static bool parseValue(MutableStylePropertySet*, CSSPropertyID, const String&, const Document&);
 
     bool parseValue(CSSPropertyID);
     void parseSelector(const String&, CSSSelectorList&);
 
     CSSParserSelector* createFloatingSelector();
     CSSParserSelector* createFloatingSelectorWithTagName(const QualifiedName&);
     PassOwnPtr<CSSParserSelector> sinkFloatingSelector(CSSParserSelector*);
 
     Vector<OwnPtr<CSSParserSelector> >* createFloatingSelectorVector();
     PassOwnPtr<Vector<OwnPtr<CSSParserSelector> > > sinkFloatingSelectorVector(Vector<OwnPtr<CSSParserSelector> >*);
 
     CSSParserValueList* createFloatingValueList();
     PassOwnPtr<CSSParserValueList> sinkFloatingValueList(CSSParserValueList*);
 
     CSSParserFunction* createFloatingFunction();
     CSSParserFunction* createFloatingFunction(const CSSParserString& name, PassOwnPtr<CSSParserValueList> args);
     PassOwnPtr<CSSParserFunction> sinkFloatingFunction(CSSParserFunction*);
 
     CSSParserValue& sinkFloatingValue(CSSParserValue&);
 
-    StyleKeyframe* createKeyframe(CSSParserValueList*);
-    StyleRuleKeyframes* createKeyframesRule(const String&, PassOwnPtr<Vector<RefPtr<StyleKeyframe> > >, bool isPrefixed);
-
     typedef Vector<RefPtr<StyleRuleBase> > RuleList;
     RuleList* createRuleList();
     RuleList* appendRule(RuleList*, StyleRuleBase*);
     StyleRuleBase* createStyleRule(Vector<OwnPtr<CSSParserSelector> >* selectors);
     StyleRuleBase* createFontFaceRule();
     StyleRuleBase* createSupportsRule(bool conditionIsSupported, RuleList*);
     void markSupportsRuleHeaderStart();
     void markSupportsRuleHeaderEnd();
     PassRefPtr<CSSRuleSourceData> popSupportsRuleData();
     StyleRuleBase* createHostRule(RuleList* rules);
 
     void startDeclarationsForMarginBox();
     void endDeclarationsForMarginBox();
 
-    Vector<RefPtr<StyleKeyframe> >* createFloatingKeyframeVector();
-    PassOwnPtr<Vector<RefPtr<StyleKeyframe> > > sinkFloatingKeyframeVector(Vector<RefPtr<StyleKeyframe> >*);
-
     CSSParserSelector* rewriteSpecifiersWithElementName(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector*, bool isNamespacePlaceholder = false);
     CSSParserSelector* rewriteSpecifiersWithNamespaceIfNeeded(CSSParserSelector*);
     CSSParserSelector* rewriteSpecifiers(CSSParserSelector*, CSSParserSelector*);
     CSSParserSelector* rewriteSpecifiersForShadowDistributed(CSSParserSelector* specifiers, CSSParserSelector* distributedPseudoElementSelector);
 
     void invalidBlockHit() { }
 
     Vector<OwnPtr<CSSParserSelector> >* reusableSelectorVector() { return &m_reusableSelectorVector; }
 
     void clearProperties();
 
     PassRefPtr<ImmutableStylePropertySet> createStylePropertySet();
 
     CSSParserContext m_context;
 
     CSSPropertyID m_id;
     RawPtr<StyleSheetContents> m_styleSheet;
     RefPtr<StyleRuleBase> m_rule;
-    RefPtr<StyleKeyframe> m_keyframe;
     OwnPtr<CSSParserValueList> m_valueList;
     bool m_supportsCondition;
 
     Vector<CSSProperty, 256> m_parsedProperties;
     CSSSelectorList* m_selectorListForParseSelector;
 
     unsigned m_numParsedPropertiesBeforeMarginBox;
 
     bool m_hadSyntacticallyValidCSSRule;
     bool m_ignoreErrors;
@@ skipping 55 matching lines @@
     bool m_ruleHasHeader;
 
     bool m_allowImportRules;
     bool m_allowNamespaceDeclarations;
 
     bool m_inViewport;
 
     CSSParserLocation m_locationLabel;
 
     Vector<RefPtr<StyleRuleBase> > m_parsedRules;
-    Vector<RefPtr<StyleKeyframe> > m_parsedKeyframes;
     Vector<OwnPtr<RuleList> > m_parsedRuleLists;
     Vector<CSSParserSelector*> m_floatingSelectors;
     Vector<Vector<OwnPtr<CSSParserSelector> >*> m_floatingSelectorVectors;
     Vector<CSSParserValueList*> m_floatingValueLists;
     Vector<CSSParserFunction*> m_floatingFunctions;
 
-    OwnPtr<Vector<RefPtr<StyleKeyframe> > > m_floatingKeyframeVector;
-
     Vector<OwnPtr<CSSParserSelector> > m_reusableSelectorVector;
 
     OwnPtr<RuleSourceDataList> m_supportsRuleDataStack;
 
     CSSTokenizer m_tokenizer;
 
     friend class TransformOperationInfo;
     friend class FilterOperationInfo;
 };
 
 inline int cssyylex(void* yylval, BisonCSSParser* parser)
 {
     return parser->m_tokenizer.lex(yylval);
 }
 
 bool isValidNthToken(const CSSParserString&);
 
 } // namespace blink
 
 #endif  // SKY_ENGINE_CORE_CSS_PARSER_BISONCSSPARSER_H_