Remove DEFINE_FILTER_OPERATION_TYPE_CASTS to use new downcast helpers.

Bug: 891908
Change-Id: I79c199ee38d9369f4ca87d578dcbc8565fa0ef11
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1538157
Commit-Queue: Abhijeet Kandalkar <abhijeet@igalia.com>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#644349}

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

@@ -184,12 +184,12 @@ InterpolationValue filter_interpolation_functions::MaybeConvertFilter(
 
     case FilterOperation::BLUR:
       result = LengthInterpolationFunctions::MaybeConvertLength(
-          ToBlurFilterOperation(filter).StdDeviation(), zoom);
+          To<BlurFilterOperation>(filter).StdDeviation(), zoom);
       break;
 
     case FilterOperation::DROP_SHADOW: {
       result = ShadowInterpolationFunctions::ConvertShadowData(
-          ToDropShadowFilterOperation(filter).Shadow(), zoom);
+          To<DropShadowFilterOperation>(filter).Shadow(), zoom);
       break;
     }
 

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

@@ -1972,7 +1972,7 @@ CSSValue* ComputedStyleUtils::ValueForFilter(
       case FilterOperation::REFERENCE:
         filter_value = MakeGarbageCollected<CSSFunctionValue>(CSSValueID::kUrl);
         filter_value->Append(*MakeGarbageCollected<CSSStringValue>(
-            ToReferenceFilterOperation(filter_operation)->Url()));
+            To<ReferenceFilterOperation>(filter_operation)->Url()));
         break;
       case FilterOperation::GRAYSCALE:
         filter_value =
@@ -2038,12 +2038,12 @@ CSSValue* ComputedStyleUtils::ValueForFilter(
         filter_value =
             MakeGarbageCollected<CSSFunctionValue>(CSSValueID::kBlur);
         filter_value->Append(*ZoomAdjustedPixelValue(
-            ToBlurFilterOperation(filter_operation)->StdDeviation().Value(),
+            To<BlurFilterOperation>(filter_operation)->StdDeviation().Value(),
             style));
         break;
       case FilterOperation::DROP_SHADOW: {
         const auto& drop_shadow_operation =
-            ToDropShadowFilterOperation(*filter_operation);
+            To<DropShadowFilterOperation>(*filter_operation);
         filter_value =
             MakeGarbageCollected<CSSFunctionValue>(CSSValueID::kDropShadow);
         // We want our computed style to look like that of a text shadow (has

third_party/blink/renderer/core/css/resolver/element_style_resources.cc

@@ -124,12 +124,12 @@ void ElementStyleResources::LoadPendingSVGResources(
     return;
   FilterOperations::FilterOperationVector& filter_operations =
       computed_style->MutableFilter().Operations();
-  for (auto& filter_operation : filter_operations) {
-    if (filter_operation->GetType() != FilterOperation::REFERENCE)
+  for (const auto& filter_operation : filter_operations) {
+    auto* reference_operation =
+        DynamicTo<ReferenceFilterOperation>(filter_operation.Get());
+    if (!reference_operation)
       continue;
-    ReferenceFilterOperation& reference_operation =
-        ToReferenceFilterOperation(*filter_operation);
-    if (SVGResource* resource = reference_operation.Resource())
+    if (SVGResource* resource = reference_operation->Resource())
       resource->Load(element_->GetDocument());
   }
 }

third_party/blink/renderer/core/layout/svg/svg_layout_tree_as_text.cc

@@ -750,7 +750,7 @@ void WriteResources(WTF::TextStream& ts,
     const FilterOperation& filter_operation = *style.Filter().at(0);
     DCHECK_EQ(filter_operation.GetType(), FilterOperation::REFERENCE);
     const auto& reference_filter_operation =
-        ToReferenceFilterOperation(filter_operation);
+        To<ReferenceFilterOperation>(filter_operation);
     AtomicString id = SVGURIReference::FragmentIdentifierFromIRIString(
         reference_filter_operation.Url(), tree_scope);
     WriteIndent(ts, indent);

third_party/blink/renderer/core/layout/svg/svg_resources.cc

@@ -183,12 +183,11 @@ std::unique_ptr<SVGResources> SVGResources::BuildResources(
       const FilterOperations& filter_operations = computed_style.Filter();
       if (filter_operations.size() == 1) {
         const FilterOperation& filter_operation = *filter_operations.at(0);
-        if (filter_operation.GetType() == FilterOperation::REFERENCE) {
-          const auto& reference_filter_operation =
-              ToReferenceFilterOperation(filter_operation);
+        if (const auto* reference_filter_operation =
+                DynamicTo<ReferenceFilterOperation>(filter_operation)) {
           EnsureResources(resources).SetFilter(
               CastResource<LayoutSVGResourceFilter>(
-                  reference_filter_operation.Resource()));
+                  reference_filter_operation->Resource()));
         }
       }
     }

third_party/blink/renderer/core/paint/filter_effect_builder.cc

@@ -142,8 +142,8 @@ FilterEffect* FilterEffectBuilder::BuildFilterEffect(
     FilterEffect* effect = nullptr;
     switch (filter_operation->GetType()) {
       case FilterOperation::REFERENCE: {
-        ReferenceFilterOperation& reference_operation =
-            ToReferenceFilterOperation(*filter_operation);
+        auto& reference_operation =
+            To<ReferenceFilterOperation>(*filter_operation);
         Filter* reference_filter =
             BuildReferenceFilter(reference_operation, previous_effect);
         if (reference_filter) {
@@ -252,14 +252,14 @@ FilterEffect* FilterEffectBuilder::BuildFilterEffect(
       }
       case FilterOperation::BLUR: {
         float std_deviation = FloatValueForLength(
-            ToBlurFilterOperation(filter_operation)->StdDeviation(), 0);
+            To<BlurFilterOperation>(filter_operation)->StdDeviation(), 0);
         effect =
             FEGaussianBlur::Create(parent_filter, std_deviation, std_deviation);
         break;
       }
       case FilterOperation::DROP_SHADOW: {
         const ShadowData& shadow =
-            ToDropShadowFilterOperation(*filter_operation).Shadow();
+            To<DropShadowFilterOperation>(*filter_operation).Shadow();
         effect = FEDropShadow::Create(parent_filter, shadow.Blur(),
                                       shadow.Blur(), shadow.X(), shadow.Y(),
                                       shadow.GetColor().GetColor(), 1);
@@ -267,7 +267,7 @@ FilterEffect* FilterEffectBuilder::BuildFilterEffect(
       }
       case FilterOperation::BOX_REFLECT: {
         BoxReflectFilterOperation* box_reflect_operation =
-            ToBoxReflectFilterOperation(filter_operation);
+            To<BoxReflectFilterOperation>(filter_operation);
         effect = FEBoxReflect::Create(parent_filter,
                                       box_reflect_operation->Reflection());
         break;
@@ -300,8 +300,7 @@ CompositorFilterOperations FilterEffectBuilder::BuildFilterOperations(
   for (FilterOperation* op : operations.Operations()) {
     switch (op->GetType()) {
       case FilterOperation::REFERENCE: {
-        ReferenceFilterOperation& reference_operation =
-            ToReferenceFilterOperation(*op);
+        auto& reference_operation = To<ReferenceFilterOperation>(*op);
         Filter* reference_filter =
             BuildReferenceFilter(reference_operation, nullptr);
         if (reference_filter && reference_filter->LastEffect()) {
@@ -369,12 +368,12 @@ CompositorFilterOperations FilterEffectBuilder::BuildFilterOperations(
       }
       case FilterOperation::BLUR: {
         float pixel_radius =
-            ToBlurFilterOperation(*op).StdDeviation().GetFloatValue();
+            To<BlurFilterOperation>(*op).StdDeviation().GetFloatValue();
         filters.AppendBlurFilter(pixel_radius);
         break;
       }
       case FilterOperation::DROP_SHADOW: {
-        const ShadowData& shadow = ToDropShadowFilterOperation(*op).Shadow();
+        const ShadowData& shadow = To<DropShadowFilterOperation>(*op).Shadow();
         filters.AppendDropShadowFilter(FlooredIntPoint(shadow.Location()),
                                        shadow.Blur(),
                                        shadow.GetColor().GetColor());
@@ -383,7 +382,8 @@ CompositorFilterOperations FilterEffectBuilder::BuildFilterOperations(
       case FilterOperation::BOX_REFLECT: {
         // TODO(jbroman): Consider explaining box reflect to the compositor,
         // instead of calling this a "reference filter".
-        const auto& reflection = ToBoxReflectFilterOperation(*op).Reflection();
+        const auto& reflection =
+            To<BoxReflectFilterOperation>(*op).Reflection();
         filters.AppendReferenceFilter(
             paint_filter_builder::BuildBoxReflectFilter(reflection, nullptr));
         break;

third_party/blink/renderer/core/style/filter_operation.cc

@@ -74,7 +74,7 @@ void ReferenceFilterOperation::RemoveClient(SVGResourceClient& client) {
 bool ReferenceFilterOperation::operator==(const FilterOperation& o) const {
   if (!IsSameType(o))
     return false;
-  const ReferenceFilterOperation& other = ToReferenceFilterOperation(o);
+  const auto& other = To<ReferenceFilterOperation>(o);
   return url_ == other.url_ && resource_ == other.resource_;
 }
 
@@ -170,7 +170,7 @@ FilterOperation* BlurFilterOperation::Blend(const FilterOperation* from,
     return BlurFilterOperation::Create(std_deviation_.Blend(
         Length(length_type), progress, kValueRangeNonNegative));
 
-  const BlurFilterOperation* from_op = ToBlurFilterOperation(from);
+  const auto* from_op = To<BlurFilterOperation>(from);
   return BlurFilterOperation::Create(std_deviation_.Blend(
       from_op->std_deviation_, progress, kValueRangeNonNegative));
 }
@@ -188,7 +188,7 @@ FilterOperation* DropShadowFilterOperation::Blend(const FilterOperation* from,
                                 Color::kTransparent));
   }
 
-  const auto& from_op = ToDropShadowFilterOperation(*from);
+  const auto& from_op = To<DropShadowFilterOperation>(*from);
   return Create(shadow_.Blend(from_op.shadow_, progress, Color::kTransparent));
 }
 

third_party/blink/renderer/core/style/filter_operation.h

@@ -124,11 +124,6 @@ class CORE_EXPORT FilterOperation
   DISALLOW_COPY_AND_ASSIGN(FilterOperation);
 };
 
-#define DEFINE_FILTER_OPERATION_TYPE_CASTS(thisType, operationType)  \
-  DEFINE_TYPE_CASTS(thisType, FilterOperation, op,                   \
-                    op->GetType() == FilterOperation::operationType, \
-                    op.GetType() == FilterOperation::operationType)
-
 class CORE_EXPORT ReferenceFilterOperation : public FilterOperation {
  public:
   static ReferenceFilterOperation* Create(const AtomicString& url,
@@ -168,7 +163,12 @@ class CORE_EXPORT ReferenceFilterOperation : public FilterOperation {
   Member<Filter> filter_;
 };
 
-DEFINE_FILTER_OPERATION_TYPE_CASTS(ReferenceFilterOperation, REFERENCE);
+template <>
+struct DowncastTraits<ReferenceFilterOperation> {
+  static bool AllowFrom(const FilterOperation& op) {
+    return op.GetType() == FilterOperation::REFERENCE;
+  }
+};
 
 // GRAYSCALE, SEPIA, SATURATE and HUE_ROTATE are variations on a basic color
 // matrix effect.  For HUE_ROTATE, the angle of rotation is stored in m_amount.
@@ -289,7 +289,12 @@ class CORE_EXPORT BlurFilterOperation : public FilterOperation {
   Length std_deviation_;
 };
 
-DEFINE_FILTER_OPERATION_TYPE_CASTS(BlurFilterOperation, BLUR);
+template <>
+struct DowncastTraits<BlurFilterOperation> {
+  static bool AllowFrom(const FilterOperation& op) {
+    return op.GetType() == FilterOperation::BLUR;
+  }
+};
 
 class CORE_EXPORT DropShadowFilterOperation : public FilterOperation {
  public:
@@ -320,7 +325,12 @@ class CORE_EXPORT DropShadowFilterOperation : public FilterOperation {
   ShadowData shadow_;
 };
 
-DEFINE_FILTER_OPERATION_TYPE_CASTS(DropShadowFilterOperation, DROP_SHADOW);
+template <>
+struct DowncastTraits<DropShadowFilterOperation> {
+  static bool AllowFrom(const FilterOperation& op) {
+    return op.GetType() == FilterOperation::DROP_SHADOW;
+  }
+};
 
 class CORE_EXPORT BoxReflectFilterOperation : public FilterOperation {
  public:
@@ -344,7 +354,13 @@ class CORE_EXPORT BoxReflectFilterOperation : public FilterOperation {
 
   BoxReflection reflection_;
 };
-DEFINE_FILTER_OPERATION_TYPE_CASTS(BoxReflectFilterOperation, BOX_REFLECT);
+
+template <>
+struct DowncastTraits<BoxReflectFilterOperation> {
+  static bool AllowFrom(const FilterOperation& op) {
+    return op.GetType() == FilterOperation::BOX_REFLECT;
+  }
+};
 
 #undef DEFINE_FILTER_OPERATION_TYPE_CASTS
 

third_party/blink/renderer/core/style/filter_operations.cc

@@ -104,14 +104,14 @@ bool FilterOperations::HasFilterThatMovesPixels() const {
 void FilterOperations::AddClient(SVGResourceClient& client) const {
   for (FilterOperation* operation : operations_) {
     if (operation->GetType() == FilterOperation::REFERENCE)
-      ToReferenceFilterOperation(*operation).AddClient(client);
+      To<ReferenceFilterOperation>(*operation).AddClient(client);
   }
 }
 
 void FilterOperations::RemoveClient(SVGResourceClient& client) const {
   for (FilterOperation* operation : operations_) {
     if (operation->GetType() == FilterOperation::REFERENCE)
-      ToReferenceFilterOperation(*operation).RemoveClient(client);
+      To<ReferenceFilterOperation>(*operation).RemoveClient(client);
   }
 }