Emit console warning when element.animate() keyframe value fails to parse

third_party/WebKit/Source/core/css/parser/CSSParser.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/parser/CSSParser.h"
 
 #include "core/css/CSSColorValue.h"
 #include "core/css/CSSKeyframeRule.h"
 #include "core/css/StyleColor.h"
-#include "core/css/StylePropertySet.h"
 #include "core/css/StyleRule.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/parser/CSSParserFastPaths.h"
 #include "core/css/parser/CSSParserImpl.h"
 #include "core/css/parser/CSSPropertyParser.h"
 #include "core/css/parser/CSSSelectorParser.h"
 #include "core/css/parser/CSSSupportsParser.h"
 #include "core/css/parser/CSSTokenizer.h"
 #include "core/css/parser/CSSVariableParser.h"
 #include "core/layout/LayoutTheme.h"
@@ skipping 48 matching lines @@
 }
 
 void CSSParser::parseSheetForInspector(const CSSParserContext& context,
                                        StyleSheetContents* styleSheet,
                                        const String& text,
                                        CSSParserObserver& observer) {
   return CSSParserImpl::parseStyleSheetForInspector(text, context, styleSheet,
                                                     observer);
 }
 
-bool CSSParser::parseValue(MutableStylePropertySet* declaration,
-                           CSSPropertyID unresolvedProperty,
-                           const String& string,
-                           bool important,
-                           StyleSheetContents* styleSheet) {
-  if (string.isEmpty())
-    return false;
+MutableStylePropertySet::SetResult CSSParser::parseValue(
+    MutableStylePropertySet* declaration,
+    CSSPropertyID unresolvedProperty,
+    const String& string,
+    bool important,
+    StyleSheetContents* styleSheet) {
+  if (string.isEmpty()) {
+    bool didParse = false;
+    bool didChange = false;
+    return MutableStylePropertySet::SetResult{didParse, didChange};
+  }
+
   CSSPropertyID resolvedProperty = resolveCSSPropertyID(unresolvedProperty);
   CSSParserMode parserMode = declaration->cssParserMode();
   CSSValue* value =
       CSSParserFastPaths::maybeParseValue(resolvedProperty, string, parserMode);
-  if (value)
-    return declaration->setProperty(
+  if (value) {
+    bool didParse = true;
+    bool didChange = declaration->setProperty(
         CSSProperty(resolvedProperty, *value, important));
+    return MutableStylePropertySet::SetResult{didParse, didChange};
+  }
   CSSParserContext context(parserMode, nullptr);
   if (styleSheet) {
     context = styleSheet->parserContext();
     context.setMode(parserMode);
   }
   return parseValue(declaration, unresolvedProperty, string, important,
                     context);
 }
 
-bool CSSParser::parseValueForCustomProperty(
+MutableStylePropertySet::SetResult CSSParser::parseValueForCustomProperty(
     MutableStylePropertySet* declaration,
     const AtomicString& propertyName,
     const String& value,
     bool important,
     StyleSheetContents* styleSheet,
     bool isAnimationTainted) {
   DCHECK(CSSVariableParser::isValidVariableName(propertyName));
-  if (value.isEmpty())
-    return false;
+  if (value.isEmpty()) {
+    bool didParse = false;
+    bool didChange = false;
+    return MutableStylePropertySet::SetResult{didParse, didChange};
+  }
   CSSParserMode parserMode = declaration->cssParserMode();
   CSSParserContext context(parserMode, nullptr);
   if (styleSheet) {
     context = styleSheet->parserContext();
     context.setMode(parserMode);
   }
   return CSSParserImpl::parseVariableValue(
       declaration, propertyName, value, important, context, isAnimationTainted);
 }
 
 ImmutableStylePropertySet* CSSParser::parseCustomPropertySet(
     CSSParserTokenRange range) {
   return CSSParserImpl::parseCustomPropertySet(range);
 }
 
-bool CSSParser::parseValue(MutableStylePropertySet* declaration,
-                           CSSPropertyID unresolvedProperty,
-                           const String& string,
-                           bool important,
-                           const CSSParserContext& context) {
+MutableStylePropertySet::SetResult CSSParser::parseValue(
+    MutableStylePropertySet* declaration,
+    CSSPropertyID unresolvedProperty,
+    const String& string,
+    bool important,
+    const CSSParserContext& context) {
   return CSSParserImpl::parseValue(declaration, unresolvedProperty, string,
                                    important, context);
 }
 
 const CSSValue* CSSParser::parseSingleValue(CSSPropertyID propertyID,
                                             const String& string,
                                             const CSSParserContext& context) {
   if (string.isEmpty())
     return nullptr;
   if (CSSValue* value = CSSParserFastPaths::maybeParseValue(propertyID, string,
@@ skipping 74 matching lines @@
   builder.append(propertyValue);
   builder.append("; }");
   StyleRuleBase* rule = parseRule(context, nullptr, builder.toString());
   if (!rule || !rule->isFontFaceRule())
     return nullptr;
   return toStyleRuleFontFace(rule)->properties().getPropertyCSSValue(
       propertyID);
 }
 
 }  // namespace blink