Implement animation tainted custom property values

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

 // Copyright 2015 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.
 
 #ifndef CSSVariableResolver_h
 #define CSSVariableResolver_h
 
 #include "core/CSSPropertyNames.h"
 #include "core/css/parser/CSSParserToken.h"
 #include "wtf/HashSet.h"
@@ skipping 13 matching lines @@
 
 class CSSVariableResolver {
   STACK_ALLOCATED();
 
  public:
   static void resolveVariableDefinitions(const StyleResolverState&);
 
   // Shorthand properties are not supported.
   static const CSSValue* resolveVariableReferences(const StyleResolverState&,
                                                    CSSPropertyID,
-                                                   const CSSValue&);
+                                                   const CSSValue&,
+                                                   bool omitAnimationTainted);

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

This should actually be disallowAnimationTainted.

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

Done.

 
   DECLARE_TRACE();
 
  private:
   CSSVariableResolver(const StyleResolverState&);
 
   static const CSSValue* resolvePendingSubstitutions(
       const StyleResolverState&,
       CSSPropertyID,
-      const CSSPendingSubstitutionValue&);
+      const CSSPendingSubstitutionValue&,
+      bool omitAnimationTainted);
   static const CSSValue* resolveVariableReferences(
       const StyleResolverState&,
       CSSPropertyID,
-      const CSSVariableReferenceValue&);
+      const CSSVariableReferenceValue&,
+      bool omitAnimationTainted);
 
   // These return false if we encounter a reference to an invalid variable with no fallback
 
   // Resolves a range which may contain var() references or @apply rules
-  bool resolveTokenRange(CSSParserTokenRange, Vector<CSSParserToken>& result);
+  bool resolveTokenRange(CSSParserTokenRange,
+                         bool omitAnimationTainted,
+                         Vector<CSSParserToken>& result,
+                         bool& resultIsAnimationTainted);
   // Resolves the fallback (if present) of a var() reference, starting from the comma
-  bool resolveFallback(CSSParserTokenRange, Vector<CSSParserToken>& result);
+  bool resolveFallback(CSSParserTokenRange,
+                       bool omitAnimationTainted,
+                       Vector<CSSParserToken>& result,
+                       bool& resultIsAnimationTainted);
   // Resolves the contents of a var() reference
   bool resolveVariableReference(CSSParserTokenRange,
-                                Vector<CSSParserToken>& result);
+                                bool omitAnimationTainted,
+                                Vector<CSSParserToken>& result,
+                                bool& resultIsAnimationTainted);
   // Consumes and resolves an @apply rule
   void resolveApplyAtRule(CSSParserTokenRange&, Vector<CSSParserToken>& result);
 
   // These return null if the custom property is invalid
 
   // Returns the CSSVariableData for a custom property, resolving and storing it if necessary
   CSSVariableData* valueForCustomProperty(AtomicString name);
   // Resolves the CSSVariableData from a custom property declaration
   PassRefPtr<CSSVariableData> resolveCustomProperty(AtomicString name,
                                                     const CSSVariableData&);
 
   const StyleResolverState& m_styleResolverState;
   StyleInheritedVariables* m_inheritedVariables;
   StyleNonInheritedVariables* m_nonInheritedVariables;
   Member<const PropertyRegistry> m_registry;
   HashSet<AtomicString> m_variablesSeen;
   // Resolution doesn't finish when a cycle is detected. Fallbacks still
   // need to be tracked for additional cycles, and invalidation only
   // applies back to cycle starts.
   HashSet<AtomicString> m_cycleStartPoints;
 };
 
 }  // namespace blink
 
 #endif  // CSSVariableResolver