WIP Support var() references in registered custom property keyframes

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

 // 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.
 
 #include "core/css/resolver/CSSVariableResolver.h"
 
 #include "core/CSSPropertyNames.h"
 #include "core/CSSValueKeywords.h"
 #include "core/StyleBuilderFunctions.h"
 #include "core/StylePropertyShorthand.h"
+#include "core/css/CSSCustomPropertyDeclaration.h"
 #include "core/css/CSSPendingSubstitutionValue.h"
 #include "core/css/CSSUnsetValue.h"
 #include "core/css/CSSVariableData.h"
 #include "core/css/CSSVariableReferenceValue.h"
 #include "core/css/PropertyRegistry.h"
 #include "core/css/parser/CSSParserToken.h"
 #include "core/css/parser/CSSParserTokenRange.h"
 #include "core/css/parser/CSSPropertyParser.h"
 #include "core/css/resolver/StyleBuilder.h"
 #include "core/css/resolver/StyleBuilderConverter.h"
@@ skipping 72 matching lines @@
 PassRefPtr<CSSVariableData> CSSVariableResolver::ResolveCustomProperty(
     AtomicString name,
     const CSSVariableData& variable_data) {
   DCHECK(variable_data.NeedsVariableResolution());
 
   bool disallow_animation_tainted = false;
   bool is_animation_tainted = variable_data.IsAnimationTainted();
   Vector<CSSParserToken> tokens;
   Vector<String> backing_strings;
   backing_strings.AppendVector(variable_data.BackingStrings());
+  DCHECK(!variables_seen_.Contains(name));
   variables_seen_.insert(name);
   bool success =
       ResolveTokenRange(variable_data.Tokens(), disallow_animation_tainted,
                         tokens, backing_strings, is_animation_tainted);
   variables_seen_.erase(name);
 
   if (!success || !cycle_start_points_.IsEmpty()) {
     cycle_start_points_.erase(name);
     return nullptr;
   }
   return CSSVariableData::CreateResolved(tokens, std::move(backing_strings),
                                          is_animation_tainted);
 }
 
 bool CSSVariableResolver::ResolveVariableReference(
     CSSParserTokenRange range,
     bool disallow_animation_tainted,
     Vector<CSSParserToken>& result,
     Vector<String>& result_backing_strings,
     bool& result_is_animation_tainted) {
   range.ConsumeWhitespace();
   DCHECK_EQ(range.Peek().GetType(), kIdentToken);
   AtomicString variable_name =
       range.ConsumeIncludingWhitespace().Value().ToAtomicString();
   DCHECK(range.AtEnd() || (range.Peek().GetType() == kCommaToken));
 
+  PropertyHandle property(variable_name);
+  if (state_.AnimationPendingCustomProperties().Contains(property) &&
+      !variables_seen_.Contains(variable_name)) {
+    // We make the StyleResolverState mutable for animated custom properties as
+    // an optimisation. Without this we would need to compute animated values on
+    // the stack without saving the result or perform an expensive and complex
+    // value dependency graph analysis to compute them in the required order.
+    StyleResolver::ApplyAnimatedCustomProperty(
+        const_cast<StyleResolverState&>(state_), *this, property);
+    // Null custom property storage may become non-null after application, we
+    // must refresh these cached values.
+    inherited_variables_ = state_.Style()->InheritedVariables();
+    non_inherited_variables_ = state_.Style()->NonInheritedVariables();
+  }
   CSSVariableData* variable_data = ValueForCustomProperty(variable_name);
   if (!variable_data ||
       (disallow_animation_tainted && variable_data->IsAnimationTainted())) {
     // TODO(alancutter): Append the registered initial custom property value if
     // we are disallowing an animation tainted value.
     return ResolveFallback(range, disallow_animation_tainted, result,
                            result_backing_strings, result_is_animation_tainted);
   }
 
   result.AppendVector(variable_data->Tokens());
@@ skipping 137 matching lines @@
     }
     value = property_cache.at(id);
   }
 
   if (value)
     return value;
 
   return CSSUnsetValue::Create();
 }
 
+const CSSValue*
+CSSVariableResolver::ResolveRegisteredCustomPropertyAnimationKeyframe(
+    const PropertyRegistration& registration,
+    const CSSCustomPropertyDeclaration& keyframe) {
+  DCHECK(keyframe.Value());
+  const AtomicString& name = keyframe.GetName();
+  DCHECK_EQ(registry_->Registration(name), &registration);
+
+  if (variables_seen_.Contains(name)) {
+    cycle_start_points_.insert(name);
+    return nullptr;
+  }
+
+  if (!keyframe.Value()->NeedsVariableResolution()) {
+    return keyframe.Value()->ParseForSyntax(registration.Syntax());
+  }
+
+  RefPtr<CSSVariableData> resolved_tokens =
+      ResolveCustomProperty(name, *keyframe.Value());
+  if (!resolved_tokens) {
+    return nullptr;
+  }
+  return resolved_tokens->ParseForSyntax(registration.Syntax());
+}
+
 void CSSVariableResolver::ResolveVariableDefinitions() {
   if (!inherited_variables_ && !non_inherited_variables_)
     return;
 
   int variable_count = 0;
   if (inherited_variables_) {
     for (auto& variable : inherited_variables_->data_)
       ValueForCustomProperty(variable.key);
     variable_count += inherited_variables_->data_.size();
   }
@@ skipping 30 matching lines @@
   }
 }
 
 CSSVariableResolver::CSSVariableResolver(const StyleResolverState& state)
     : state_(state),
       inherited_variables_(state.Style()->InheritedVariables()),
       non_inherited_variables_(state.Style()->NonInheritedVariables()),
       registry_(state.GetDocument().GetPropertyRegistry()) {}
 
 }  // namespace blink