Switch {Descendant,Sibling}InvalidationSet to use downcast helpers

R=haraken@chromium.org
CC=​blink-reviews-vendor@chromium.org

BUG=891908

Change-Id: Ibd1f71f7b7eaed5051b7a44abdae737ffd21b2e3
Reviewed-on: https://chromium-review.googlesource.com/c/1491833
Auto-Submit: Antonio Gomes <tonikitoo@igalia.com>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Antonio Gomes <tonikitoo@igalia.com>
Cr-Commit-Position: refs/heads/master@{#636281}

third_party/blink/renderer/core/css/invalidation/invalidation_set.cc

@@ -136,10 +136,10 @@ void InvalidationSet::Combine(const InvalidationSet& other) {
 
   CHECK_NE(&other, this);
 
-  if (IsSiblingInvalidationSet()) {
-    SiblingInvalidationSet& siblings = ToSiblingInvalidationSet(*this);
+  if (auto* invalidation_set = DynamicTo<SiblingInvalidationSet>(this)) {
+    SiblingInvalidationSet& siblings = *invalidation_set;
     const SiblingInvalidationSet& other_siblings =
-        ToSiblingInvalidationSet(other);
+        To<SiblingInvalidationSet>(other);
 
     siblings.UpdateMaxDirectAdjacentSelectors(
         other_siblings.MaxDirectAdjacentSelectors());
@@ -195,10 +195,10 @@ void InvalidationSet::Combine(const InvalidationSet& other) {
 }
 
 void InvalidationSet::Destroy() const {
-  if (IsDescendantInvalidationSet())
-    delete ToDescendantInvalidationSet(this);
+  if (auto* invalidation_set = DynamicTo<DescendantInvalidationSet>(this))
+    delete invalidation_set;
   else
-    delete ToSiblingInvalidationSet(this);
+    delete To<SiblingInvalidationSet>(this);
 }
 
 void InvalidationSet::ClearAllBackings() {

third_party/blink/renderer/core/css/invalidation/invalidation_set.h

@@ -38,7 +38,7 @@
 #include "third_party/blink/renderer/core/core_export.h"
 #include "third_party/blink/renderer/core/css/invalidation/invalidation_flags.h"
 #include "third_party/blink/renderer/platform/wtf/allocator.h"
-#include "third_party/blink/renderer/platform/wtf/assertions.h"
+#include "third_party/blink/renderer/platform/wtf/casting.h"
 #include "third_party/blink/renderer/platform/wtf/forward.h"
 #include "third_party/blink/renderer/platform/wtf/hash_set.h"
 #include "third_party/blink/renderer/platform/wtf/text/atomic_string_hash.h"
@@ -500,16 +500,19 @@ bool InvalidationSet::Backing<type>::IsEmpty(
   return !IsHashSet(flags) && !string_impl_;
 }
 
-DEFINE_TYPE_CASTS(DescendantInvalidationSet,
-                  InvalidationSet,
-                  value,
-                  value->IsDescendantInvalidationSet(),
-                  value.IsDescendantInvalidationSet());
-DEFINE_TYPE_CASTS(SiblingInvalidationSet,
-                  InvalidationSet,
-                  value,
-                  value->IsSiblingInvalidationSet(),
-                  value.IsSiblingInvalidationSet());
+template <>
+struct DowncastTraits<DescendantInvalidationSet> {
+  static bool AllowFrom(const InvalidationSet& value) {
+    return value.IsDescendantInvalidationSet();
+  }
+};
+
+template <>
+struct DowncastTraits<SiblingInvalidationSet> {
+  static bool AllowFrom(const InvalidationSet& value) {
+    return value.IsSiblingInvalidationSet();
+  }
+};
 
 }  // namespace blink
 

third_party/blink/renderer/core/css/invalidation/pending_invalidations.cc

@@ -102,7 +102,8 @@ void PendingInvalidations::ScheduleSiblingInvalidationsAsDescendants(
       pending_invalidations.Descendants().push_back(invalidation_set);
 
     if (DescendantInvalidationSet* descendants =
-            ToSiblingInvalidationSet(*invalidation_set).SiblingDescendants()) {
+            To<SiblingInvalidationSet>(*invalidation_set)
+                .SiblingDescendants()) {
       if (descendants->WholeSubtreeInvalid()) {
         scheduling_parent.SetNeedsStyleRecalc(
             kSubtreeStyleChange, StyleChangeReasonForTracing::Create(
@@ -130,7 +131,8 @@ void PendingInvalidations::RescheduleSiblingInvalidationsAsDescendants(
   for (const auto& invalidation_set : pending_invalidations.Siblings()) {
     invalidation_lists.descendants.push_back(invalidation_set);
     if (DescendantInvalidationSet* descendants =
-            ToSiblingInvalidationSet(*invalidation_set).SiblingDescendants()) {
+            To<SiblingInvalidationSet>(*invalidation_set)
+                .SiblingDescendants()) {
       invalidation_lists.descendants.push_back(descendants);
     }
   }

third_party/blink/renderer/core/css/invalidation/style_invalidator.cc

@@ -193,7 +193,7 @@ void StyleInvalidator::PushInvalidationSetsForContainerNode(
   for (const auto& invalidation_set : pending_invalidations.Siblings()) {
     CHECK(invalidation_set->IsAlive());
     sibling_data.PushInvalidationSet(
-        ToSiblingInvalidationSet(*invalidation_set));
+        To<SiblingInvalidationSet>(*invalidation_set));
   }
 
   if (node.GetStyleChangeType() >= kSubtreeStyleChange)

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

@@ -281,11 +281,11 @@ InvalidationSet& RuleFeatureSet::EnsureMutableInvalidationSet(
     return *invalidation_set;
 
   if (type == InvalidationType::kInvalidateDescendants)
-    return ToSiblingInvalidationSet(*invalidation_set).EnsureDescendants();
+    return To<SiblingInvalidationSet>(*invalidation_set).EnsureDescendants();
 
   scoped_refptr<InvalidationSet> descendants = invalidation_set;
   invalidation_set = SiblingInvalidationSet::Create(
-      ToDescendantInvalidationSet(descendants.get()));
+      To<DescendantInvalidationSet>(descendants.get()));
   return *invalidation_set;
 }
 
@@ -346,13 +346,14 @@ void ExtractInvalidationSets(InvalidationSet* invalidation_set,
                              DescendantInvalidationSet*& descendants,
                              SiblingInvalidationSet*& siblings) {
   CHECK(invalidation_set->IsAlive());
-  if (invalidation_set->IsDescendantInvalidationSet()) {
-    descendants = ToDescendantInvalidationSet(invalidation_set);
+  if (auto* descendant =
+          DynamicTo<DescendantInvalidationSet>(invalidation_set)) {
+    descendants = descendant;
     siblings = nullptr;
     return;
   }
 
-  siblings = ToSiblingInvalidationSet(invalidation_set);
+  siblings = To<SiblingInvalidationSet>(invalidation_set);
   descendants = siblings->Descendants();
 }
 
@@ -812,8 +813,8 @@ void RuleFeatureSet::AddFeaturesToInvalidationSetsForSimpleSelector(
       return;
     }
 
-    SiblingInvalidationSet* sibling_invalidation_set =
-        ToSiblingInvalidationSet(invalidation_set);
+    auto* sibling_invalidation_set =
+        To<SiblingInvalidationSet>(invalidation_set);
     sibling_invalidation_set->UpdateMaxDirectAdjacentSelectors(
         sibling_features->max_direct_adjacent_selectors);
     AddFeaturesToInvalidationSet(*invalidation_set, *sibling_features);
@@ -1055,12 +1056,10 @@ void RuleFeatureSet::CollectSiblingInvalidationSetForClass(
   if (it == class_invalidation_sets_.end())
     return;
 
-  InvalidationSet* invalidation_set = it->value.get();
-  if (invalidation_set->IsDescendantInvalidationSet())
+  auto* sibling_set = DynamicTo<SiblingInvalidationSet>(it->value.get());
+  if (!sibling_set)
     return;
 
-  SiblingInvalidationSet* sibling_set =
-      ToSiblingInvalidationSet(invalidation_set);
   if (sibling_set->MaxDirectAdjacentSelectors() < min_direct_adjacent)
     return;
 
@@ -1101,12 +1100,10 @@ void RuleFeatureSet::CollectSiblingInvalidationSetForId(
   if (it == id_invalidation_sets_.end())
     return;
 
-  InvalidationSet* invalidation_set = it->value.get();
-  if (invalidation_set->IsDescendantInvalidationSet())
+  auto* sibling_set = DynamicTo<SiblingInvalidationSet>(it->value.get());
+  if (!sibling_set)
     return;
 
-  SiblingInvalidationSet* sibling_set =
-      ToSiblingInvalidationSet(invalidation_set);
   if (sibling_set->MaxDirectAdjacentSelectors() < min_direct_adjacent)
     return;
 
@@ -1150,12 +1147,10 @@ void RuleFeatureSet::CollectSiblingInvalidationSetForAttribute(
   if (it == attribute_invalidation_sets_.end())
     return;
 
-  InvalidationSet* invalidation_set = it->value.get();
-  if (invalidation_set->IsDescendantInvalidationSet())
+  auto* sibling_set = DynamicTo<SiblingInvalidationSet>(it->value.get());
+  if (!sibling_set)
     return;
 
-  SiblingInvalidationSet* sibling_set =
-      ToSiblingInvalidationSet(invalidation_set);
   if (sibling_set->MaxDirectAdjacentSelectors() < min_direct_adjacent)
     return;
 

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

@@ -206,8 +206,8 @@ class RuleFeatureSetTest : public testing::Test {
       const AtomicString& sibling_name,
       InvalidationSetVector& invalidation_sets) {
     EXPECT_EQ(1u, invalidation_sets.size());
-    const SiblingInvalidationSet& sibling_invalidation_set =
-        ToSiblingInvalidationSet(*invalidation_sets[0]);
+    const auto& sibling_invalidation_set =
+        To<SiblingInvalidationSet>(*invalidation_sets[0]);
     HashSet<AtomicString> classes = ClassSet(sibling_invalidation_set);
     EXPECT_EQ(1u, classes.size());
     EXPECT_TRUE(classes.Contains(sibling_name));
@@ -219,8 +219,8 @@ class RuleFeatureSetTest : public testing::Test {
                                    const AtomicString& sibling_name,
                                    InvalidationSetVector& invalidation_sets) {
     EXPECT_EQ(1u, invalidation_sets.size());
-    const SiblingInvalidationSet& sibling_invalidation_set =
-        ToSiblingInvalidationSet(*invalidation_sets[0]);
+    const auto& sibling_invalidation_set =
+        To<SiblingInvalidationSet>(*invalidation_sets[0]);
     HashSet<AtomicString> ids = IdSet(*invalidation_sets[0]);
     EXPECT_EQ(1u, ids.size());
     EXPECT_TRUE(ids.Contains(sibling_name));
@@ -234,8 +234,8 @@ class RuleFeatureSetTest : public testing::Test {
       const AtomicString& descendant_name,
       InvalidationSetVector& invalidation_sets) {
     EXPECT_EQ(1u, invalidation_sets.size());
-    const SiblingInvalidationSet& sibling_invalidation_set =
-        ToSiblingInvalidationSet(*invalidation_sets[0]);
+    const auto& sibling_invalidation_set =
+        To<SiblingInvalidationSet>(*invalidation_sets[0]);
     HashSet<AtomicString> classes = ClassSet(sibling_invalidation_set);
     EXPECT_EQ(1u, classes.size());
     EXPECT_TRUE(classes.Contains(sibling_name));
@@ -317,8 +317,8 @@ class RuleFeatureSetTest : public testing::Test {
       // For SiblingInvalidationSets, we also require that the inner
       // InvalidationSets either don't exist, or have a refcount of 1.
       if (it->value->IsSiblingInvalidationSet()) {
-        const SiblingInvalidationSet& sibling_invalidation_set =
-            ToSiblingInvalidationSet(*it->value);
+        const auto& sibling_invalidation_set =
+            To<SiblingInvalidationSet>(*it->value);
         bool sibling_descendants_has_one_ref =
             !sibling_invalidation_set.SiblingDescendants() ||
             sibling_invalidation_set.SiblingDescendants()->HasOneRef();