CSS: Make ~InvalidationSet protected

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 18 matching lines @@
  */
 
 #ifndef InvalidationSet_h
 #define InvalidationSet_h
 
 #include "core/CoreExport.h"
 #include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/Forward.h"
 #include "wtf/HashSet.h"
-#include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
 #include "wtf/text/AtomicStringHash.h"
 #include "wtf/text/StringHash.h"
 #include <memory>
 
 namespace blink {
 
 class Element;
 class TracedValue;
 
@@ skipping 21 matching lines @@
 //
 // .v * {}
 //   For class v we will have a DescendantInvalidationSet with wholeSubtreeInvalid.
 //
 // .u ~ * {}
 //   For class u we will have a SiblingInvalidationSet with wholeSubtreeInvalid and invalidatesSelf (for all siblings, the sibling itself is invalidated).
 //
 // .t .v, .t ~ .z {}
 //   For class t we will have a SiblingInvalidationSet containing class z, with the SiblingInvalidationSet also holding descendants containing class v.
 //
-class CORE_EXPORT InvalidationSet : public RefCounted<InvalidationSet> {
+// We avoid virtual functions to minimize space consumption.
+class CORE_EXPORT InvalidationSet {
     WTF_MAKE_NONCOPYABLE(InvalidationSet);
     USING_FAST_MALLOC_WITH_TYPE_NAME(blink::InvalidationSet);
 public:
     InvalidationType type() const { return static_cast<InvalidationType>(m_type); }
     bool isDescendantInvalidationSet() const { return type() == InvalidateDescendants; }
     bool isSiblingInvalidationSet() const { return type() == InvalidateSiblings; }
 
     static void cacheTracingFlag();
 
     bool invalidatesElement(Element&) const;
@@ skipping 24 matching lines @@
     bool isEmpty() const { return !m_classes && !m_ids && !m_tagNames && !m_attributes && !m_customPseudoInvalid && !m_insertionPointCrossing && !m_invalidatesSlotted; }
 
     bool isAlive() const { return m_isAlive; }
 
     void toTracedValue(TracedValue*) const;
 
 #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; }
+    const HashSet<AtomicString>& classSetForTesting() const { DCHECK(m_classes); return *m_classes; }
+    const HashSet<AtomicString>& idSetForTesting() const { DCHECK(m_ids); return *m_ids; }
+    const HashSet<AtomicString>& tagNameSetForTesting() const { DCHECK(m_tagNames); return *m_tagNames; }
+    const HashSet<AtomicString>& attributeSetForTesting() const { DCHECK(m_attributes); return *m_attributes; }
 
+    void ref() { ++m_refCount; }
     void deref()
     {
-        if (!derefBase())
-            return;
-        destroy();
+        DCHECK_GT(m_refCount, 0);
+        --m_refCount;
+        if (!m_refCount)
+            destroy();
     }
 
     void combine(const InvalidationSet& other);
 
+protected:
+    explicit InvalidationSet(InvalidationType);
+
     ~InvalidationSet()
     {
         RELEASE_ASSERT(m_isAlive);
         m_isAlive = false;
     }
 
-protected:
-    explicit InvalidationSet(InvalidationType);
-
 private:
     void destroy();
 
     HashSet<AtomicString>& ensureClassSet();
     HashSet<AtomicString>& ensureIdSet();
     HashSet<AtomicString>& ensureTagNameSet();
     HashSet<AtomicString>& ensureAttributeSet();
 
+    // Implement reference counting manually so we can call a derived
+    // class destructor when the reference count decreases to 0.
+    // If we use RefCounted instead, at least one of our compilers
+    // requires the ability for RefCounted<InvalidationSet>::deref()
+    // to call ~InvalidationSet(), but this is not a virtual call.
+    int m_refCount;
+
     // FIXME: optimize this if it becomes a memory issue.
     std::unique_ptr<HashSet<AtomicString>> m_classes;
     std::unique_ptr<HashSet<AtomicString>> m_ids;
     std::unique_ptr<HashSet<AtomicString>> m_tagNames;
     std::unique_ptr<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;
@@ skipping 65 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