Implement animation tainted custom property values

third_party/WebKit/Source/core/css/resolver/CSSVariableResolver.cpp

Index: third_party/WebKit/Source/core/css/resolver/CSSVariableResolver.cpp
diff --git a/third_party/WebKit/Source/core/css/resolver/CSSVariableResolver.cpp b/third_party/WebKit/Source/core/css/resolver/CSSVariableResolver.cpp
index 82f7efc26a3e85f68a69bb09c6459ae9f669ead6..3626b885a9a733cd2889a6f91808179ae331f99e 100644
--- a/third_party/WebKit/Source/core/css/resolver/CSSVariableResolver.cpp
+++ b/third_party/WebKit/Source/core/css/resolver/CSSVariableResolver.cpp
@@ -26,12 +26,15 @@
 namespace blink {
 
 bool CSSVariableResolver::resolveFallback(CSSParserTokenRange range,
-                                          Vector<CSSParserToken>& result) {
+                                          bool omitAnimationTainted,
+                                          Vector<CSSParserToken>& result,
+                                          bool& resultIsAnimationTainted) {
   if (range.atEnd())
     return false;
   ASSERT(range.peek().type() == CommaToken);
   range.consume();
-  return resolveTokenRange(range, result);
+  return resolveTokenRange(range, omitAnimationTainted, result,
+                           resultIsAnimationTainted);
 }
 
 CSSVariableData* CSSVariableResolver::valueForCustomProperty(
@@ -90,9 +93,12 @@ PassRefPtr<CSSVariableData> CSSVariableResolver::resolveCustomProperty(
     const CSSVariableData& variableData) {
   ASSERT(variableData.needsVariableResolution());
 
+  bool omitAnimationTainted = false;
+  bool isAnimationTainted = variableData.isAnimationTainted();
   Vector<CSSParserToken> tokens;
   m_variablesSeen.add(name);
-  bool success = resolveTokenRange(variableData.tokens(), tokens);
+  bool success = resolveTokenRange(variableData.tokens(), omitAnimationTainted,
+                                   tokens, isAnimationTainted);
   m_variablesSeen.remove(name);
 
   // The old variable data holds onto the backing string the new resolved CSSVariableData
@@ -103,12 +109,15 @@ PassRefPtr<CSSVariableData> CSSVariableResolver::resolveCustomProperty(
     m_cycleStartPoints.remove(name);
     return nullptr;
   }
-  return CSSVariableData::createResolved(tokens, variableData);
+  return CSSVariableData::createResolved(tokens, variableData,
+                                         isAnimationTainted);
 }
 
 bool CSSVariableResolver::resolveVariableReference(
     CSSParserTokenRange range,
-    Vector<CSSParserToken>& result) {
+    bool omitAnimationTainted,
+    Vector<CSSParserToken>& result,
+    bool& resultIsAnimationTainted) {
   range.consumeWhitespace();
   ASSERT(range.peek().type() == IdentToken);
   AtomicString variableName =
@@ -116,12 +125,21 @@ bool CSSVariableResolver::resolveVariableReference(
   ASSERT(range.atEnd() || (range.peek().type() == CommaToken));
 
   CSSVariableData* variableData = valueForCustomProperty(variableName);
-  if (!variableData)
-    return resolveFallback(range, result);
+  if (!variableData) {
+    return resolveFallback(range, omitAnimationTainted, result,
+                           resultIsAnimationTainted);
+  }
+
+  if (!omitAnimationTainted || !variableData->isAnimationTainted()) {

[alancutter (OOO until 2018), 2016/10/05 07:46:40]

Negate this and return so it reads better and doesn't need an else.

[alancutter (OOO until 2018), 2016/10/06 01:25:32]

Done.

+    result.appendVector(variableData->tokens());
+    resultIsAnimationTainted |= variableData->isAnimationTainted();
+  } else {
+    // TODO(alancutter): Append the registered initial custom property value.

[alancutter (OOO until 2018), 2016/10/05 07:46:40]

This should be calling resolveFallback instead of discarding it.

[alancutter (OOO until 2018), 2016/10/06 01:25:32]

Done.

+  }
 
-  result.appendVector(variableData->tokens());
   Vector<CSSParserToken> trash;
-  resolveFallback(range, trash);
+  bool trashIsAnimationTainted;
+  resolveFallback(range, omitAnimationTainted, trash, trashIsAnimationTainted);
   return true;
 }
 
@@ -153,11 +171,15 @@ void CSSVariableResolver::resolveApplyAtRule(CSSParserTokenRange& range,
 }
 
 bool CSSVariableResolver::resolveTokenRange(CSSParserTokenRange range,
-                                            Vector<CSSParserToken>& result) {
+                                            bool omitAnimationTainted,
+                                            Vector<CSSParserToken>& result,
+                                            bool& resultIsAnimationTainted) {
   bool success = true;
   while (!range.atEnd()) {
     if (range.peek().functionId() == CSSValueVar) {
-      success &= resolveVariableReference(range.consumeBlock(), result);
+      success &=
+          resolveVariableReference(range.consumeBlock(), omitAnimationTainted,
+                                   result, resultIsAnimationTainted);
     } else if (range.peek().type() == AtKeywordToken &&
                equalIgnoringASCIICase(range.peek().value(), "apply") &&
                RuntimeEnabledFeatures::cssApplyAtRulesEnabled()) {
@@ -172,16 +194,19 @@ bool CSSVariableResolver::resolveTokenRange(CSSParserTokenRange range,
 const CSSValue* CSSVariableResolver::resolveVariableReferences(
     const StyleResolverState& state,
     CSSPropertyID id,
-    const CSSValue& value) {
+    const CSSValue& value,
+    bool omitAnimationTainted) {
   ASSERT(!isShorthandProperty(id));
 
-  if (value.isPendingSubstitutionValue())
-    return resolvePendingSubstitutions(state, id,
-                                       toCSSPendingSubstitutionValue(value));
+  if (value.isPendingSubstitutionValue()) {
+    return resolvePendingSubstitutions(
+        state, id, toCSSPendingSubstitutionValue(value), omitAnimationTainted);
+  }
 
-  if (value.isVariableReferenceValue())
-    return resolveVariableReferences(state, id,
-                                     toCSSVariableReferenceValue(value));
+  if (value.isVariableReferenceValue()) {
+    return resolveVariableReferences(
+        state, id, toCSSVariableReferenceValue(value), omitAnimationTainted);
+  }
 
   NOTREACHED();
   return nullptr;
@@ -190,10 +215,14 @@ const CSSValue* CSSVariableResolver::resolveVariableReferences(
 const CSSValue* CSSVariableResolver::resolveVariableReferences(
     const StyleResolverState& state,
     CSSPropertyID id,
-    const CSSVariableReferenceValue& value) {
+    const CSSVariableReferenceValue& value,
+    bool omitAnimationTainted) {
   CSSVariableResolver resolver(state);
   Vector<CSSParserToken> tokens;
-  if (!resolver.resolveTokenRange(value.variableDataValue()->tokens(), tokens))
+  bool isAnimationTainted = false;
+  if (!resolver.resolveTokenRange(value.variableDataValue()->tokens(),
+                                  omitAnimationTainted, tokens,
+                                  isAnimationTainted))
     return CSSUnsetValue::create();
   const CSSValue* result =
       CSSPropertyParser::parseSingleValue(id, tokens, strictCSSParserContext());
@@ -205,7 +234,8 @@ const CSSValue* CSSVariableResolver::resolveVariableReferences(
 const CSSValue* CSSVariableResolver::resolvePendingSubstitutions(
     const StyleResolverState& state,
     CSSPropertyID id,
-    const CSSPendingSubstitutionValue& pendingValue) {
+    const CSSPendingSubstitutionValue& pendingValue,
+    bool omitAnimationTainted) {
   // Longhands from shorthand references follow this path.
   HeapHashMap<CSSPropertyID, Member<const CSSValue>>& propertyCache =
       state.parsedPropertiesForPendingSubstitutionCache(pendingValue);
@@ -219,8 +249,10 @@ const CSSValue* CSSVariableResolver::resolvePendingSubstitutions(
     CSSVariableResolver resolver(state);
 
     Vector<CSSParserToken> tokens;
+    bool isAnimationTainted = false;
     if (resolver.resolveTokenRange(
-            shorthandValue->variableDataValue()->tokens(), tokens)) {
+            shorthandValue->variableDataValue()->tokens(), omitAnimationTainted,
+            tokens, isAnimationTainted)) {
       CSSParserContext context(HTMLStandardMode, 0);
 
       HeapVector<CSSProperty, 256> parsedProperties;