Avoid reparsing keyframe selectors

Source/core/css/CSSParser.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 11003 matching lines @@
 {
     PageConsole* console = m_styleSheet->singleOwnerDocument()->page()->console();
     console->addMessage(CSSMessageSource, WarningMessageLevel, message, m_styleSheet->baseURL().string(), lineNumber + 1);
 }
 
 StyleRuleKeyframes* CSSParser::createKeyframesRule(const String& name, PassOwnPtr<Vector<RefPtr<StyleKeyframe> > > popKeyframes)
 {
     OwnPtr<Vector<RefPtr<StyleKeyframe> > > keyframes = popKeyframes;
     m_allowImportRules = m_allowNamespaceDeclarations = false;
     RefPtr<StyleRuleKeyframes> rule = StyleRuleKeyframes::create();
-    for (size_t i = 0; i < keyframes->size(); ++i)
-        rule->parserAppendKeyframe(keyframes->at(i));
+    for (size_t i = 0; i < keyframes->size(); ++i) {
+        RefPtr<StyleKeyframe> keyframe = keyframes->at(i);
+        if (keyframe->isValid()) {
+            rule->parserAppendKeyframe(keyframe);
+            continue;
+        }
+        return 0;
+    }
+
     rule->setName(name);
     StyleRuleKeyframes* rulePtr = rule.get();
     m_parsedRules.append(rule.release());
     endRuleBody();
     return rulePtr;
 }
 
 StyleRuleBase* CSSParser::createStyleRule(Vector<OwnPtr<CSSParserSelector> >* selectors)
 {
     StyleRule* result = 0;
@@ skipping 233 matching lines @@
         if (property.id() == CSSPropertyFontVariant && property.value()->isValueList()) {
             m_parsedProperties.remove(i);
             continue;
         }
         ++i;
     }
 }
 
 StyleKeyframe* CSSParser::createKeyframe(CSSParserValueList* keys)
 {
-    // Create a key string from the passed keys
-    StringBuilder keyString;
-    for (unsigned i = 0; i < keys->size(); ++i) {
-        float key = static_cast<float>(keys->valueAt(i)->fValue);
-        if (i != 0)
-            keyString.append(',');
-        keyString.append(String::number(key));
-        keyString.append('%');
+    Vector<float> keyframeKeys;
+    unsigned keyCount = keys->size();
+    for (unsigned i = 0; i < keyCount; ++i) {
+        CSSParserValue* value = keys->valueAt(i);
+        if (value && value->unit == CSSPrimitiveValue::CSS_NUMBER) {
+            keyframeKeys.append(static_cast<float>(value->fValue / 100));
+            continue;
+        }
+        keyframeKeys.clear();
+        break;
     }
 
     RefPtr<StyleKeyframe> keyframe = StyleKeyframe::create();
-    keyframe->setKeyText(keyString.toString());
+    keyframe->setKeys(keyframeKeys);
     keyframe->setProperties(createStylePropertySet());
 
     clearProperties();
 
     StyleKeyframe* keyframePtr = keyframe.get();
     m_parsedKeyframes.append(keyframe.release());
     return keyframePtr;
 }
 
 void CSSParser::invalidBlockHit()
@@ skipping 415 matching lines @@
 {
     // The tokenizer checks for the construct of an+b.
     // However, since the {ident} rule precedes the {nth} rule, some of those
     // tokens are identified as string literal. Furthermore we need to accept
     // "odd" and "even" which does not match to an+b.
     return equalIgnoringCase(token, "odd") || equalIgnoringCase(token, "even")
         || equalIgnoringCase(token, "n") || equalIgnoringCase(token, "-n");
 }
 
 }