Add const to SVGPropertyBase's animation value interface

Mechanical change (with luckily no repercussions).

Bug: 1017723
Change-Id: Iaae9529d3a4fb84f2dd4478875afdfc1ad211bd8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2395620
Commit-Queue: Stephen Chenney <schenney@chromium.org>
Auto-Submit: Fredrik Söderquist <fs@opera.com>
Reviewed-by: Stephen Chenney <schenney@chromium.org>
Cr-Commit-Position: refs/heads/master@{#804826}

third_party/blink/renderer/core/svg/properties/svg_list_property_helper.h

@@ -117,8 +117,8 @@ class SVGListPropertyHelper : public SVGListPropertyBase {
  protected:
   void DeepCopy(const Derived*);
 
-  bool AdjustFromToListValues(Derived* from_list,
-                              Derived* to_list,
+  bool AdjustFromToListValues(const Derived* from_list,
+                              const Derived* to_list,
                               float percentage);
 
   virtual ItemPropertyType* CreatePaddingItem() const {
@@ -136,8 +136,8 @@ void SVGListPropertyHelper<Derived, ItemProperty>::DeepCopy(
 
 template <typename Derived, typename ItemProperty>
 bool SVGListPropertyHelper<Derived, ItemProperty>::AdjustFromToListValues(
-    Derived* from_list,
-    Derived* to_list,
+    const Derived* from_list,
+    const Derived* to_list,
     float percentage) {
   // If no 'to' value is given, nothing to animate.
   uint32_t to_list_size = to_list->length();

third_party/blink/renderer/core/svg/properties/svg_property.h

@@ -63,16 +63,17 @@ class SVGPropertyBase : public GarbageCollected<SVGPropertyBase> {
 
   // FIXME: remove below and just have this inherit AnimatableValue in
   // WebAnimations transition.
-  virtual void Add(SVGPropertyBase*, SVGElement*) = 0;
+  virtual void Add(const SVGPropertyBase*, const SVGElement*) = 0;
   virtual void CalculateAnimatedValue(
       const SMILAnimationEffectParameters&,
       float percentage,
       unsigned repeat_count,
-      SVGPropertyBase* from,
-      SVGPropertyBase* to,
-      SVGPropertyBase* to_at_end_of_duration_value,
-      SVGElement*) = 0;
-  virtual float CalculateDistance(SVGPropertyBase* to, SVGElement*) = 0;
+      const SVGPropertyBase* from,
+      const SVGPropertyBase* to,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement*) = 0;
+  virtual float CalculateDistance(const SVGPropertyBase* to,
+                                  const SVGElement*) const = 0;
 
   virtual AnimatedPropertyType GetType() const = 0;
 

third_party/blink/renderer/core/svg/svg_angle.cc

@@ -340,7 +340,7 @@ void SVGAngle::ConvertToSpecifiedUnits(SVGAngleType unit_type) {
   orient_type_->SetEnumValue(kSVGMarkerOrientAngle);
 }
 
-void SVGAngle::Add(SVGPropertyBase* other, SVGElement*) {
+void SVGAngle::Add(const SVGPropertyBase* other, const SVGElement*) {
   auto* other_angle = To<SVGAngle>(other);
 
   // Only respect by animations, if from and by are both specified in angles
@@ -364,10 +364,10 @@ void SVGAngle::CalculateAnimatedValue(
     const SMILAnimationEffectParameters& parameters,
     float percentage,
     unsigned repeat_count,
-    SVGPropertyBase* from,
-    SVGPropertyBase* to,
-    SVGPropertyBase* to_at_end_of_duration,
-    SVGElement*) {
+    const SVGPropertyBase* from,
+    const SVGPropertyBase* to,
+    const SVGPropertyBase* to_at_end_of_duration,
+    const SVGElement*) {
   auto* from_angle = To<SVGAngle>(from);
   auto* to_angle = To<SVGAngle>(to);
 
@@ -387,7 +387,8 @@ void SVGAngle::CalculateAnimatedValue(
   SetValue(animated_value);
 }
 
-float SVGAngle::CalculateDistance(SVGPropertyBase* other, SVGElement*) {
+float SVGAngle::CalculateDistance(const SVGPropertyBase* other,
+                                  const SVGElement*) const {
   return fabsf(Value() - To<SVGAngle>(other)->Value());
 }
 

third_party/blink/renderer/core/svg/svg_angle.h

@@ -91,16 +91,17 @@ class SVGAngle final : public SVGPropertyHelper<SVGAngle> {
   String ValueAsString() const override;
   SVGParsingError SetValueAsString(const String&);
 
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from,
-                              SVGPropertyBase* to,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement* context_element) override;
-  float CalculateDistance(SVGPropertyBase* to,
-                          SVGElement* context_element) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from,
+      const SVGPropertyBase* to,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement* context_element) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement* context_element) const override;
 
   static AnimatedPropertyType ClassType() { return kAnimatedAngle; }
 

third_party/blink/renderer/core/svg/svg_animated_color.cc

@@ -48,7 +48,8 @@ SVGPropertyBase* SVGColorProperty::CloneForAnimation(const String&) const {
   return nullptr;
 }
 
-static inline Color FallbackColorForCurrentColor(SVGElement* target_element) {
+static inline Color FallbackColorForCurrentColor(
+    const SVGElement* target_element) {
   DCHECK(target_element);
   if (const ComputedStyle* target_style = target_element->GetComputedStyle())
     return target_style->VisitedDependentColor(GetCSSPropertyColor());
@@ -56,15 +57,15 @@ static inline Color FallbackColorForCurrentColor(SVGElement* target_element) {
 }
 
 static inline WebColorScheme ColorSchemeForSVGElement(
-    SVGElement* target_element) {
+    const SVGElement* target_element) {
   DCHECK(target_element);
   if (const ComputedStyle* target_style = target_element->GetComputedStyle())
     return target_style->UsedColorScheme();
   return WebColorScheme::kLight;
 }
 
-void SVGColorProperty::Add(SVGPropertyBase* other,
-                           SVGElement* context_element) {
+void SVGColorProperty::Add(const SVGPropertyBase* other,
+                           const SVGElement* context_element) {
   DCHECK(context_element);
 
   Color fallback_color = FallbackColorForCurrentColor(context_element);
@@ -79,10 +80,10 @@ void SVGColorProperty::CalculateAnimatedValue(
     const SMILAnimationEffectParameters& parameters,
     float percentage,
     unsigned repeat_count,
-    SVGPropertyBase* from_value,
-    SVGPropertyBase* to_value,
-    SVGPropertyBase* to_at_end_of_duration_value,
-    SVGElement* context_element) {
+    const SVGPropertyBase* from_value,
+    const SVGPropertyBase* to_value,
+    const SVGPropertyBase* to_at_end_of_duration_value,
+    const SVGElement* context_element) {
   StyleColor from_style_color = To<SVGColorProperty>(from_value)->style_color_;
   StyleColor to_style_color = To<SVGColorProperty>(to_value)->style_color_;
   StyleColor to_at_end_of_duration_style_color =
@@ -123,8 +124,9 @@ void SVGColorProperty::CalculateAnimatedValue(
                           roundf(animated_blue), roundf(animated_alpha)));
 }
 
-float SVGColorProperty::CalculateDistance(SVGPropertyBase* to_value,
-                                          SVGElement* context_element) {
+float SVGColorProperty::CalculateDistance(
+    const SVGPropertyBase* to_value,
+    const SVGElement* context_element) const {
   DCHECK(context_element);
   Color fallback_color = FallbackColorForCurrentColor(context_element);
   WebColorScheme color_scheme = ColorSchemeForSVGElement(context_element);

third_party/blink/renderer/core/svg/svg_animated_color.h

@@ -47,15 +47,17 @@ class SVGColorProperty final : public SVGPropertyBase {
   SVGPropertyBase* CloneForAnimation(const String&) const override;
   String ValueAsString() const override;
 
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from,
-                              SVGPropertyBase* to,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement*) override;
-  float CalculateDistance(SVGPropertyBase* to, SVGElement*) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from,
+      const SVGPropertyBase* to,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement*) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement*) const override;
 
   static AnimatedPropertyType ClassType() { return kAnimatedColor; }
   AnimatedPropertyType GetType() const override { return ClassType(); }

third_party/blink/renderer/core/svg/svg_boolean.cc

@@ -48,21 +48,22 @@ SVGParsingError SVGBoolean::SetValueAsString(const String& value) {
   return SVGParseStatus::kExpectedBoolean;
 }
 
-void SVGBoolean::Add(SVGPropertyBase*, SVGElement*) {
+void SVGBoolean::Add(const SVGPropertyBase*, const SVGElement*) {
   NOTREACHED();
 }
 
 void SVGBoolean::CalculateAnimatedValue(const SMILAnimationEffectParameters&,
                                         float percentage,
                                         unsigned repeat_count,
-                                        SVGPropertyBase* from,
-                                        SVGPropertyBase* to,
-                                        SVGPropertyBase*,
-                                        SVGElement*) {
+                                        const SVGPropertyBase* from,
+                                        const SVGPropertyBase* to,
+                                        const SVGPropertyBase*,
+                                        const SVGElement*) {
   NOTREACHED();
 }
 
-float SVGBoolean::CalculateDistance(SVGPropertyBase*, SVGElement*) {
+float SVGBoolean::CalculateDistance(const SVGPropertyBase*,
+                                    const SVGElement*) const {
   // No paced animations for boolean.
   return -1;
 }

third_party/blink/renderer/core/svg/svg_boolean.h

@@ -50,15 +50,17 @@ class SVGBoolean final : public SVGPropertyHelper<SVGBoolean> {
   String ValueAsString() const override;
   SVGParsingError SetValueAsString(const String&);
 
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from,
-                              SVGPropertyBase* to,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement*) override;
-  float CalculateDistance(SVGPropertyBase* to, SVGElement*) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from,
+      const SVGPropertyBase* to,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement*) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement*) const override;
 
   bool Value() const { return value_; }
   void SetValue(bool value) { value_ = value; }

third_party/blink/renderer/core/svg/svg_enumeration.cc

@@ -71,7 +71,7 @@ uint16_t SVGEnumeration::MaxInternalEnumValue() const {
   return map_.ValueOfLast();
 }
 
-void SVGEnumeration::Add(SVGPropertyBase*, SVGElement*) {
+void SVGEnumeration::Add(const SVGPropertyBase*, const SVGElement*) {
   NOTREACHED();
 }
 
@@ -79,14 +79,15 @@ void SVGEnumeration::CalculateAnimatedValue(
     const SMILAnimationEffectParameters&,
     float percentage,
     unsigned repeat_count,
-    SVGPropertyBase* from,
-    SVGPropertyBase* to,
-    SVGPropertyBase*,
-    SVGElement*) {
+    const SVGPropertyBase* from,
+    const SVGPropertyBase* to,
+    const SVGPropertyBase*,
+    const SVGElement*) {
   NOTREACHED();
 }
 
-float SVGEnumeration::CalculateDistance(SVGPropertyBase*, SVGElement*) {
+float SVGEnumeration::CalculateDistance(const SVGPropertyBase*,
+                                        const SVGElement*) const {
   // No paced animations for enumerations.
   return -1;
 }

third_party/blink/renderer/core/svg/svg_enumeration.h

@@ -80,15 +80,17 @@ class SVGEnumeration : public SVGPropertyBase {
   String ValueAsString() const override;
   SVGParsingError SetValueAsString(const String&);
 
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from,
-                              SVGPropertyBase* to,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement*) override;
-  float CalculateDistance(SVGPropertyBase* to, SVGElement*) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from,
+      const SVGPropertyBase* to,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement*) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement*) const override;
 
   static AnimatedPropertyType ClassType() { return kAnimatedEnumeration; }
   AnimatedPropertyType GetType() const override { return ClassType(); }

third_party/blink/renderer/core/svg/svg_integer.cc

@@ -58,7 +58,7 @@ SVGParsingError SVGInteger::SetValueAsString(const String& string) {
   return valid ? SVGParseStatus::kNoError : SVGParseStatus::kExpectedInteger;
 }
 
-void SVGInteger::Add(SVGPropertyBase* other, SVGElement*) {
+void SVGInteger::Add(const SVGPropertyBase* other, const SVGElement*) {
   SetValue(value_ + To<SVGInteger>(other)->Value());
 }
 
@@ -66,10 +66,10 @@ void SVGInteger::CalculateAnimatedValue(
     const SMILAnimationEffectParameters& parameters,
     float percentage,
     unsigned repeat_count,
-    SVGPropertyBase* from,
-    SVGPropertyBase* to,
-    SVGPropertyBase* to_at_end_of_duration,
-    SVGElement*) {
+    const SVGPropertyBase* from,
+    const SVGPropertyBase* to,
+    const SVGPropertyBase* to_at_end_of_duration,
+    const SVGElement*) {
   auto* from_integer = To<SVGInteger>(from);
   auto* to_integer = To<SVGInteger>(to);
   auto* to_at_end_of_duration_integer = To<SVGInteger>(to_at_end_of_duration);
@@ -81,7 +81,8 @@ void SVGInteger::CalculateAnimatedValue(
   value_ = clampTo<int>(roundf(animated_float));
 }
 
-float SVGInteger::CalculateDistance(SVGPropertyBase* other, SVGElement*) {
+float SVGInteger::CalculateDistance(const SVGPropertyBase* other,
+                                    const SVGElement*) const {
   return abs(value_ - To<SVGInteger>(other)->Value());
 }
 

third_party/blink/renderer/core/svg/svg_integer.h

@@ -52,16 +52,17 @@ class SVGInteger final : public SVGPropertyHelper<SVGInteger> {
   String ValueAsString() const override;
   SVGParsingError SetValueAsString(const String&);
 
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from,
-                              SVGPropertyBase* to,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement* context_element) override;
-  float CalculateDistance(SVGPropertyBase* to,
-                          SVGElement* context_element) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from,
+      const SVGPropertyBase* to,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement* context_element) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement* context_element) const override;
 
   static AnimatedPropertyType ClassType() { return kAnimatedInteger; }
 

third_party/blink/renderer/core/svg/svg_integer_optional_integer.cc

@@ -87,8 +87,8 @@ void SVGIntegerOptionalInteger::SetInitial(unsigned value) {
   second_integer_->SetInitial(value);
 }
 
-void SVGIntegerOptionalInteger::Add(SVGPropertyBase* other,
-                                    SVGElement* context_element) {
+void SVGIntegerOptionalInteger::Add(const SVGPropertyBase* other,
+                                    const SVGElement* context_element) {
   auto* other_integer_optional_integer = To<SVGIntegerOptionalInteger>(other);
   first_integer_->Add(other_integer_optional_integer->FirstInteger(),
                       context_element);
@@ -100,10 +100,10 @@ void SVGIntegerOptionalInteger::CalculateAnimatedValue(
     const SMILAnimationEffectParameters& parameters,
     float percentage,
     unsigned repeat_count,
-    SVGPropertyBase* from,
-    SVGPropertyBase* to,
-    SVGPropertyBase* to_at_end_of_duration,
-    SVGElement* context_element) {
+    const SVGPropertyBase* from,
+    const SVGPropertyBase* to,
+    const SVGPropertyBase* to_at_end_of_duration,
+    const SVGElement* context_element) {
   auto* from_integer = To<SVGIntegerOptionalInteger>(from);
   auto* to_integer = To<SVGIntegerOptionalInteger>(to);
   auto* to_at_end_of_duration_integer =
@@ -119,8 +119,8 @@ void SVGIntegerOptionalInteger::CalculateAnimatedValue(
       to_at_end_of_duration_integer->SecondInteger(), context_element);
 }
 
-float SVGIntegerOptionalInteger::CalculateDistance(SVGPropertyBase* other,
-                                                   SVGElement*) {
+float SVGIntegerOptionalInteger::CalculateDistance(const SVGPropertyBase* other,
+                                                   const SVGElement*) const {
   // FIXME: Distance calculation is not possible for SVGIntegerOptionalInteger
   // right now. We need the distance for every single value.
   return -1;

third_party/blink/renderer/core/svg/svg_integer_optional_integer.h

@@ -55,16 +55,17 @@ class SVGIntegerOptionalInteger final : public SVGPropertyBase {
   void SetInitial(unsigned);
   static constexpr int kInitialValueBits = SVGInteger::kInitialValueBits;
 
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from,
-                              SVGPropertyBase* to,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement* context_element) override;
-  float CalculateDistance(SVGPropertyBase* to,
-                          SVGElement* context_element) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from,
+      const SVGPropertyBase* to,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement* context_element) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement* context_element) const override;
 
   static AnimatedPropertyType ClassType() {
     return kAnimatedIntegerOptionalInteger;

third_party/blink/renderer/core/svg/svg_length.cc

@@ -312,7 +312,8 @@ bool SVGLength::NegativeValuesForbiddenForAnimatedLengthAttribute(
   return no_negative_values_set.Contains(attr_name);
 }
 
-void SVGLength::Add(SVGPropertyBase* other, SVGElement* context_element) {
+void SVGLength::Add(const SVGPropertyBase* other,
+                    const SVGElement* context_element) {
   SVGLengthContext length_context(context_element);
   SetValue(Value(length_context) + To<SVGLength>(other)->Value(length_context),
            length_context);
@@ -322,10 +323,10 @@ void SVGLength::CalculateAnimatedValue(
     const SMILAnimationEffectParameters& parameters,
     float percentage,
     unsigned repeat_count,
-    SVGPropertyBase* from_value,
-    SVGPropertyBase* to_value,
-    SVGPropertyBase* to_at_end_of_duration_value,
-    SVGElement* context_element) {
+    const SVGPropertyBase* from_value,
+    const SVGPropertyBase* to_value,
+    const SVGPropertyBase* to_at_end_of_duration_value,
+    const SVGElement* context_element) {
   auto* from_length = To<SVGLength>(from_value);
   auto* to_length = To<SVGLength>(to_value);
   auto* to_at_end_of_duration_length =
@@ -356,8 +357,8 @@ void SVGLength::CalculateAnimatedValue(
   value_ = CSSNumericLiteralValue::Create(animated_number, new_unit);
 }
 
-float SVGLength::CalculateDistance(SVGPropertyBase* to_value,
-                                   SVGElement* context_element) {
+float SVGLength::CalculateDistance(const SVGPropertyBase* to_value,
+                                   const SVGElement* context_element) const {
   SVGLengthContext length_context(context_element);
   auto* to_length = To<SVGLength>(to_value);
 

third_party/blink/renderer/core/svg/svg_length.h

@@ -126,16 +126,17 @@ class CORE_EXPORT SVGLength final : public SVGPropertyBase {
   static bool NegativeValuesForbiddenForAnimatedLengthAttribute(
       const QualifiedName&);
 
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from,
-                              SVGPropertyBase* to,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement* context_element) override;
-  float CalculateDistance(SVGPropertyBase* to,
-                          SVGElement* context_element) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from,
+      const SVGPropertyBase* to,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement* context_element) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement* context_element) const override;
 
   static AnimatedPropertyType ClassType() { return kAnimatedLength; }
   AnimatedPropertyType GetType() const override { return ClassType(); }

third_party/blink/renderer/core/svg/svg_length_list.cc

@@ -79,7 +79,8 @@ SVGParsingError SVGLengthList::SetValueAsString(const String& value) {
   });
 }
 
-void SVGLengthList::Add(SVGPropertyBase* other, SVGElement* context_element) {
+void SVGLengthList::Add(const SVGPropertyBase* other,
+                        const SVGElement* context_element) {
   auto* other_list = To<SVGLengthList>(other);
   if (length() != other_list->length())
     return;
@@ -95,10 +96,10 @@ void SVGLengthList::CalculateAnimatedValue(
     const SMILAnimationEffectParameters& parameters,
     float percentage,
     unsigned repeat_count,
-    SVGPropertyBase* from_value,
-    SVGPropertyBase* to_value,
-    SVGPropertyBase* to_at_end_of_duration_value,
-    SVGElement* context_element) {
+    const SVGPropertyBase* from_value,
+    const SVGPropertyBase* to_value,
+    const SVGPropertyBase* to_at_end_of_duration_value,
+    const SVGElement* context_element) {
   auto* from_list = To<SVGLengthList>(from_value);
   auto* to_list = To<SVGLengthList>(to_value);
 
@@ -115,18 +116,20 @@ void SVGLengthList::CalculateAnimatedValue(
 
   const bool needs_neutral_element =
       !from_list_size || to_list_size != to_at_end_of_duration_list_size;
-  SVGLength* neutral = needs_neutral_element ? CreatePaddingItem() : nullptr;
+  const SVGLength* neutral =
+      needs_neutral_element ? CreatePaddingItem() : nullptr;
   for (uint32_t i = 0; i < to_list_size; ++i) {
-    SVGLength* from = from_list_size ? from_list->at(i) : neutral;
-    SVGLength* to_at_end = i < to_at_end_of_duration_list_size
-                               ? to_at_end_of_duration_list->at(i)
-                               : neutral;
+    const SVGLength* from = from_list_size ? from_list->at(i) : neutral;
+    const SVGLength* to_at_end = i < to_at_end_of_duration_list_size
+                                     ? to_at_end_of_duration_list->at(i)
+                                     : neutral;
     at(i)->CalculateAnimatedValue(parameters, percentage, repeat_count, from,
                                   to_list->at(i), to_at_end, context_element);
   }
 }
 
-float SVGLengthList::CalculateDistance(SVGPropertyBase* to, SVGElement*) {
+float SVGLengthList::CalculateDistance(const SVGPropertyBase* to,
+                                       const SVGElement*) const {
   // FIXME: Distance calculation is not possible for SVGLengthList right now. We
   // need the distance for every single value.
   return -1;

third_party/blink/renderer/core/svg/svg_length_list.h

@@ -55,15 +55,17 @@ class SVGLengthList final
   SVGLengthList* Clone() override;
   SVGLengthMode UnitMode() const { return mode_; }
 
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from_value,
-                              SVGPropertyBase* to_value,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement*) override;
-  float CalculateDistance(SVGPropertyBase* to, SVGElement*) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from_value,
+      const SVGPropertyBase* to_value,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement*) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement*) const override;
 
   static AnimatedPropertyType ClassType() { return kAnimatedLengthList; }
 

third_party/blink/renderer/core/svg/svg_number.cc

@@ -70,7 +70,7 @@ SVGParsingError SVGNumber::SetValueAsString(const String& string) {
   });
 }
 
-void SVGNumber::Add(SVGPropertyBase* other, SVGElement*) {
+void SVGNumber::Add(const SVGPropertyBase* other, const SVGElement*) {
   SetValue(value_ + To<SVGNumber>(other)->Value());
 }
 
@@ -78,10 +78,10 @@ void SVGNumber::CalculateAnimatedValue(
     const SMILAnimationEffectParameters& parameters,
     float percentage,
     unsigned repeat_count,
-    SVGPropertyBase* from,
-    SVGPropertyBase* to,
-    SVGPropertyBase* to_at_end_of_duration,
-    SVGElement*) {
+    const SVGPropertyBase* from,
+    const SVGPropertyBase* to,
+    const SVGPropertyBase* to_at_end_of_duration,
+    const SVGElement*) {
   auto* from_number = To<SVGNumber>(from);
   auto* to_number = To<SVGNumber>(to);
   auto* to_at_end_of_duration_number = To<SVGNumber>(to_at_end_of_duration);
@@ -91,7 +91,8 @@ void SVGNumber::CalculateAnimatedValue(
                         to_at_end_of_duration_number->Value(), value_);
 }
 
-float SVGNumber::CalculateDistance(SVGPropertyBase* other, SVGElement*) {
+float SVGNumber::CalculateDistance(const SVGPropertyBase* other,
+                                   const SVGElement*) const {
   return fabsf(value_ - To<SVGNumber>(other)->Value());
 }
 

third_party/blink/renderer/core/svg/svg_number.h

@@ -55,16 +55,17 @@ class SVGNumber : public SVGPropertyHelper<SVGNumber> {
   String ValueAsString() const override;
   virtual SVGParsingError SetValueAsString(const String&);
 
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from,
-                              SVGPropertyBase* to,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement* context_element) override;
-  float CalculateDistance(SVGPropertyBase* to,
-                          SVGElement* context_element) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from,
+      const SVGPropertyBase* to,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement* context_element) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement* context_element) const override;
 
   static AnimatedPropertyType ClassType() { return kAnimatedNumber; }
 

third_party/blink/renderer/core/svg/svg_number_list.cc

@@ -58,7 +58,8 @@ SVGParsingError SVGNumberList::SetValueAsString(const String& value) {
   });
 }
 
-void SVGNumberList::Add(SVGPropertyBase* other, SVGElement* context_element) {
+void SVGNumberList::Add(const SVGPropertyBase* other,
+                        const SVGElement* context_element) {
   auto* other_list = To<SVGNumberList>(other);
   if (length() != other_list->length())
     return;
@@ -70,10 +71,10 @@ void SVGNumberList::CalculateAnimatedValue(
     const SMILAnimationEffectParameters& parameters,
     float percentage,
     unsigned repeat_count,
-    SVGPropertyBase* from_value,
-    SVGPropertyBase* to_value,
-    SVGPropertyBase* to_at_end_of_duration_value,
-    SVGElement* context_element) {
+    const SVGPropertyBase* from_value,
+    const SVGPropertyBase* to_value,
+    const SVGPropertyBase* to_at_end_of_duration_value,
+    const SVGElement* context_element) {
   auto* from_list = To<SVGNumberList>(from_value);
   auto* to_list = To<SVGNumberList>(to_value);
 
@@ -90,18 +91,20 @@ void SVGNumberList::CalculateAnimatedValue(
 
   const bool needs_neutral_element =
       !from_list_size || to_list_size != to_at_end_of_duration_list_size;
-  SVGNumber* neutral = needs_neutral_element ? CreatePaddingItem() : nullptr;
+  const SVGNumber* neutral =
+      needs_neutral_element ? CreatePaddingItem() : nullptr;
   for (uint32_t i = 0; i < to_list_size; ++i) {
-    SVGNumber* from = from_list_size ? from_list->at(i) : neutral;
-    SVGNumber* to_at_end = i < to_at_end_of_duration_list_size
-                               ? to_at_end_of_duration_list->at(i)
-                               : neutral;
+    const SVGNumber* from = from_list_size ? from_list->at(i) : neutral;
+    const SVGNumber* to_at_end = i < to_at_end_of_duration_list_size
+                                     ? to_at_end_of_duration_list->at(i)
+                                     : neutral;
     at(i)->CalculateAnimatedValue(parameters, percentage, repeat_count, from,
                                   to_list->at(i), to_at_end, context_element);
   }
 }
 
-float SVGNumberList::CalculateDistance(SVGPropertyBase* to, SVGElement*) {
+float SVGNumberList::CalculateDistance(const SVGPropertyBase* to,
+                                       const SVGElement*) const {
   // FIXME: Distance calculation is not possible for SVGNumberList right now. We
   // need the distance for every single value.
   return -1;

third_party/blink/renderer/core/svg/svg_number_list.h

@@ -51,15 +51,17 @@ class SVGNumberList final
   SVGParsingError SetValueAsString(const String&);
 
   // SVGPropertyBase:
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from_value,
-                              SVGPropertyBase* to_value,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement*) override;
-  float CalculateDistance(SVGPropertyBase* to, SVGElement*) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from_value,
+      const SVGPropertyBase* to_value,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement*) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement*) const override;
 
   static AnimatedPropertyType ClassType() { return kAnimatedNumberList; }
 

third_party/blink/renderer/core/svg/svg_number_optional_number.cc

@@ -89,8 +89,8 @@ void SVGNumberOptionalNumber::SetInitial(unsigned value) {
   second_number_->SetInitial(value);
 }
 
-void SVGNumberOptionalNumber::Add(SVGPropertyBase* other,
-                                  SVGElement* context_element) {
+void SVGNumberOptionalNumber::Add(const SVGPropertyBase* other,
+                                  const SVGElement* context_element) {
   auto* other_number_optional_number = To<SVGNumberOptionalNumber>(other);
   first_number_->Add(other_number_optional_number->FirstNumber(),
                      context_element);
@@ -102,10 +102,10 @@ void SVGNumberOptionalNumber::CalculateAnimatedValue(
     const SMILAnimationEffectParameters& parameters,
     float percentage,
     unsigned repeat_count,
-    SVGPropertyBase* from,
-    SVGPropertyBase* to,
-    SVGPropertyBase* to_at_end_of_duration,
-    SVGElement* context_element) {
+    const SVGPropertyBase* from,
+    const SVGPropertyBase* to,
+    const SVGPropertyBase* to_at_end_of_duration,
+    const SVGElement* context_element) {
   auto* from_number = To<SVGNumberOptionalNumber>(from);
   auto* to_number = To<SVGNumberOptionalNumber>(to);
   auto* to_at_end_of_duration_number =
@@ -121,8 +121,8 @@ void SVGNumberOptionalNumber::CalculateAnimatedValue(
       context_element);
 }
 
-float SVGNumberOptionalNumber::CalculateDistance(SVGPropertyBase* other,
-                                                 SVGElement*) {
+float SVGNumberOptionalNumber::CalculateDistance(const SVGPropertyBase* other,
+                                                 const SVGElement*) const {
   // FIXME: Distance calculation is not possible for SVGNumberOptionalNumber
   // right now. We need the distance for every single value.
   return -1;

third_party/blink/renderer/core/svg/svg_number_optional_number.h

@@ -54,16 +54,17 @@ class SVGNumberOptionalNumber final : public SVGPropertyBase {
   void SetInitial(unsigned);
   static constexpr int kInitialValueBits = SVGNumber::kInitialValueBits;
 
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from,
-                              SVGPropertyBase* to,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement* context_element) override;
-  float CalculateDistance(SVGPropertyBase* to,
-                          SVGElement* context_element) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from,
+      const SVGPropertyBase* to,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement* context_element) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement* context_element) const override;
 
   static AnimatedPropertyType ClassType() {
     return kAnimatedNumberOptionalNumber;

third_party/blink/renderer/core/svg/svg_path.cc

@@ -113,7 +113,7 @@ SVGPropertyBase* SVGPath::CloneForAnimation(const String& value) const {
       MakeGarbageCollected<CSSPathValue>(std::move(byte_stream)));
 }
 
-void SVGPath::Add(SVGPropertyBase* other, SVGElement*) {
+void SVGPath::Add(const SVGPropertyBase* other, const SVGElement*) {
   const auto& other_path_byte_stream = To<SVGPath>(other)->ByteStream();
   if (ByteStream().size() != other_path_byte_stream.size() ||
       ByteStream().IsEmpty() || other_path_byte_stream.IsEmpty())
@@ -127,10 +127,10 @@ void SVGPath::CalculateAnimatedValue(
     const SMILAnimationEffectParameters& parameters,
     float percentage,
     unsigned repeat_count,
-    SVGPropertyBase* from_value,
-    SVGPropertyBase* to_value,
-    SVGPropertyBase* to_at_end_of_duration_value,
-    SVGElement*) {
+    const SVGPropertyBase* from_value,
+    const SVGPropertyBase* to_value,
+    const SVGPropertyBase* to_at_end_of_duration_value,
+    const SVGElement*) {
   const auto& to = To<SVGPath>(*to_value);
   const SVGPathByteStream& to_stream = to.ByteStream();
 
@@ -175,7 +175,8 @@ void SVGPath::CalculateAnimatedValue(
   path_value_ = MakeGarbageCollected<CSSPathValue>(std::move(new_stream));
 }
 
-float SVGPath::CalculateDistance(SVGPropertyBase* to, SVGElement*) {
+float SVGPath::CalculateDistance(const SVGPropertyBase* to,
+                                 const SVGElement*) const {
   // FIXME: Support paced animations.
   return -1;
 }

third_party/blink/renderer/core/svg/svg_path.h

@@ -59,15 +59,17 @@ class SVGPath final : public SVGPropertyBase {
   String ValueAsString() const override;
   SVGParsingError SetValueAsString(const String&);
 
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from_value,
-                              SVGPropertyBase* to_value,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement*) override;
-  float CalculateDistance(SVGPropertyBase* to, SVGElement*) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from_value,
+      const SVGPropertyBase* to_value,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement*) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement*) const override;
 
   static AnimatedPropertyType ClassType() { return kAnimatedPath; }
   AnimatedPropertyType GetType() const override { return ClassType(); }

third_party/blink/renderer/core/svg/svg_point.cc

@@ -89,7 +89,7 @@ String SVGPoint::ValueAsString() const {
   return builder.ToString();
 }
 
-void SVGPoint::Add(SVGPropertyBase* other, SVGElement*) {
+void SVGPoint::Add(const SVGPropertyBase* other, const SVGElement*) {
   // SVGPoint is not animated by itself
   NOTREACHED();
 }
@@ -98,16 +98,16 @@ void SVGPoint::CalculateAnimatedValue(
     const SMILAnimationEffectParameters&,
     float percentage,
     unsigned repeat_count,
-    SVGPropertyBase* from_value,
-    SVGPropertyBase* to_value,
-    SVGPropertyBase* to_at_end_of_duration_value,
-    SVGElement*) {
+    const SVGPropertyBase* from_value,
+    const SVGPropertyBase* to_value,
+    const SVGPropertyBase* to_at_end_of_duration_value,
+    const SVGElement*) {
   // SVGPoint is not animated by itself
   NOTREACHED();
 }
 
-float SVGPoint::CalculateDistance(SVGPropertyBase* to,
-                                  SVGElement* context_element) {
+float SVGPoint::CalculateDistance(const SVGPropertyBase* to,
+                                  const SVGElement* context_element) const {
   // SVGPoint is not animated by itself
   NOTREACHED();
   return 0.0f;

third_party/blink/renderer/core/svg/svg_point.h

@@ -63,16 +63,17 @@ class SVGPoint final : public SVGPropertyHelper<SVGPoint> {
   String ValueAsString() const override;
   SVGParsingError SetValueAsString(const String&);
 
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from,
-                              SVGPropertyBase* to,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement* context_element) override;
-  float CalculateDistance(SVGPropertyBase* to,
-                          SVGElement* context_element) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from,
+      const SVGPropertyBase* to,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement* context_element) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement* context_element) const override;
 
   static AnimatedPropertyType ClassType() { return kAnimatedPoint; }
 

third_party/blink/renderer/core/svg/svg_point_list.cc

@@ -73,7 +73,8 @@ SVGParsingError SVGPointList::SetValueAsString(const String& value) {
   });
 }
 
-void SVGPointList::Add(SVGPropertyBase* other, SVGElement* context_element) {
+void SVGPointList::Add(const SVGPropertyBase* other,
+                       const SVGElement* context_element) {
   auto* other_list = To<SVGPointList>(other);
 
   if (length() != other_list->length())
@@ -87,10 +88,10 @@ void SVGPointList::CalculateAnimatedValue(
     const SMILAnimationEffectParameters& parameters,
     float percentage,
     unsigned repeat_count,
-    SVGPropertyBase* from_value,
-    SVGPropertyBase* to_value,
-    SVGPropertyBase* to_at_end_of_duration_value,
-    SVGElement* context_element) {
+    const SVGPropertyBase* from_value,
+    const SVGPropertyBase* to_value,
+    const SVGPropertyBase* to_at_end_of_duration_value,
+    const SVGElement* context_element) {
   auto* from_list = To<SVGPointList>(from_value);
   auto* to_list = To<SVGPointList>(to_value);
   auto* to_at_end_of_duration_list =
@@ -126,7 +127,8 @@ void SVGPointList::CalculateAnimatedValue(
   }
 }
 
-float SVGPointList::CalculateDistance(SVGPropertyBase* to, SVGElement*) {
+float SVGPointList::CalculateDistance(const SVGPropertyBase* to,
+                                      const SVGElement*) const {
   // FIXME: Distance calculation is not possible for SVGPointList right now. We
   // need the distance for every single value.
   return -1;

third_party/blink/renderer/core/svg/svg_point_list.h

@@ -51,15 +51,17 @@ class SVGPointList final
   SVGParsingError SetValueAsString(const String&);
 
   // SVGPropertyBase:
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from_value,
-                              SVGPropertyBase* to_value,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement*) override;
-  float CalculateDistance(SVGPropertyBase* to, SVGElement*) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from_value,
+      const SVGPropertyBase* to_value,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement*) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement*) const override;
 
   static AnimatedPropertyType ClassType() { return kAnimatedPoints; }
 

third_party/blink/renderer/core/svg/svg_preserve_aspect_ratio.cc

@@ -430,7 +430,8 @@ String SVGPreserveAspectRatio::ValueAsString() const {
   return builder.ToString();
 }
 
-void SVGPreserveAspectRatio::Add(SVGPropertyBase* other, SVGElement*) {
+void SVGPreserveAspectRatio::Add(const SVGPropertyBase* other,
+                                 const SVGElement*) {
   NOTREACHED();
 }
 
@@ -438,15 +439,16 @@ void SVGPreserveAspectRatio::CalculateAnimatedValue(
     const SMILAnimationEffectParameters&,
     float percentage,
     unsigned repeat_count,
-    SVGPropertyBase* from_value,
-    SVGPropertyBase* to_value,
-    SVGPropertyBase*,
-    SVGElement*) {
+    const SVGPropertyBase* from_value,
+    const SVGPropertyBase* to_value,
+    const SVGPropertyBase*,
+    const SVGElement*) {
   NOTREACHED();
 }
 
-float SVGPreserveAspectRatio::CalculateDistance(SVGPropertyBase* to_value,
-                                                SVGElement* context_element) {
+float SVGPreserveAspectRatio::CalculateDistance(
+    const SVGPropertyBase* to_value,
+    const SVGElement* context_element) const {
   // No paced animations for SVGPreserveAspectRatio.
   return -1;
 }

third_party/blink/renderer/core/svg/svg_preserve_aspect_ratio.h

@@ -86,16 +86,17 @@ class SVGPreserveAspectRatio final
   bool Parse(const UChar*& ptr, const UChar* end, bool validate);
   bool Parse(const LChar*& ptr, const LChar* end, bool validate);
 
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from,
-                              SVGPropertyBase* to,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement* context_element) override;
-  float CalculateDistance(SVGPropertyBase* to,
-                          SVGElement* context_element) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from,
+      const SVGPropertyBase* to,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement* context_element) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement* context_element) const override;
 
   static AnimatedPropertyType ClassType() {
     return kAnimatedPreserveAspectRatio;

third_party/blink/renderer/core/svg/svg_rect.cc

@@ -86,7 +86,7 @@ String SVGRect::ValueAsString() const {
   return builder.ToString();
 }
 
-void SVGRect::Add(SVGPropertyBase* other, SVGElement*) {
+void SVGRect::Add(const SVGPropertyBase* other, const SVGElement*) {
   value_ += To<SVGRect>(other)->Value();
 }
 
@@ -94,10 +94,10 @@ void SVGRect::CalculateAnimatedValue(
     const SMILAnimationEffectParameters& parameters,
     float percentage,
     unsigned repeat_count,
-    SVGPropertyBase* from_value,
-    SVGPropertyBase* to_value,
-    SVGPropertyBase* to_at_end_of_duration_value,
-    SVGElement*) {
+    const SVGPropertyBase* from_value,
+    const SVGPropertyBase* to_value,
+    const SVGPropertyBase* to_at_end_of_duration_value,
+    const SVGElement*) {
   auto* from_rect = To<SVGRect>(from_value);
   auto* to_rect = To<SVGRect>(to_value);
   auto* to_at_end_of_duration_rect = To<SVGRect>(to_at_end_of_duration_value);
@@ -122,8 +122,8 @@ void SVGRect::CalculateAnimatedValue(
   value_ = FloatRect(animated_x, animated_y, animated_width, animated_height);
 }
 
-float SVGRect::CalculateDistance(SVGPropertyBase* to,
-                                 SVGElement* context_element) {
+float SVGRect::CalculateDistance(const SVGPropertyBase* to,
+                                 const SVGElement* context_element) const {
   // FIXME: Distance calculation is not possible for SVGRect right now. We need
   // the distance for every single value.
   return -1;

third_party/blink/renderer/core/svg/svg_rect.h

@@ -60,16 +60,17 @@ class SVGRect final : public SVGPropertyHelper<SVGRect> {
   String ValueAsString() const override;
   SVGParsingError SetValueAsString(const String&);
 
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from,
-                              SVGPropertyBase* to,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement* context_element) override;
-  float CalculateDistance(SVGPropertyBase* to,
-                          SVGElement* context_element) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from,
+      const SVGPropertyBase* to,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement* context_element) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement* context_element) const override;
 
   bool IsValid() const { return is_valid_; }
   void SetInvalid();

third_party/blink/renderer/core/svg/svg_string.cc

@@ -21,21 +21,22 @@
 
 namespace blink {
 
-void SVGString::Add(SVGPropertyBase*, SVGElement*) {
+void SVGString::Add(const SVGPropertyBase*, const SVGElement*) {
   NOTREACHED();
 }
 
 void SVGString::CalculateAnimatedValue(const SMILAnimationEffectParameters&,
                                        float percentage,
                                        unsigned repeat_count,
-                                       SVGPropertyBase* from,
-                                       SVGPropertyBase* to,
-                                       SVGPropertyBase*,
-                                       SVGElement*) {
+                                       const SVGPropertyBase* from,
+                                       const SVGPropertyBase* to,
+                                       const SVGPropertyBase*,
+                                       const SVGElement*) {
   NOTREACHED();
 }
 
-float SVGString::CalculateDistance(SVGPropertyBase*, SVGElement*) {
+float SVGString::CalculateDistance(const SVGPropertyBase*,
+                                   const SVGElement*) const {
   // No paced animations for strings.
   return -1;
 }

third_party/blink/renderer/core/svg/svg_string.h

@@ -57,15 +57,17 @@ class SVGString final : public SVGPropertyBase {
     return SVGParseStatus::kNoError;
   }
 
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from,
-                              SVGPropertyBase* to,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement*) override;
-  float CalculateDistance(SVGPropertyBase* to, SVGElement*) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from,
+      const SVGPropertyBase* to,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement*) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement*) const override;
 
   const String& Value() const { return value_; }
   void SetValue(const String& value) { value_ = value; }

third_party/blink/renderer/core/svg/svg_string_list.cc

@@ -100,8 +100,8 @@ String SVGStringListBase::ValueAsStringWithDelimiter(
   return builder.ToString();
 }
 
-void SVGStringListBase::Add(SVGPropertyBase* other,
-                            SVGElement* context_element) {
+void SVGStringListBase::Add(const SVGPropertyBase* other,
+                            const SVGElement* context_element) {
   // SVGStringList is never animated.
   NOTREACHED();
 }
@@ -110,15 +110,16 @@ void SVGStringListBase::CalculateAnimatedValue(
     const SMILAnimationEffectParameters&,
     float,
     unsigned,
-    SVGPropertyBase*,
-    SVGPropertyBase*,
-    SVGPropertyBase*,
-    SVGElement*) {
+    const SVGPropertyBase*,
+    const SVGPropertyBase*,
+    const SVGPropertyBase*,
+    const SVGElement*) {
   // SVGStringList is never animated.
   NOTREACHED();
 }
 
-float SVGStringListBase::CalculateDistance(SVGPropertyBase*, SVGElement*) {
+float SVGStringListBase::CalculateDistance(const SVGPropertyBase*,
+                                           const SVGElement*) const {
   // SVGStringList is never animated.
   NOTREACHED();
   return -1.0f;

third_party/blink/renderer/core/svg/svg_string_list.h

@@ -70,15 +70,17 @@ class SVGStringListBase : public SVGPropertyBase {
   virtual SVGParsingError SetValueAsString(const String&) = 0;
 
   // SVGPropertyBase:
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from_value,
-                              SVGPropertyBase* to_value,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement*) override;
-  float CalculateDistance(SVGPropertyBase* to, SVGElement*) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from_value,
+      const SVGPropertyBase* to_value,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement*) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement*) const override;
 
   static AnimatedPropertyType ClassType() { return kAnimatedStringList; }
 

third_party/blink/renderer/core/svg/svg_transform.cc

@@ -217,7 +217,7 @@ String SVGTransform::ValueAsString() const {
   return builder.ToString();
 }
 
-void SVGTransform::Add(SVGPropertyBase*, SVGElement*) {
+void SVGTransform::Add(const SVGPropertyBase*, const SVGElement*) {
   // SVGTransform is not animated by itself.
   NOTREACHED();
 }
@@ -225,15 +225,16 @@ void SVGTransform::Add(SVGPropertyBase*, SVGElement*) {
 void SVGTransform::CalculateAnimatedValue(const SMILAnimationEffectParameters&,
                                           float,
                                           unsigned,
-                                          SVGPropertyBase*,
-                                          SVGPropertyBase*,
-                                          SVGPropertyBase*,
-                                          SVGElement*) {
+                                          const SVGPropertyBase*,
+                                          const SVGPropertyBase*,
+                                          const SVGPropertyBase*,
+                                          const SVGElement*) {
   // SVGTransform is not animated by itself.
   NOTREACHED();
 }
 
-float SVGTransform::CalculateDistance(SVGPropertyBase*, SVGElement*) {
+float SVGTransform::CalculateDistance(const SVGPropertyBase*,
+                                      const SVGElement*) const {
   // SVGTransform is not animated by itself.
   NOTREACHED();
 

third_party/blink/renderer/core/svg/svg_transform.h

@@ -88,16 +88,17 @@ class SVGTransform final : public SVGPropertyBase {
 
   String ValueAsString() const override;
 
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from,
-                              SVGPropertyBase* to,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement* context_element) override;
-  float CalculateDistance(SVGPropertyBase* to,
-                          SVGElement* context_element) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from,
+      const SVGPropertyBase* to,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement* context_element) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement* context_element) const override;
 
   static AnimatedPropertyType ClassType() { return kAnimatedTransform; }
   AnimatedPropertyType GetType() const override { return ClassType(); }

third_party/blink/renderer/core/svg/svg_transform_distance.cc

@@ -41,8 +41,9 @@ SVGTransformDistance::SVGTransformDistance(SVGTransformType transform_type,
       cy_(cy),
       transform_(transform) {}
 
-SVGTransformDistance::SVGTransformDistance(SVGTransform* from_svg_transform,
-                                           SVGTransform* to_svg_transform)
+SVGTransformDistance::SVGTransformDistance(
+    const SVGTransform* from_svg_transform,
+    const SVGTransform* to_svg_transform)
     : angle_(0), cx_(0), cy_(0) {
   transform_type_ = from_svg_transform->TransformType();
   DCHECK_EQ(transform_type_, to_svg_transform->TransformType());
@@ -116,8 +117,8 @@ SVGTransformDistance SVGTransformDistance::ScaledDistance(
   return SVGTransformDistance();
 }
 
-SVGTransform* SVGTransformDistance::AddSVGTransforms(SVGTransform* first,
-                                                     SVGTransform* second,
+SVGTransform* SVGTransformDistance::AddSVGTransforms(const SVGTransform* first,
+                                                     const SVGTransform* second,
                                                      unsigned repeat_count) {
   DCHECK_EQ(first->TransformType(), second->TransformType());
 
@@ -164,7 +165,7 @@ SVGTransform* SVGTransformDistance::AddSVGTransforms(SVGTransform* first,
 }
 
 SVGTransform* SVGTransformDistance::AddToSVGTransform(
-    SVGTransform* transform) const {
+    const SVGTransform* transform) const {
   DCHECK(transform_type_ == transform->TransformType() ||
          transform_type_ == SVGTransformType::kUnknown);
 

third_party/blink/renderer/core/svg/svg_transform_distance.h

@@ -32,14 +32,14 @@ class SVGTransformDistance {
 
  public:
   SVGTransformDistance();
-  SVGTransformDistance(SVGTransform* from_transform,
-                       SVGTransform* to_transform);
+  SVGTransformDistance(const SVGTransform* from_transform,
+                       const SVGTransform* to_transform);
 
   SVGTransformDistance ScaledDistance(float scale_factor) const;
-  SVGTransform* AddToSVGTransform(SVGTransform*) const;
+  SVGTransform* AddToSVGTransform(const SVGTransform*) const;
 
-  static SVGTransform* AddSVGTransforms(SVGTransform*,
-                                        SVGTransform*,
+  static SVGTransform* AddSVGTransforms(const SVGTransform*,
+                                        const SVGTransform*,
                                         unsigned repeat_count = 1);
 
   float Distance() const;

third_party/blink/renderer/core/svg/svg_transform_list.cc

@@ -391,8 +391,8 @@ SVGPropertyBase* SVGTransformList::CloneForAnimation(
   return SVGListPropertyHelper::CloneForAnimation(value);
 }
 
-void SVGTransformList::Add(SVGPropertyBase* other,
-                           SVGElement* context_element) {
+void SVGTransformList::Add(const SVGPropertyBase* other,
+                           const SVGElement* context_element) {
   if (IsEmpty())
     return;
 
@@ -401,8 +401,8 @@ void SVGTransformList::Add(SVGPropertyBase* other,
     return;
 
   DCHECK_EQ(length(), 1u);
-  SVGTransform* from_transform = at(0);
-  SVGTransform* to_transform = other_list->at(0);
+  const SVGTransform* from_transform = at(0);
+  const SVGTransform* to_transform = other_list->at(0);
 
   DCHECK_EQ(from_transform->TransformType(), to_transform->TransformType());
   Clear();
@@ -413,10 +413,10 @@ void SVGTransformList::CalculateAnimatedValue(
     const SMILAnimationEffectParameters& parameters,
     float percentage,
     unsigned repeat_count,
-    SVGPropertyBase* from_value,
-    SVGPropertyBase* to_value,
-    SVGPropertyBase* to_at_end_of_duration_value,
-    SVGElement* context_element) {
+    const SVGPropertyBase* from_value,
+    const SVGPropertyBase* to_value,
+    const SVGPropertyBase* to_at_end_of_duration_value,
+    const SVGElement* context_element) {
   // Spec: To animations provide specific functionality to get a smooth change
   // from the underlying value to the 'to' attribute value, which conflicts
   // mathematically with the requirement for additive transform animations to be
@@ -434,8 +434,8 @@ void SVGTransformList::CalculateAnimatedValue(
 
   // Get a reference to the from value before potentially cleaning it out (in
   // the case of a To animation.)
-  SVGTransform* to_transform = to_list->at(0);
-  SVGTransform* effective_from = nullptr;
+  const SVGTransform* to_transform = to_list->at(0);
+  const SVGTransform* effective_from = nullptr;
   // If there's an existing 'from'/underlying value of the same type use that,
   // else use a "zero transform".
   if (from_list->length() &&
@@ -452,7 +452,7 @@ void SVGTransformList::CalculateAnimatedValue(
 
   // Handle accumulation.
   if (repeat_count && parameters.is_cumulative) {
-    SVGTransform* effective_to_at_end =
+    const SVGTransform* effective_to_at_end =
         !to_at_end_of_duration_list->IsEmpty()
             ? to_at_end_of_duration_list->at(0)
             : MakeGarbageCollected<SVGTransform>(
@@ -473,8 +473,8 @@ void SVGTransformList::CalculateAnimatedValue(
   Append(current_transform);
 }
 
-float SVGTransformList::CalculateDistance(SVGPropertyBase* to_value,
-                                          SVGElement*) {
+float SVGTransformList::CalculateDistance(const SVGPropertyBase* to_value,
+                                          const SVGElement*) const {
   // FIXME: This is not correct in all cases. The spec demands that each
   // component (translate x and y for example) is paced separately. To implement
   // this we need to treat each component as individual animation everywhere.

third_party/blink/renderer/core/svg/svg_transform_list.h

@@ -58,15 +58,17 @@ class SVGTransformList final
   bool Parse(const UChar*& ptr, const UChar* end);
   bool Parse(const LChar*& ptr, const LChar* end);
 
-  void Add(SVGPropertyBase*, SVGElement*) override;
-  void CalculateAnimatedValue(const SMILAnimationEffectParameters&,
-                              float percentage,
-                              unsigned repeat_count,
-                              SVGPropertyBase* from_value,
-                              SVGPropertyBase* to_value,
-                              SVGPropertyBase* to_at_end_of_duration_value,
-                              SVGElement*) override;
-  float CalculateDistance(SVGPropertyBase* to, SVGElement*) override;
+  void Add(const SVGPropertyBase*, const SVGElement*) override;
+  void CalculateAnimatedValue(
+      const SMILAnimationEffectParameters&,
+      float percentage,
+      unsigned repeat_count,
+      const SVGPropertyBase* from_value,
+      const SVGPropertyBase* to_value,
+      const SVGPropertyBase* to_at_end_of_duration_value,
+      const SVGElement*) override;
+  float CalculateDistance(const SVGPropertyBase* to,
+                          const SVGElement*) const override;
 
   static AnimatedPropertyType ClassType() { return kAnimatedTransformList; }