CSS Invalidation: Avoid virtual functions in InvalidationSet

third_party/WebKit/Source/core/css/invalidation/InvalidationSet.h

 /*
  * Copyright (C) 2014 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 38 matching lines @@
 enum InvalidationType {
     InvalidateDescendants,
     InvalidateSiblings
 };
 
 // Tracks data to determine which descendants in a DOM subtree, or
 // siblings and their descendants, need to have style recalculated.
 class CORE_EXPORT InvalidationSet : public RefCounted<InvalidationSet> {
     WTF_MAKE_NONCOPYABLE(InvalidationSet);
 public:
-    virtual ~InvalidationSet() {}
-
-    virtual bool isDescendantInvalidationSet() const { return false; }
-    virtual bool isSiblingInvalidationSet() const { return false; }
+    bool isDescendantInvalidationSet() const { return m_type == InvalidateDescendants; }
+    bool isSiblingInvalidationSet() const { return m_type == InvalidateSiblings; }
 
     static void cacheTracingFlag();
 
     bool invalidatesElement(Element&) const;
 
     void addClass(const AtomicString& className);
     void addId(const AtomicString& id);
     void addTagName(const AtomicString& tagName);
     void addAttribute(const AtomicString& attributeLocalName);
 
@@ skipping 18 matching lines @@
 
 #ifndef NDEBUG
     void show() const;
 #endif
 
     const HashSet<AtomicString>& classSetForTesting() const { ASSERT(m_classes); return *m_classes; }
     const HashSet<AtomicString>& idSetForTesting() const { ASSERT(m_ids); return *m_ids; }
     const HashSet<AtomicString>& tagNameSetForTesting() const { ASSERT(m_tagNames); return *m_tagNames; }
     const HashSet<AtomicString>& attributeSetForTesting() const { ASSERT(m_attributes); return *m_attributes; }
 
+    void deref()
+    {
+        if (!derefBase())
+            return;
+        destroy();
+    }
+
 protected:
-    InvalidationSet();
+    InvalidationSet(InvalidationType);
 
     void combine(const InvalidationSet& other);
 
 private:
+    void destroy();
+
     HashSet<AtomicString>& ensureClassSet();
     HashSet<AtomicString>& ensureIdSet();
     HashSet<AtomicString>& ensureTagNameSet();
     HashSet<AtomicString>& ensureAttributeSet();
 
     // FIXME: optimize this if it becomes a memory issue.
     OwnPtr<HashSet<AtomicString>> m_classes;
     OwnPtr<HashSet<AtomicString>> m_ids;
     OwnPtr<HashSet<AtomicString>> m_tagNames;
     OwnPtr<HashSet<AtomicString>> m_attributes;
 
+    unsigned m_type : 1;
+
     // If true, all descendants might be invalidated, so a full subtree recalc is required.
     unsigned m_allDescendantsMightBeInvalid : 1;
 
     // If true, the element itself is invalid.
     unsigned m_invalidatesSelf : 1;
 
     // If true, all descendants which are custom pseudo elements must be invalidated.
     unsigned m_customPseudoInvalid : 1;
 
     // If true, the invalidation must traverse into ShadowRoots with this set.
     unsigned m_treeBoundaryCrossing : 1;
 
     // If true, insertion point descendants must be invalidated.
     unsigned m_insertionPointCrossing : 1;
 };
 
 class CORE_EXPORT DescendantInvalidationSet final : public InvalidationSet {
 public:
     static PassRefPtr<DescendantInvalidationSet> create()
     {
         return adoptRef(new DescendantInvalidationSet);
     }
 
-    bool isDescendantInvalidationSet() const final { return true; }
-
     void combine(const DescendantInvalidationSet& other)
     {
         InvalidationSet::combine(other);
     }
 
 private:
-    DescendantInvalidationSet() {}
+    DescendantInvalidationSet()
+        : InvalidationSet(InvalidateDescendants) {}
 };
 
 class CORE_EXPORT SiblingInvalidationSet final : public InvalidationSet {
 public:
     static PassRefPtr<SiblingInvalidationSet> create()
     {
         return adoptRef(new SiblingInvalidationSet);
     }
 
-    bool isSiblingInvalidationSet() const final { return true; }
-
     void combine(const SiblingInvalidationSet& other);
 
     DescendantInvalidationSet& descendants() { return *m_descendantInvalidationSet; }
     const DescendantInvalidationSet& descendants() const { return *m_descendantInvalidationSet; }
 
     unsigned maxDirectAdjacentSelectors() const { return m_maxDirectAdjacentSelectors; }
     void updateMaxDirectAdjacentSelectors(unsigned value) { m_maxDirectAdjacentSelectors = std::max(value, m_maxDirectAdjacentSelectors); }
 
 private:
     SiblingInvalidationSet();
@@ skipping 11 matching lines @@
     InvalidationSetVector descendants;
     InvalidationSetVector siblings;
 };
 
 DEFINE_TYPE_CASTS(DescendantInvalidationSet, InvalidationSet, value, value->isDescendantInvalidationSet(), value.isDescendantInvalidationSet());
 DEFINE_TYPE_CASTS(SiblingInvalidationSet, InvalidationSet, value, value->isSiblingInvalidationSet(), value.isSiblingInvalidationSet());
 
 } // namespace blink
 
 #endif // InvalidationSet_h