[css-ui] Make caret-color animatable

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)
-      currentStyleColor =
-          currentColorGetter(CSSPropertyWebkitTextFillColor, *state.style());
+    if (isTextDecoration) {
+      currentColorGetter(CSSPropertyWebkitTextFillColor, *state.style(),
+                         currentStyleColor);
+    }
     if (currentStyleColor.isCurrentColor())
-      currentStyleColor = currentColorGetter(CSSPropertyColor, *state.style());
+      currentColorGetter(CSSPropertyColor, *state.style(), currentStyleColor);
     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 20 matching lines @@
       const StyleColor& color) {
     return WTF::wrapUnique(new InheritedColorChecker(property, color));
   }
 
  private:
   InheritedColorChecker(CSSPropertyID property, const StyleColor& 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());
+    StyleColor unvisitedColor;
+    if (!ColorPropertyFunctions::getUnvisitedColor(
+            m_property, *environment.state().parentStyle(), unvisitedColor))
+      return false;
+    return m_color == unvisitedColor;
   }
 
   const CSSPropertyID m_property;
   const StyleColor 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 {
-  const StyleColor initialColor =
-      ColorPropertyFunctions::getInitialColor(cssProperty());
-  return convertStyleColorPair(initialColor, initialColor);
+  StyleColor initialColor;
+  if (ColorPropertyFunctions::getInitialColor(cssProperty(), initialColor))
+    return convertStyleColorPair(initialColor, initialColor);
+  return nullptr;
 }
 
 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(
-      cssProperty(), *state.parentStyle());
+  StyleColor inheritedColor;
+  if (!ColorPropertyFunctions::getUnvisitedColor(
+          cssProperty(), *state.parentStyle(), inheritedColor))
+    return nullptr;
   conversionCheckers.push_back(
       InheritedColorChecker::create(cssProperty(), inheritedColor));
   return convertStyleColorPair(inheritedColor, inheritedColor);
 }
 
 enum InterpolableColorPairIndex : unsigned {
   Unvisited,
   Visited,
   InterpolableColorPairIndexCount,
 };
@@ skipping 22 matching lines @@
     const StyleColor& visitedColor) const {
   std::unique_ptr<InterpolableList> colorPair =
       InterpolableList::create(InterpolableColorPairIndexCount);
   colorPair->set(Unvisited, createInterpolableColor(unvisitedColor));
   colorPair->set(Visited, createInterpolableColor(visitedColor));
   return InterpolationValue(std::move(colorPair));
 }
 
 InterpolationValue CSSColorInterpolationType::maybeConvertUnderlyingValue(
     const InterpolationEnvironment& environment) const {
-  return convertStyleColorPair(
-      ColorPropertyFunctions::getUnvisitedColor(cssProperty(),
-                                                *environment.state().style()),
-      ColorPropertyFunctions::getVisitedColor(cssProperty(),
-                                              *environment.state().style()));
+  StyleColor unvisitedColor;
+  if (!ColorPropertyFunctions::getUnvisitedColor(
+          cssProperty(), *environment.state().style(), unvisitedColor))
+    return nullptr;
+  StyleColor visitedColor;
+  if (!ColorPropertyFunctions::getVisitedColor(
+          cssProperty(), *environment.state().style(), visitedColor))
+    return nullptr;

[alancutter (OOO until 2018), 2016/12/21 00:49:05]

I see a problem here. If either the visited or unvisited caret-color are auto
then interpolation does not occur.
Unfortunately the weird behaviour of color properties actually being two
properties doesn't work nicely with the InterpolationType design. I think this
behavioural issue is corner case enough that we can leave this issue to another
patch, I'm happy to take it on as it's requires non-trivial changes to
ColorInterpolationType to resolve.

For now make getVisitedColor() return StyleColor instead of bool and return
currentcolor if caret-color is auto. That should resolve the issue in
caret-color-interpolation.html.

Create a failing test case with a TODO that points to a bug assigned to me.
<style>
@keyframes test {
  to { caret-color: green; }
}
#target {
  color: red;
  caret-color: blue;
  animation: test 1s paused;
}
#target:visited {
  caret-color: auto;
}
</style>
<a href=""><textarea id="target">The caret-color should not be
red.</textarea></a>

(I'm not sure how you do ref tests for caret-color, please correct my attempt
here).

[Manuel Rego, 2016/12/21 13:14:38]

Wow, it's clear this is getting more complex. :-)
Ok, I've done it and yeah "caret-color-interpolation.html" passes now.
I think it'd be better to have testharness tests if possible
for these cases.
I've create a simple one caret-color-021.html that is not passing
with the last version of this patch.

+
+  return convertStyleColorPair(unvisitedColor, visitedColor);
 }
 
 void CSSColorInterpolationType::apply(
     const InterpolableValue& interpolableValue,
     const NonInterpolableValue*,
     InterpolationEnvironment& environment) const {
   const InterpolableList& colorPair = toInterpolableList(interpolableValue);
   DCHECK_EQ(colorPair.length(), InterpolableColorPairIndexCount);
   ColorPropertyFunctions::setUnvisitedColor(
       cssProperty(), *environment.state().style(),
       resolveInterpolableColor(
           *colorPair.get(Unvisited), environment.state(), false,
           cssProperty() == CSSPropertyTextDecorationColor));
   ColorPropertyFunctions::setVisitedColor(
       cssProperty(), *environment.state().style(),
       resolveInterpolableColor(
           *colorPair.get(Visited), environment.state(), true,
           cssProperty() == CSSPropertyTextDecorationColor));
 }
 
 }  // namespace blink