Remove DEFINE_TIMING_FUNCTION_TYPE_CASTS from t_p/b/r/c/animation (6/n)

The goal of this CL is to use new downcast helper and remove
DEFINE_TIMING_FUNCTION_TYPE_CASTS to adopt new downcast helpers.

This CL removes DEFINE_TIMING_FUNCTION_TYPE_CASTS for below classes.
- LinearTimingFunction,
- CubicBezierTimingFunction,
- StepsTimingFunction

Bug: 891908
Change-Id: I6485f964d3715ba13d5bdf503b4f6d1028379f40
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1983112
Commit-Queue: Abhijeet Kandalkar <abhijeet@igalia.com>
Reviewed-by: Jeremy Roman <jbroman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#727857}

third_party/blink/renderer/core/animation/compositor_animations_test.cc

@@ -466,7 +466,7 @@ class AnimationCompositorAnimationsTest : public PaintTestConfigurations,
     DCHECK_EQ(keyframe_timing_function->GetType(),
               TimingFunction::Type::CUBIC_BEZIER);
     const auto& cubic_timing_function =
-        ToCubicBezierTimingFunction(*keyframe_timing_function);
+        To<CubicBezierTimingFunction>(*keyframe_timing_function);
     EXPECT_EQ(cubic_timing_function.GetEaseType(), ease_type);
   }
 
@@ -1573,7 +1573,7 @@ TEST_P(AnimationCompositorAnimationsTest,
   EXPECT_EQ(curve_timing_function->GetType(),
             TimingFunction::Type::CUBIC_BEZIER);
   const auto& cubic_timing_function =
-      ToCubicBezierTimingFunction(*curve_timing_function);
+      To<CubicBezierTimingFunction>(*curve_timing_function);
   EXPECT_EQ(cubic_timing_function.GetEaseType(),
             CubicBezierTimingFunction::EaseType::CUSTOM);
   EXPECT_EQ(cubic_timing_function.X1(), 1.0);

third_party/blink/renderer/core/css/properties/computed_style_utils.cc

@@ -1617,8 +1617,8 @@ CSSValue* ComputedStyleUtils::CreateTimingFunctionValue(
     const TimingFunction* timing_function) {
   switch (timing_function->GetType()) {
     case TimingFunction::Type::CUBIC_BEZIER: {
-      const CubicBezierTimingFunction* bezier_timing_function =
-          ToCubicBezierTimingFunction(timing_function);
+      const auto* bezier_timing_function =
+          To<CubicBezierTimingFunction>(timing_function);
       if (bezier_timing_function->GetEaseType() !=
           CubicBezierTimingFunction::EaseType::CUSTOM) {
         CSSValueID value_id = CSSValueID::kInvalid;
@@ -1647,8 +1647,8 @@ CSSValue* ComputedStyleUtils::CreateTimingFunctionValue(
     }
 
     case TimingFunction::Type::STEPS: {
-      const StepsTimingFunction* steps_timing_function =
-          ToStepsTimingFunction(timing_function);
+      const auto* steps_timing_function =
+          To<StepsTimingFunction>(timing_function);
       StepsTimingFunction::StepPosition position =
           steps_timing_function->GetStepPosition();
       int steps = steps_timing_function->NumberOfSteps();

third_party/blink/renderer/platform/animation/timing_function.cc

@@ -200,7 +200,7 @@ bool operator==(const CubicBezierTimingFunction& lhs,
   if (rhs.GetType() != TimingFunction::Type::CUBIC_BEZIER)
     return false;
 
-  const CubicBezierTimingFunction& ctf = ToCubicBezierTimingFunction(rhs);
+  const auto& ctf = To<CubicBezierTimingFunction>(rhs);
   if ((lhs.GetEaseType() == CubicBezierTimingFunction::EaseType::CUSTOM) &&
       (ctf.GetEaseType() == CubicBezierTimingFunction::EaseType::CUSTOM))
     return (lhs.X1() == ctf.X1()) && (lhs.Y1() == ctf.Y1()) &&
@@ -213,7 +213,7 @@ bool operator==(const StepsTimingFunction& lhs, const TimingFunction& rhs) {
   if (rhs.GetType() != TimingFunction::Type::STEPS)
     return false;
 
-  const StepsTimingFunction& stf = ToStepsTimingFunction(rhs);
+  const auto& stf = To<StepsTimingFunction>(rhs);
   return (lhs.NumberOfSteps() == stf.NumberOfSteps()) &&
          (lhs.GetStepPosition() == stf.GetStepPosition());
 }
@@ -223,15 +223,15 @@ bool operator==(const StepsTimingFunction& lhs, const TimingFunction& rhs) {
 bool operator==(const TimingFunction& lhs, const TimingFunction& rhs) {
   switch (lhs.GetType()) {
     case TimingFunction::Type::LINEAR: {
-      const LinearTimingFunction& linear = ToLinearTimingFunction(lhs);
+      const auto& linear = To<LinearTimingFunction>(lhs);
       return (linear == rhs);
     }
     case TimingFunction::Type::CUBIC_BEZIER: {
-      const CubicBezierTimingFunction& cubic = ToCubicBezierTimingFunction(lhs);
+      const auto& cubic = To<CubicBezierTimingFunction>(lhs);
       return (cubic == rhs);
     }
     case TimingFunction::Type::STEPS: {
-      const StepsTimingFunction& step = ToStepsTimingFunction(lhs);
+      const auto& step = To<StepsTimingFunction>(lhs);
       return (step == rhs);
     }
     default:

third_party/blink/renderer/platform/animation/timing_function.h

@@ -30,6 +30,7 @@
 #include "third_party/blink/renderer/platform/platform_export.h"
 #include "third_party/blink/renderer/platform/runtime_enabled_features.h"
 #include "third_party/blink/renderer/platform/wtf/assertions.h"
+#include "third_party/blink/renderer/platform/wtf/casting.h"
 #include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
 #include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
 #include "third_party/blink/renderer/platform/wtf/thread_safe_ref_counted.h"
@@ -217,14 +218,24 @@ PLATFORM_EXPORT bool operator==(const StepsTimingFunction&,
 PLATFORM_EXPORT bool operator==(const TimingFunction&, const TimingFunction&);
 PLATFORM_EXPORT bool operator!=(const TimingFunction&, const TimingFunction&);
 
-#define DEFINE_TIMING_FUNCTION_TYPE_CASTS(typeName, enumName)           \
-  DEFINE_TYPE_CASTS(typeName##TimingFunction, TimingFunction, value,    \
-                    value->GetType() == TimingFunction::Type::enumName, \
-                    value.GetType() == TimingFunction::Type::enumName)
-
-DEFINE_TIMING_FUNCTION_TYPE_CASTS(Linear, LINEAR);
-DEFINE_TIMING_FUNCTION_TYPE_CASTS(CubicBezier, CUBIC_BEZIER);
-DEFINE_TIMING_FUNCTION_TYPE_CASTS(Steps, STEPS);
+template <>
+struct DowncastTraits<LinearTimingFunction> {
+  static bool AllowFrom(const TimingFunction& value) {
+    return value.GetType() == TimingFunction::Type::LINEAR;
+  }
+};
+template <>
+struct DowncastTraits<CubicBezierTimingFunction> {
+  static bool AllowFrom(const TimingFunction& value) {
+    return value.GetType() == TimingFunction::Type::CUBIC_BEZIER;
+  }
+};
+template <>
+struct DowncastTraits<StepsTimingFunction> {
+  static bool AllowFrom(const TimingFunction& value) {
+    return value.GetType() == TimingFunction::Type::STEPS;
+  }
+};
 
 }  // namespace blink