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

third_party/WebKit/Source/core/animation/EffectInput.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 24 matching lines @@
 #include "bindings/core/v8/DictionarySequenceOrDictionary.h"
 #include "core/animation/AnimationInputHelpers.h"
 #include "core/animation/CompositorAnimations.h"
 #include "core/animation/KeyframeEffectModel.h"
 #include "core/animation/StringKeyframe.h"
 #include "core/css/CSSStyleSheet.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/NodeComputedStyle.h"
+#include "core/frame/FrameConsole.h"
+#include "core/frame/LocalFrame.h"
+#include "core/inspector/ConsoleMessage.h"
 #include "wtf/ASCIICType.h"
 #include "wtf/HashSet.h"
 #include "wtf/NonCopyingSort.h"
 
 namespace blink {
 
 namespace {
 
 bool compareKeyframes(const RefPtr<StringKeyframe>& a,
                       const RefPtr<StringKeyframe>& b) {
@@ skipping 20 matching lines @@
         "Keyframes with specified offsets are not sorted");
     return false;
   }
 
   return true;
 }
 
 void setKeyframeValue(Element& element,
                       StringKeyframe& keyframe,
                       const String& property,
-                      const String& value) {
+                      const String& value,
+                      ExecutionContext* executionContext) {
   StyleSheetContents* styleSheetContents =
       element.document().elementSheet().contents();
   CSSPropertyID cssProperty =
       AnimationInputHelpers::keyframeAttributeToCSSProperty(property,
                                                             element.document());
   if (cssProperty != CSSPropertyInvalid) {
-    if (cssProperty == CSSPropertyVariable)
-      keyframe.setCSSPropertyValue(AtomicString(property), value,
-                                   styleSheetContents);
-    else
-      keyframe.setCSSPropertyValue(cssProperty, value, styleSheetContents);
+    MutableStylePropertySet::SetResult setResult =
+        cssProperty == CSSPropertyVariable
+            ? keyframe.setCSSPropertyValue(AtomicString(property), value,
+                                           styleSheetContents)
+            : keyframe.setCSSPropertyValue(cssProperty, value,
+                                           styleSheetContents);
+    if (!setResult.didParse && executionContext) {
+      Document& document = toDocument(*executionContext);
+      if (document.frame()) {
+        document.frame()->console().addMessage(ConsoleMessage::create(
+            JSMessageSource, WarningMessageLevel,
+            "Invalid keyframe value for property " + property + ": " + value));
+      }
+    }
     return;
   }
   cssProperty = AnimationInputHelpers::keyframeAttributeToPresentationAttribute(
       property, element);
   if (cssProperty != CSSPropertyInvalid) {
     keyframe.setPresentationAttributeValue(cssProperty, value,
                                            styleSheetContents);
     return;
   }
   const QualifiedName* svgAttribute =
@@ skipping 54 matching lines @@
 
 // Spec: http://w3c.github.io/web-animations/#processing-a-keyframes-argument
 EffectModel* EffectInput::convert(
     Element* element,
     const DictionarySequenceOrDictionary& effectInput,
     ExecutionContext* executionContext,
     ExceptionState& exceptionState) {
   if (effectInput.isNull() || !element)
     return nullptr;
 
-  if (effectInput.isDictionarySequence())
+  if (effectInput.isDictionarySequence()) {
     return convertArrayForm(*element, effectInput.getAsDictionarySequence(),
-                            exceptionState);
+                            executionContext, exceptionState);
+  }
 
   const Dictionary& dictionary = effectInput.getAsDictionary();
   DictionaryIterator iterator = dictionary.getIterator(executionContext);
   if (!iterator.isNull()) {
     // TODO(alancutter): Convert keyframes during iteration rather than after to
     // match spec.
     Vector<Dictionary> keyframeDictionaries;
     if (exhaustDictionaryIterator(iterator, executionContext, exceptionState,
-                                  keyframeDictionaries))
-      return convertArrayForm(*element, keyframeDictionaries, exceptionState);
+                                  keyframeDictionaries)) {
+      return convertArrayForm(*element, keyframeDictionaries, executionContext,
+                              exceptionState);
+    }
     return nullptr;
   }
 
   return convertObjectForm(*element, dictionary, executionContext,
                            exceptionState);
 }
 
 EffectModel* EffectInput::convertArrayForm(
     Element& element,
     const Vector<Dictionary>& keyframeDictionaries,
+    ExecutionContext* executionContext,
     ExceptionState& exceptionState) {
   StringKeyframeVector keyframes;
   double lastOffset = 0;
 
   for (const Dictionary& keyframeDictionary : keyframeDictionaries) {
     RefPtr<StringKeyframe> keyframe = StringKeyframe::create();
 
     Nullable<double> offset;
     if (DictionaryHelper::get(keyframeDictionary, "offset", offset) &&
         !offset.isNull()) {
@@ skipping 32 matching lines @@
       Vector<String> values;
       if (DictionaryHelper::get(keyframeDictionary, property, values)) {
         exceptionState.throwTypeError(
             "Lists of values not permitted in array-form list of keyframes");
         return nullptr;
       }
 
       String value;
       DictionaryHelper::get(keyframeDictionary, property, value);
 
-      setKeyframeValue(element, *keyframe.get(), property, value);
+      setKeyframeValue(element, *keyframe.get(), property, value,
+                       executionContext);
     }
     keyframes.append(keyframe);
   }
 
   DCHECK(!exceptionState.hadException());
 
   return createEffectModelFromKeyframes(element, keyframes, exceptionState);
 }
 
 static bool getPropertyIndexedKeyframeValues(
@@ skipping 91 matching lines @@
       else
         keyframe->setOffset(i / (numKeyframes - 1.0));
 
       if (timingFunction)
         keyframe->setEasing(timingFunction);
 
       if (compositeString == "add")
         keyframe->setComposite(EffectModel::CompositeAdd);
       // TODO(alancutter): Support "accumulate" keyframe composition.
 
-      setKeyframeValue(element, *keyframe.get(), property, values[i]);
+      setKeyframeValue(element, *keyframe.get(), property, values[i],
+                       executionContext);
       keyframes.append(keyframe);
     }
   }
 
   std::sort(keyframes.begin(), keyframes.end(), compareKeyframes);
 
   DCHECK(!exceptionState.hadException());
 
   return createEffectModelFromKeyframes(element, keyframes, exceptionState);
 }
 
 }  // namespace blink