Switch t_p/blink/renderer/core/css away from DEFINE_CSS_RULE_TYPE_CASTS

... to use downcast helpers

BUG=891908

R=jbroman@chromium.org
CC=blink-reviews-vendor@chromium.org

Change-Id: I73216ed5fadbd095498e98613e089cea1b7514fb
Reviewed-on: https://chromium-review.googlesource.com/c/1494680
Commit-Queue: Antonio Gomes <tonikitoo@igalia.com>
Reviewed-by: Jeremy Roman <jbroman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#636835}

third_party/blink/renderer/core/css/css_font_face_rule.h

@@ -24,6 +24,7 @@
 
 #include "third_party/blink/renderer/core/css/css_rule.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
+#include "third_party/blink/renderer/platform/wtf/casting.h"
 
 namespace blink {
 
@@ -59,7 +60,12 @@ class CSSFontFaceRule final : public CSSRule {
   mutable Member<StyleRuleCSSStyleDeclaration> properties_cssom_wrapper_;
 };
 
-DEFINE_CSS_RULE_TYPE_CASTS(CSSFontFaceRule, kFontFaceRule);
+template <>
+struct DowncastTraits<CSSFontFaceRule> {
+  static bool AllowFrom(const CSSRule& rule) {
+    return rule.type() == CSSRule::kFontFaceRule;
+  }
+};
 
 }  // namespace blink
 

third_party/blink/renderer/core/css/css_font_feature_values_rule.h

@@ -7,6 +7,7 @@
 
 #include "third_party/blink/renderer/core/css/css_rule.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
+#include "third_party/blink/renderer/platform/wtf/casting.h"
 
 namespace blink {
 
@@ -44,7 +45,12 @@ class CSSFontFeatureValuesRule final : public CSSRule {
   Member<StyleRuleFontFeatureValues> font_feature_values_rule_;
 };
 
-DEFINE_CSS_RULE_TYPE_CASTS(CSSFontFeatureValuesRule, kFontFeatureValuesRule);
+template <>
+struct DowncastTraits<CSSFontFeatureValuesRule> {
+  static bool AllowFrom(const CSSRule& rule) {
+    return rule.type() == CSSRule::kFontFeatureValuesRule;
+  }
+};
 
 }  // namespace blink
 

third_party/blink/renderer/core/css/css_import_rule.h

@@ -24,6 +24,7 @@
 
 #include "third_party/blink/renderer/core/css/css_rule.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
+#include "third_party/blink/renderer/platform/wtf/casting.h"
 
 namespace blink {
 
@@ -58,7 +59,12 @@ class CSSImportRule final : public CSSRule {
   mutable Member<CSSStyleSheet> style_sheet_cssom_wrapper_;
 };
 
-DEFINE_CSS_RULE_TYPE_CASTS(CSSImportRule, kImportRule);
+template <>
+struct DowncastTraits<CSSImportRule> {
+  static bool AllowFrom(const CSSRule& rule) {
+    return rule.type() == CSSRule::kImportRule;
+  }
+};
 
 }  // namespace blink
 

third_party/blink/renderer/core/css/css_keyframe_rule.cc

@@ -49,7 +49,7 @@ void CSSKeyframeRule::setKeyText(const String& key_text,
         DOMExceptionCode::kSyntaxError,
         "The key '" + key_text + "' is invalid and cannot be parsed");
 
-  ToCSSKeyframesRule(parentRule())->StyleChanged();
+  To<CSSKeyframesRule>(parentRule())->StyleChanged();
 }
 
 CSSStyleDeclaration* CSSKeyframeRule::style() const {

third_party/blink/renderer/core/css/css_keyframe_rule.h

@@ -28,6 +28,7 @@
 
 #include "third_party/blink/renderer/core/css/css_rule.h"
 #include "third_party/blink/renderer/core/css/style_rule_keyframe.h"
+#include "third_party/blink/renderer/platform/wtf/casting.h"
 
 namespace blink {
 
@@ -63,7 +64,12 @@ class CSSKeyframeRule final : public CSSRule {
   friend class CSSKeyframesRule;
 };
 
-DEFINE_CSS_RULE_TYPE_CASTS(CSSKeyframeRule, kKeyframeRule);
+template <>
+struct DowncastTraits<CSSKeyframeRule> {
+  static bool AllowFrom(const CSSRule& rule) {
+    return rule.type() == CSSRule::kKeyframeRule;
+  }
+};
 
 }  // namespace blink
 

third_party/blink/renderer/core/css/css_keyframes_rule.h

@@ -28,6 +28,7 @@
 
 #include "third_party/blink/renderer/core/css/css_rule.h"
 #include "third_party/blink/renderer/core/css/style_rule.h"
+#include "third_party/blink/renderer/platform/wtf/casting.h"
 #include "third_party/blink/renderer/platform/wtf/forward.h"
 #include "third_party/blink/renderer/platform/wtf/text/atomic_string.h"
 
@@ -129,7 +130,12 @@ class CSSKeyframesRule final : public CSSRule {
   bool is_prefixed_;
 };
 
-DEFINE_CSS_RULE_TYPE_CASTS(CSSKeyframesRule, kKeyframesRule);
+template <>
+struct DowncastTraits<CSSKeyframesRule> {
+  static bool AllowFrom(const CSSRule& rule) {
+    return rule.type() == CSSRule::kKeyframesRule;
+  }
+};
 
 }  // namespace blink
 

third_party/blink/renderer/core/css/css_media_rule.h

@@ -25,6 +25,7 @@
 
 #include "third_party/blink/renderer/core/css/css_condition_rule.h"
 #include "third_party/blink/renderer/core/css/media_list.h"
+#include "third_party/blink/renderer/platform/wtf/casting.h"
 
 namespace blink {
 
@@ -57,7 +58,12 @@ class CSSMediaRule final : public CSSConditionRule {
   mutable Member<MediaList> media_cssom_wrapper_;
 };
 
-DEFINE_CSS_RULE_TYPE_CASTS(CSSMediaRule, kMediaRule);
+template <>
+struct DowncastTraits<CSSMediaRule> {
+  static bool AllowFrom(const CSSRule& rule) {
+    return rule.type() == CSSRule::kMediaRule;
+  }
+};
 
 }  // namespace blink
 

third_party/blink/renderer/core/css/css_namespace_rule.h

@@ -6,6 +6,7 @@
 #define THIRD_PARTY_BLINK_RENDERER_CORE_CSS_CSS_NAMESPACE_RULE_H_
 
 #include "third_party/blink/renderer/core/css/css_rule.h"
+#include "third_party/blink/renderer/platform/wtf/casting.h"
 
 namespace blink {
 
@@ -37,7 +38,12 @@ class CSSNamespaceRule final : public CSSRule {
   Member<StyleRuleNamespace> namespace_rule_;
 };
 
-DEFINE_CSS_RULE_TYPE_CASTS(CSSNamespaceRule, kNamespaceRule);
+template <>
+struct DowncastTraits<CSSNamespaceRule> {
+  static bool AllowFrom(const CSSRule& rule) {
+    return rule.type() == CSSRule::kNamespaceRule;
+  }
+};
 
 }  // namespace blink
 

third_party/blink/renderer/core/css/css_page_rule.h

@@ -24,6 +24,7 @@
 
 #include "third_party/blink/renderer/core/css/css_rule.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
+#include "third_party/blink/renderer/platform/wtf/casting.h"
 
 namespace blink {
 
@@ -61,7 +62,12 @@ class CORE_EXPORT CSSPageRule final : public CSSRule {
   mutable Member<StyleRuleCSSStyleDeclaration> properties_cssom_wrapper_;
 };
 
-DEFINE_CSS_RULE_TYPE_CASTS(CSSPageRule, kPageRule);
+template <>
+struct DowncastTraits<CSSPageRule> {
+  static bool AllowFrom(const CSSRule& rule) {
+    return rule.type() == CSSRule::kPageRule;
+  }
+};
 
 }  // namespace blink
 

third_party/blink/renderer/core/css/css_page_rule_test.cc

@@ -23,8 +23,8 @@ TEST(CSSPageRule, Serializing) {
     EXPECT_EQ(1u, sheet.CssRules()->length());
     EXPECT_EQ(String(css_rule), sheet.CssRules()->item(0)->cssText());
     EXPECT_EQ(CSSRule::kPageRule, sheet.CssRules()->item(0)->type());
-    if (CSSPageRule* page_rule = ToCSSPageRule(sheet.CssRules()->item(0)))
-      EXPECT_EQ(":left", page_rule->selectorText());
+    auto* page_rule = To<CSSPageRule>(sheet.CssRules()->item(0));
+    EXPECT_EQ(":left", page_rule->selectorText());
   }
 }
 
@@ -36,7 +36,7 @@ TEST(CSSPageRule, selectorText) {
   DCHECK(sheet.CssRules());
   EXPECT_EQ(1u, sheet.CssRules()->length());
 
-  CSSPageRule* page_rule = ToCSSPageRule(sheet.CssRules()->item(0));
+  auto* page_rule = To<CSSPageRule>(sheet.CssRules()->item(0));
   EXPECT_EQ(":left", page_rule->selectorText());
 
   // set invalid page selector.

third_party/blink/renderer/core/css/css_rule.h

@@ -106,10 +106,6 @@ class CORE_EXPORT CSSRule : public ScriptWrappable {
   };
 };
 
-#define DEFINE_CSS_RULE_TYPE_CASTS(ToType, TYPE_NAME)                          \
-  DEFINE_TYPE_CASTS(ToType, CSSRule, rule, rule->type() == CSSRule::TYPE_NAME, \
-                    rule.type() == CSSRule::TYPE_NAME)
-
 }  // namespace blink
 
 #endif  // THIRD_PARTY_BLINK_RENDERER_CORE_CSS_CSS_RULE_H_

third_party/blink/renderer/core/css/css_style_declaration_test.cc

@@ -21,7 +21,7 @@ TEST(CSSStyleDeclarationTest, getPropertyShorthand) {
   ASSERT_TRUE(sheet.CssRules());
   ASSERT_EQ(1u, sheet.CssRules()->length());
   ASSERT_EQ(CSSRule::kStyleRule, sheet.CssRules()->item(0)->type());
-  CSSStyleRule* style_rule = ToCSSStyleRule(sheet.CssRules()->item(0));
+  CSSStyleRule* style_rule = To<CSSStyleRule>(sheet.CssRules()->item(0));
   CSSStyleDeclaration* style = style_rule->style();
   ASSERT_TRUE(style);
   EXPECT_EQ(AtomicString(), style->GetPropertyShorthand("padding"));

third_party/blink/renderer/core/css/css_style_rule.h

@@ -25,6 +25,7 @@
 #include "third_party/blink/renderer/core/css/css_rule.h"
 #include "third_party/blink/renderer/core/css/cssom/style_property_map.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
+#include "third_party/blink/renderer/platform/wtf/casting.h"
 
 namespace blink {
 
@@ -67,7 +68,12 @@ class CORE_EXPORT CSSStyleRule final : public CSSRule {
   Member<StylePropertyMap> style_map_;
 };
 
-DEFINE_CSS_RULE_TYPE_CASTS(CSSStyleRule, kStyleRule);
+template <>
+struct DowncastTraits<CSSStyleRule> {
+  static bool AllowFrom(const CSSRule& rule) {
+    return rule.type() == CSSRule::kStyleRule;
+  }
+};
 
 }  // namespace blink
 

third_party/blink/renderer/core/css/css_supports_rule.h

@@ -30,6 +30,7 @@
 #define THIRD_PARTY_BLINK_RENDERER_CORE_CSS_CSS_SUPPORTS_RULE_H_
 
 #include "third_party/blink/renderer/core/css/css_condition_rule.h"
+#include "third_party/blink/renderer/platform/wtf/casting.h"
 
 namespace blink {
 
@@ -53,7 +54,12 @@ class CSSSupportsRule final : public CSSConditionRule {
   CSSRule::Type type() const override { return kSupportsRule; }
 };
 
-DEFINE_CSS_RULE_TYPE_CASTS(CSSSupportsRule, kSupportsRule);
+template <>
+struct DowncastTraits<CSSSupportsRule> {
+  static bool AllowFrom(const CSSRule& rule) {
+    return rule.type() == CSSRule::kSupportsRule;
+  }
+};
 
 }  // namespace blink
 

third_party/blink/renderer/core/css/css_viewport_rule.h

@@ -33,6 +33,7 @@
 
 #include "third_party/blink/renderer/core/css/css_rule.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
+#include "third_party/blink/renderer/platform/wtf/casting.h"
 
 namespace blink {
 
@@ -66,7 +67,12 @@ class CSSViewportRule final : public CSSRule {
   mutable Member<StyleRuleCSSStyleDeclaration> properties_cssom_wrapper_;
 };
 
-DEFINE_CSS_RULE_TYPE_CASTS(CSSViewportRule, kViewportRule);
+template <>
+struct DowncastTraits<CSSViewportRule> {
+  static bool AllowFrom(const CSSRule& rule) {
+    return rule.type() == CSSRule::kViewportRule;
+  }
+};
 
 }  // namespace blink
 

third_party/blink/renderer/core/css/element_rule_collector.cc

@@ -274,13 +274,10 @@ CSSRule* ElementRuleCollector::FindStyleRule(CSSRuleCollection* css_rules,
   CSSRule* result = nullptr;
   for (unsigned i = 0; i < css_rules->length() && !result; ++i) {
     CSSRule* css_rule = css_rules->item(i);
-    CSSRule::Type css_rule_type = css_rule->type();
-    if (css_rule_type == CSSRule::kStyleRule) {
-      CSSStyleRule* css_style_rule = ToCSSStyleRule(css_rule);
+    if (auto* css_style_rule = DynamicTo<CSSStyleRule>(css_rule)) {
       if (css_style_rule->GetStyleRule() == style_rule)
         result = css_rule;
-    } else if (css_rule_type == CSSRule::kImportRule) {
-      CSSImportRule* css_import_rule = ToCSSImportRule(css_rule);
+    } else if (auto* css_import_rule = DynamicTo<CSSImportRule>(css_rule)) {
       result = FindStyleRule(css_import_rule->styleSheet(), style_rule);
     } else {
       result = FindStyleRule(css_rule->cssRules(), style_rule);

third_party/blink/renderer/core/css/keyframe_style_rule_css_style_declaration.cc

@@ -16,7 +16,7 @@ KeyframeStyleRuleCSSStyleDeclaration::KeyframeStyleRuleCSSStyleDeclaration(
 
 void KeyframeStyleRuleCSSStyleDeclaration::DidMutate(MutationType type) {
   StyleRuleCSSStyleDeclaration::DidMutate(type);
-  ToCSSKeyframesRule(parent_rule_->parentRule())->StyleChanged();
+  To<CSSKeyframesRule>(parent_rule_->parentRule())->StyleChanged();
 }
 
 }  // namespace blink

third_party/blink/renderer/core/css/style_engine_test.cc

@@ -980,7 +980,7 @@ TEST_F(StyleEngineTest, ModifyStyleRuleMatchedPropertiesCache) {
   DummyExceptionStateForTesting exception_state;
   ASSERT_TRUE(sheet->cssRules(exception_state));
   CSSStyleRule* style_rule =
-      ToCSSStyleRule(sheet->cssRules(exception_state)->item(0));
+      To<CSSStyleRule>(sheet->cssRules(exception_state)->item(0));
   ASSERT_FALSE(exception_state.HadException());
   ASSERT_TRUE(style_rule);
   ASSERT_TRUE(style_rule->style());

third_party/blink/renderer/core/frame/frame_serializer.cc

@@ -427,11 +427,11 @@ void FrameSerializer::SerializeCSSRule(CSSRule* rule) {
   switch (rule->type()) {
     case CSSRule::kStyleRule:
       RetrieveResourcesForProperties(
-          &ToCSSStyleRule(rule)->GetStyleRule()->Properties(), document);
+          &To<CSSStyleRule>(rule)->GetStyleRule()->Properties(), document);
       break;
 
     case CSSRule::kImportRule: {
-      CSSImportRule* import_rule = ToCSSImportRule(rule);
+      CSSImportRule* import_rule = To<CSSImportRule>(rule);
       KURL sheet_base_url = rule->parentStyleSheet()->BaseURL();
       DCHECK(sheet_base_url.IsValid());
       KURL import_url = KURL(sheet_base_url, import_rule->href());
@@ -451,7 +451,7 @@ void FrameSerializer::SerializeCSSRule(CSSRule* rule) {
 
     case CSSRule::kFontFaceRule:
       RetrieveResourcesForProperties(
-          &ToCSSFontFaceRule(rule)->StyleRule()->Properties(), document);
+          &To<CSSFontFaceRule>(rule)->StyleRule()->Properties(), document);
       break;
 
     // Rules in which no external resources can be referenced

third_party/blink/renderer/core/inspector/inspector_animation_agent.cc

@@ -478,7 +478,7 @@ String InspectorAnimationAgent::CreateCSSId(blink::Animation& animation) {
     AddStringToDigestor(digestor.get(),
                         css_agent_->StyleSheetId(style->ParentStyleSheet()));
     AddStringToDigestor(digestor.get(),
-                        ToCSSStyleRule(style->parentRule())->selectorText());
+                        To<CSSStyleRule>(style->parentRule())->selectorText());
   }
   DigestValue digest_result;
   FinishDigestor(digestor.get(), digest_result);

third_party/blink/renderer/core/inspector/inspector_css_agent.cc

@@ -122,7 +122,7 @@ String CreateShorthandValue(Document* document,
                         style_sheet_contents, text);
 
   CSSStyleSheet* style_sheet = CSSStyleSheet::Create(style_sheet_contents);
-  CSSStyleRule* rule = ToCSSStyleRule(style_sheet->item(0));
+  auto* rule = To<CSSStyleRule>(style_sheet->item(0));
   CSSStyleDeclaration* style = rule->style();
   DummyExceptionStateForTesting exception_state;
   style->setProperty(document, longhand, new_value,
@@ -135,11 +135,11 @@ HeapVector<Member<CSSStyleRule>> FilterDuplicateRules(CSSRuleList* rule_list) {
   HeapHashSet<Member<CSSRule>> uniq_rules_set;
   for (unsigned i = rule_list ? rule_list->length() : 0; i > 0; --i) {
     CSSRule* rule = rule_list->item(i - 1);
-    if (!rule || rule->type() != CSSRule::kStyleRule ||
-        uniq_rules_set.Contains(rule))
+    auto* style_rule = DynamicTo<CSSStyleRule>(rule);
+    if (!style_rule || uniq_rules_set.Contains(rule))
       continue;
     uniq_rules_set.insert(rule);
-    uniq_rules.push_back(ToCSSStyleRule(rule));
+    uniq_rules.push_back(style_rule);
   }
   uniq_rules.Reverse();
   return uniq_rules;
@@ -507,11 +507,10 @@ class InspectorCSSAgent::ModifyRuleAction final
     if (type_ != kSetStyleText)
       return nullptr;
     CSSRule* rule = TakeRule();
-    if (rule->type() == CSSRule::kStyleRule)
-      return style_sheet_->BuildObjectForStyle(ToCSSStyleRule(rule)->style());
-    if (rule->type() == CSSRule::kKeyframeRule)
-      return style_sheet_->BuildObjectForStyle(
-          ToCSSKeyframeRule(rule)->style());
+    if (auto* style_rule = DynamicTo<CSSStyleRule>(rule))
+      return style_sheet_->BuildObjectForStyle(style_rule->style());
+    if (auto* keyframe_rule = DynamicTo<CSSKeyframeRule>(rule))
+      return style_sheet_->BuildObjectForStyle(keyframe_rule->style());
     return nullptr;
   }
 
@@ -651,16 +650,12 @@ class InspectorCSSAgent::AddRuleAction final
 
 // static
 CSSStyleRule* InspectorCSSAgent::AsCSSStyleRule(CSSRule* rule) {
-  if (!rule || rule->type() != CSSRule::kStyleRule)
-    return nullptr;
-  return ToCSSStyleRule(rule);
+  return DynamicTo<CSSStyleRule>(rule);
 }
 
 // static
 CSSMediaRule* InspectorCSSAgent::AsCSSMediaRule(CSSRule* rule) {
-  if (!rule || rule->type() != CSSRule::kMediaRule)
-    return nullptr;
-  return ToCSSMediaRule(rule);
+  return DynamicTo<CSSMediaRule>(rule);
 }
 
 InspectorCSSAgent::InspectorCSSAgent(
@@ -1027,12 +1022,10 @@ static CSSKeyframesRule* FindKeyframesRule(CSSRuleCollection* css_rules,
   CSSKeyframesRule* result = nullptr;
   for (unsigned j = 0; css_rules && j < css_rules->length() && !result; ++j) {
     CSSRule* css_rule = css_rules->item(j);
-    if (css_rule->type() == CSSRule::kKeyframesRule) {
-      CSSKeyframesRule* css_style_rule = ToCSSKeyframesRule(css_rule);
+    if (auto* css_style_rule = DynamicTo<CSSKeyframesRule>(css_rule)) {
       if (css_style_rule->Keyframes() == keyframes_rule)
         result = css_style_rule;
-    } else if (css_rule->type() == CSSRule::kImportRule) {
-      CSSImportRule* css_import_rule = ToCSSImportRule(css_rule);
+    } else if (auto* css_import_rule = DynamicTo<CSSImportRule>(css_rule)) {
       result = FindKeyframesRule(css_import_rule->styleSheet(), keyframes_rule);
     } else {
       result = FindKeyframesRule(css_rule->cssRules(), keyframes_rule);
@@ -1378,7 +1371,7 @@ Response InspectorCSSAgent::setKeyframeKey(
       key_text);
   bool success = dom_agent_->History()->Perform(action, exception_state);
   if (success) {
-    CSSKeyframeRule* rule = ToCSSKeyframeRule(action->TakeRule());
+    auto* rule = To<CSSKeyframeRule>(action->TakeRule());
     InspectorStyleSheet* inspector_style_sheet =
         BindStyleSheet(rule->parentStyleSheet());
     if (!inspector_style_sheet)
@@ -1499,12 +1492,12 @@ Response InspectorCSSAgent::SetStyleText(
     bool success = dom_agent_->History()->Perform(action, exception_state);
     if (success) {
       CSSRule* rule = action->TakeRule();
-      if (rule->type() == CSSRule::kStyleRule) {
-        result = ToCSSStyleRule(rule)->style();
+      if (auto* style_rule = DynamicTo<CSSStyleRule>(rule)) {
+        result = style_rule->style();
         return Response::OK();
       }
-      if (rule->type() == CSSRule::kKeyframeRule) {
-        result = ToCSSKeyframeRule(rule)->style();
+      if (auto* keyframe_rule = DynamicTo<CSSKeyframeRule>(rule)) {
+        result = keyframe_rule->style();
         return Response::OK();
       }
     }
@@ -1768,12 +1761,10 @@ void InspectorCSSAgent::CollectMediaQueriesFromRule(
   String source_url;
   CSSStyleSheet* parent_style_sheet = nullptr;
   bool is_media_rule = true;
-  if (rule->type() == CSSRule::kMediaRule) {
-    CSSMediaRule* media_rule = ToCSSMediaRule(rule);
+  if (auto* media_rule = DynamicTo<CSSMediaRule>(rule)) {
     media_list = media_rule->media();
     parent_style_sheet = media_rule->parentStyleSheet();
-  } else if (rule->type() == CSSRule::kImportRule) {
-    CSSImportRule* import_rule = ToCSSImportRule(rule);
+  } else if (auto* import_rule = DynamicTo<CSSImportRule>(rule)) {
     media_list = import_rule->media();
     parent_style_sheet = import_rule->parentStyleSheet();
     is_media_rule = false;
@@ -1857,8 +1848,8 @@ void InspectorCSSAgent::CollectStyleSheets(
   result.push_back(style_sheet);
   for (unsigned i = 0, size = style_sheet->length(); i < size; ++i) {
     CSSRule* rule = style_sheet->item(i);
-    if (rule->type() == CSSRule::kImportRule) {
-      CSSStyleSheet* imported_style_sheet = ToCSSImportRule(rule)->styleSheet();
+    if (auto* import_rule = DynamicTo<CSSImportRule>(rule)) {
+      CSSStyleSheet* imported_style_sheet = import_rule->styleSheet();
       if (imported_style_sheet)
         InspectorCSSAgent::CollectStyleSheets(imported_style_sheet, result);
     }

third_party/blink/renderer/core/inspector/inspector_style_sheet.cc

@@ -508,14 +508,14 @@ CSSRuleList* AsCSSRuleList(CSSRule* rule) {
   if (!rule)
     return nullptr;
 
-  if (rule->type() == CSSRule::kMediaRule)
-    return ToCSSMediaRule(rule)->cssRules();
+  if (auto* media_rule = DynamicTo<CSSMediaRule>(rule))
+    return media_rule->cssRules();
 
-  if (rule->type() == CSSRule::kSupportsRule)
-    return ToCSSSupportsRule(rule)->cssRules();
+  if (auto* supports_rule = DynamicTo<CSSSupportsRule>(rule))
+    return supports_rule->cssRules();
 
-  if (rule->type() == CSSRule::kKeyframesRule)
-    return ToCSSKeyframesRule(rule)->cssRules();
+  if (auto* keyframes_rule = DynamicTo<CSSKeyframesRule>(rule))
+    return keyframes_rule->cssRules();
 
   return nullptr;
 }
@@ -659,9 +659,9 @@ void Diff(const Vector<String>& list_a,
 }
 
 String CanonicalCSSText(CSSRule* rule) {
-  if (rule->type() != CSSRule::kStyleRule)
+  auto* style_rule = DynamicTo<CSSStyleRule>(rule);
+  if (!style_rule)
     return rule->cssText();
-  CSSStyleRule* style_rule = ToCSSStyleRule(rule);
 
   Vector<String> property_names;
   CSSStyleDeclaration* style = style_rule->style();
@@ -1089,7 +1089,7 @@ CSSKeyframeRule* InspectorStyleSheet::SetKeyframeKey(
     return nullptr;
   }
 
-  CSSKeyframeRule* keyframe_rule = ToCSSKeyframeRule(rule);
+  CSSKeyframeRule* keyframe_rule = To<CSSKeyframeRule>(rule);
   keyframe_rule->setKeyText(text, exception_state);
 
   ReplaceText(source_data->rule_header_range, text, new_range, old_text);
@@ -1119,8 +1119,7 @@ CSSRule* InspectorStyleSheet::SetStyleText(const SourceRange& range,
 
   CSSRule* rule = RuleForSourceData(source_data);
   if (!rule || !rule->parentStyleSheet() ||
-      (rule->type() != CSSRule::kStyleRule &&
-       rule->type() != CSSRule::kKeyframeRule)) {
+      (!IsA<CSSStyleRule>(rule) && !IsA<CSSKeyframeRule>(rule))) {
     exception_state.ThrowDOMException(
         DOMExceptionCode::kNotFoundError,
         "Source range didn't match existing style source range");
@@ -1128,10 +1127,10 @@ CSSRule* InspectorStyleSheet::SetStyleText(const SourceRange& range,
   }
 
   CSSStyleDeclaration* style = nullptr;
-  if (rule->type() == CSSRule::kStyleRule)
-    style = ToCSSStyleRule(rule)->style();
-  else if (rule->type() == CSSRule::kKeyframeRule)
-    style = ToCSSKeyframeRule(rule)->style();
+  if (auto* style_rule = DynamicTo<CSSStyleRule>(rule))
+    style = style_rule->style();
+  else
+    style = To<CSSKeyframeRule>(rule)->style();
   style->setCSSText(page_style_sheet_->OwnerDocument(), text, exception_state);
 
   ReplaceText(source_data->rule_body_range, text, new_range, old_text);
@@ -1280,7 +1279,7 @@ CSSStyleRule* InspectorStyleSheet::InsertCSSOMRuleBySourceRange(
     return nullptr;
   }
 
-  return InsertCSSOMRuleInMediaRule(ToCSSMediaRule(rule), insert_before_rule,
+  return InsertCSSOMRuleInMediaRule(To<CSSMediaRule>(rule), insert_before_rule,
                                     rule_text, exception_state);
 }
 
@@ -1363,7 +1362,7 @@ bool InspectorStyleSheet::DeleteRule(const SourceRange& range,
           "Cannot remove rule from non-media rule.");
       return false;
     }
-    CSSMediaRule* parent_media_rule = ToCSSMediaRule(parent_rule);
+    CSSMediaRule* parent_media_rule = To<CSSMediaRule>(parent_rule);
     wtf_size_t index = 0;
     while (index < parent_media_rule->length() &&
            parent_media_rule->Item(index) != rule)
@@ -1394,9 +1393,9 @@ InspectorStyleSheet::CollectClassNames() {
       protocol::Array<String>::create();
 
   for (wtf_size_t i = 0; i < parsed_flat_rules_.size(); ++i) {
-    if (parsed_flat_rules_.at(i)->type() == CSSRule::kStyleRule)
-      GetClassNamesFromRule(ToCSSStyleRule(parsed_flat_rules_.at(i)),
-                            unique_names);
+    if (auto* style_rule =
+            DynamicTo<CSSStyleRule>(parsed_flat_rules_.at(i).Get()))
+      GetClassNamesFromRule(style_rule, unique_names);
   }
   for (const String& class_name : unique_names)
     result->addItem(class_name);
@@ -1428,9 +1427,9 @@ void InspectorStyleSheet::InnerSetText(const String& text,
       page_style_sheet_->Contents()->ParserContext(), style_sheet, text,
       handler);
   CSSStyleSheet* source_data_sheet = nullptr;
-  if (ToCSSImportRule(page_style_sheet_->ownerRule())) {
-    source_data_sheet = CSSStyleSheet::Create(
-        style_sheet, ToCSSImportRule(page_style_sheet_->ownerRule()));
+  if (auto* import_rule =
+          DynamicTo<CSSImportRule>(page_style_sheet_->ownerRule())) {
+    source_data_sheet = CSSStyleSheet::Create(style_sheet, import_rule);
   } else {
     source_data_sheet =
         CSSStyleSheet::Create(style_sheet, *page_style_sheet_->ownerNode());