Avoid style recalc during element.animate() when unnecessary

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 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/animation/EffectInput.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/UnionTypesCore.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 "wtf/ASCIICType.h"
 #include "wtf/HashSet.h"
 #include "wtf/NonCopyingSort.h"
 
 namespace blink {
 
 EffectModel* EffectInput::convert(Element* element, const Vector<Dictionary>& keyframeDictionaryVector, ExceptionState& exceptionState)
 {
     if (!element)
         return nullptr;
 
-    // TODO(alancutter): Remove this once composited animations no longer depend on AnimatableValues.
-    if (element->inActiveDocument())
-        element->document().updateLayoutTreeForNodeIfNeeded(element);
-
     StyleSheetContents* styleSheetContents = element->document().elementSheet().contents();
     StringKeyframeVector keyframes;
     double lastOffset = 0;
+    bool encounteredCompositableProperty = false;
 
     for (const auto& keyframeDictionary : keyframeDictionaryVector) {
         RefPtr<StringKeyframe> keyframe = StringKeyframe::create();
 
         ScriptValue scriptValue;
         bool frameHasOffset = DictionaryHelper::get(keyframeDictionary, "offset", scriptValue) && !scriptValue.isNull();
 
         if (frameHasOffset) {
             double offset;
             DictionaryHelper::get(keyframeDictionary, "offset", offset);
@@ skipping 32 matching lines @@
         }
 
         Vector<String> keyframeProperties;
         keyframeDictionary.getPropertyNames(keyframeProperties);
         for (const auto& property : keyframeProperties) {
             String value;
             DictionaryHelper::get(keyframeDictionary, property, value);
 
             CSSPropertyID cssProperty = AnimationInputHelpers::keyframeAttributeToCSSProperty(property);
             if (cssProperty != CSSPropertyInvalid) {
+                if (!encounteredCompositableProperty && CompositorAnimations::isCompositableProperty(cssProperty))
+                    encounteredCompositableProperty = true;
+
                 keyframe->setCSSPropertyValue(cssProperty, value, element, styleSheetContents);
                 continue;
             }
 
             if (property == "offset"
                 || property == "composite"
                 || property == "easing") {
                 continue;
             }
 
             cssProperty = AnimationInputHelpers::keyframeAttributeToPresentationAttribute(property, *element);
             if (cssProperty != CSSPropertyInvalid) {
                 keyframe->setPresentationAttributeValue(cssProperty, value, element, styleSheetContents);
                 continue;
             }
 
             const QualifiedName* svgAttribute = AnimationInputHelpers::keyframeAttributeToSVGAttribute(property, *element);
             if (svgAttribute)
                 keyframe->setSVGAttributeValue(*svgAttribute, value);
         }
     }
 
+    // TODO(alancutter): Remove this once composited animations no longer depend on AnimatableValues.
+    if (encounteredCompositableProperty && element->inActiveDocument())
+        element->document().updateLayoutTreeForNodeIfNeeded(element);
+
     StringKeyframeEffectModel* keyframeEffectModel = StringKeyframeEffectModel::create(keyframes);
     if (!RuntimeEnabledFeatures::cssAdditiveAnimationsEnabled()) {
         for (const auto& keyframeGroup : keyframeEffectModel->getPropertySpecificKeyframeGroups()) {
             PropertyHandle property = keyframeGroup.key;
             if (!property.isCSSProperty())
                 continue;
 
             for (const auto& keyframe : keyframeGroup.value->keyframes()) {
                 if (keyframe->isNeutral()) {
                     exceptionState.throwDOMException(NotSupportedError, "Partial keyframes are not supported.");
@@ skipping 19 matching lines @@
         return convert(element, effectInput.getAsDictionarySequence(), exceptionState);
     if (effectInput.isDictionary()) {
         Vector<Dictionary> keyframes;
         keyframes.append(effectInput.getAsDictionary());
         return convert(element, keyframes, exceptionState);
     }
     return nullptr;
 }
 
 } // namespace blink