Don't animate caret-color: auto

third_party/WebKit/Source/core/animation/CSSColorInterpolationType.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/animation/CSSColorInterpolationType.h"
 
 #include "core/animation/ColorPropertyFunctions.h"
 #include "core/css/CSSColorValue.h"
 #include "core/css/CSSIdentifierValue.h"
 #include "core/css/resolver/StyleResolverState.h"
@@ skipping 103 matching lines @@
   double green = toInterpolableNumber(list.get(Green))->value();
   double blue = toInterpolableNumber(list.get(Blue))->value();
   double alpha = toInterpolableNumber(list.get(Alpha))->value();
 
   if (double currentcolorFraction =
           toInterpolableNumber(list.get(Currentcolor))->value()) {
     auto currentColorGetter = isVisited
                                   ? ColorPropertyFunctions::getVisitedColor
                                   : ColorPropertyFunctions::getUnvisitedColor;
     StyleColor currentStyleColor = StyleColor::currentColor();
-    if (isTextDecoration)
+    if (isTextDecoration) {
       currentStyleColor =
-          currentColorGetter(CSSPropertyWebkitTextFillColor, *state.style());
-    if (currentStyleColor.isCurrentColor())
-      currentStyleColor = currentColorGetter(CSSPropertyColor, *state.style());
+          currentColorGetter(CSSPropertyWebkitTextFillColor, *state.style())
+              .access();
+    }
+    if (currentStyleColor.isCurrentColor()) {
+      currentStyleColor =
+          currentColorGetter(CSSPropertyColor, *state.style()).access();
+    }
     addPremultipliedColor(red, green, blue, alpha, currentcolorFraction,
                           currentStyleColor.getColor());
   }
   const TextLinkColors& colors = state.document().textLinkColors();
   if (double webkitActivelinkFraction =
           toInterpolableNumber(list.get(WebkitActivelink))->value())
     addPremultipliedColor(red, green, blue, alpha, webkitActivelinkFraction,
                           colors.activeLinkColor());
   if (double webkitLinkFraction =
           toInterpolableNumber(list.get(WebkitLink))->value())
@@ skipping 10 matching lines @@
     return Color::transparent;
 
   return makeRGBA(round(red / alpha), round(green / alpha), round(blue / alpha),
                   round(alpha));
 }
 
 class InheritedColorChecker : public InterpolationType::ConversionChecker {
  public:
   static std::unique_ptr<InheritedColorChecker> create(
       CSSPropertyID property,
-      const StyleColor& color) {
+      const OptionalStyleColor& color) {
     return WTF::wrapUnique(new InheritedColorChecker(property, color));
   }
 
  private:
-  InheritedColorChecker(CSSPropertyID property, const StyleColor& color)
+  InheritedColorChecker(CSSPropertyID property, const OptionalStyleColor& color)
       : m_property(property), m_color(color) {}
 
   bool isValid(const InterpolationEnvironment& environment,
                const InterpolationValue& underlying) const final {
     return m_color == ColorPropertyFunctions::getUnvisitedColor(
                           m_property, *environment.state().parentStyle());
   }
 
   const CSSPropertyID m_property;
-  const StyleColor m_color;
+  const OptionalStyleColor m_color;
 };
 
 InterpolationValue CSSColorInterpolationType::maybeConvertNeutral(
     const InterpolationValue&,
     ConversionCheckers&) const {
   return convertStyleColorPair(StyleColor(Color::transparent),
                                StyleColor(Color::transparent));
 }
 
 InterpolationValue CSSColorInterpolationType::maybeConvertInitial(
     const StyleResolverState&,
     ConversionCheckers& conversionCheckers) const {
-  StyleColor initialColor;
-  if (ColorPropertyFunctions::getInitialColor(cssProperty(), initialColor))
-    return convertStyleColorPair(initialColor, initialColor);
-  return nullptr;
+  OptionalStyleColor initialColor =
+      ColorPropertyFunctions::getInitialColor(cssProperty());
+  if (initialColor.isNull())
+    return nullptr;
+  return convertStyleColorPair(initialColor.access(), initialColor.access());
 }
 
 InterpolationValue CSSColorInterpolationType::maybeConvertInherit(
     const StyleResolverState& state,
     ConversionCheckers& conversionCheckers) const {
   if (!state.parentStyle())
     return nullptr;
   // Visited color can never explicitly inherit from parent visited color so
   // only use the unvisited color.
-  const StyleColor inheritedColor = ColorPropertyFunctions::getUnvisitedColor(
+  OptionalStyleColor inheritedColor = ColorPropertyFunctions::getUnvisitedColor(
       cssProperty(), *state.parentStyle());
   conversionCheckers.push_back(
       InheritedColorChecker::create(cssProperty(), inheritedColor));
   return convertStyleColorPair(inheritedColor, inheritedColor);
 }
 
 enum InterpolableColorPairIndex : unsigned {
   Unvisited,
   Visited,
   InterpolableColorPairIndexCount,
@@ skipping 14 matching lines @@
   if (!interpolableColor)
     return nullptr;
   std::unique_ptr<InterpolableList> colorPair =
       InterpolableList::create(InterpolableColorPairIndexCount);
   colorPair->set(Unvisited, interpolableColor->clone());
   colorPair->set(Visited, std::move(interpolableColor));
   return InterpolationValue(std::move(colorPair));
 }
 
 InterpolationValue CSSColorInterpolationType::convertStyleColorPair(
-    const StyleColor& unvisitedColor,
-    const StyleColor& visitedColor) const {
+    const OptionalStyleColor& unvisitedColor,
+    const OptionalStyleColor& visitedColor) const {
+  if (unvisitedColor.isNull() || visitedColor.isNull()) {
+    return nullptr;
+  }
   std::unique_ptr<InterpolableList> colorPair =
       InterpolableList::create(InterpolableColorPairIndexCount);
-  colorPair->set(Unvisited, createInterpolableColor(unvisitedColor));
-  colorPair->set(Visited, createInterpolableColor(visitedColor));
+  colorPair->set(Unvisited, createInterpolableColor(unvisitedColor.access()));
+  colorPair->set(Visited, createInterpolableColor(visitedColor.access()));
   return InterpolationValue(std::move(colorPair));
 }
 
 InterpolationValue
 CSSColorInterpolationType::maybeConvertStandardPropertyUnderlyingValue(
     const ComputedStyle& style) const {
   return convertStyleColorPair(
       ColorPropertyFunctions::getUnvisitedColor(cssProperty(), style),
       ColorPropertyFunctions::getVisitedColor(cssProperty(), style));
 }
@@ skipping 19 matching lines @@
 const CSSValue* CSSColorInterpolationType::createCSSValue(
     const InterpolableValue& interpolableValue,
     const NonInterpolableValue*,
     const StyleResolverState& state) const {
   const InterpolableList& colorPair = toInterpolableList(interpolableValue);
   Color color = resolveInterpolableColor(*colorPair.get(Unvisited), state);
   return CSSColorValue::create(color.rgb());
 }
 
 }  // namespace blink