heap,wtf: Make FinalizerTrait a GC-internal concept

There's no particular reason FinalizerTrait needs to be overridable
for user code. The concepts that should be used are:
- T::FinalizeGarbageCollectedObject: Method that can dispatch
  finalization when virtual dtor is too expensive.
- WTF::ConditionalDestructor: Conditionally adding/removing dtor per
  type.

Bug: 1056170
Change-Id: I61ecef0392f4b1399b7311ff1b9acfeef18da2da
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2107593
Commit-Queue: Michael Lippautz <mlippautz@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Omer Katz <omerkatz@chromium.org>
Cr-Commit-Position: refs/heads/master@{#761886}

third_party/blink/renderer/platform/heap/blink_gc.h

@@ -21,7 +21,6 @@ class Visitor;
 using Address = uint8_t*;
 using ConstAddress = const uint8_t*;
 
-using FinalizationCallback = void (*)(void*);
 using VisitorCallback = void (*)(Visitor*, const void*);
 using MarkingVisitorCallback = void (*)(MarkingVisitor*, const void*);
 using TraceCallback = VisitorCallback;

third_party/blink/renderer/platform/heap/collection_support/heap_hash_table_backing.h

@@ -9,11 +9,15 @@
 #include "third_party/blink/renderer/platform/heap/threading_traits.h"
 #include "third_party/blink/renderer/platform/heap/trace_traits.h"
 #include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
+#include "third_party/blink/renderer/platform/wtf/conditional_destructor.h"
 
 namespace blink {
 
 template <typename Table>
-class HeapHashTableBacking {
+class HeapHashTableBacking final
+    : public WTF::ConditionalDestructor<
+          HeapHashTableBacking<Table>,
+          std::is_trivially_destructible<typename Table::ValueType>::value> {
   DISALLOW_NEW();
   IS_GARBAGE_COLLECTED_TYPE();
 
@@ -21,8 +25,7 @@ class HeapHashTableBacking {
   template <typename Backing>
   static void* AllocateObject(size_t size);
 
-  static void Finalize(void* pointer);
-  void FinalizeGarbageCollectedObject() { Finalize(this); }
+  void Finalize();
 };
 
 template <typename Table>
@@ -51,16 +54,16 @@ void* HeapHashTableBacking<Table>::AllocateObject(size_t size) {
 }
 
 template <typename Table>
-void HeapHashTableBacking<Table>::Finalize(void* pointer) {
+void HeapHashTableBacking<Table>::Finalize() {
   using Value = typename Table::ValueType;
   static_assert(
       !std::is_trivially_destructible<Value>::value,
       "Finalization of trivially destructible classes should not happen.");
-  HeapObjectHeader* header = HeapObjectHeader::FromPayload(pointer);
+  HeapObjectHeader* header = HeapObjectHeader::FromPayload(this);
   // Use the payload size as recorded by the heap to determine how many
   // elements to finalize.
   size_t length = header->PayloadSize() / sizeof(Value);
-  Value* table = reinterpret_cast<Value*>(pointer);
+  Value* table = reinterpret_cast<Value*>(this);
   for (unsigned i = 0; i < length; ++i) {
     if (!Table::IsEmptyOrDeletedBucket(table[i]))
       table[i].~Value();
@@ -83,17 +86,6 @@ struct MakeGarbageCollectedTrait<HeapHashTableBacking<Table>> {
   }
 };
 
-template <typename Table>
-struct FinalizerTrait<HeapHashTableBacking<Table>> {
-  STATIC_ONLY(FinalizerTrait);
-  static const bool kNonTrivialFinalizer =
-      !std::is_trivially_destructible<typename Table::ValueType>::value;
-  static void Finalize(void* obj) {
-    internal::FinalizerTraitImpl<HeapHashTableBacking<Table>,
-                                 kNonTrivialFinalizer>::Finalize(obj);
-  }
-};
-
 // The trace trait for the heap hashtable backing is used when we find a
 // direct pointer to the backing from the conservative stack scanner. This
 // normally indicates that there is an ongoing iteration over the table, and so

third_party/blink/renderer/platform/heap/collection_support/heap_vector_backing.h

@@ -9,15 +9,19 @@
 #include "third_party/blink/renderer/platform/heap/finalizer_traits.h"
 #include "third_party/blink/renderer/platform/heap/gc_info.h"
 #include "third_party/blink/renderer/platform/heap/heap.h"
+#include "third_party/blink/renderer/platform/heap/heap_allocator.h"
 #include "third_party/blink/renderer/platform/heap/thread_state.h"
 #include "third_party/blink/renderer/platform/heap/threading_traits.h"
 #include "third_party/blink/renderer/platform/heap/trace_traits.h"
+#include "third_party/blink/renderer/platform/wtf/conditional_destructor.h"
 #include "third_party/blink/renderer/platform/wtf/vector.h"
 
 namespace blink {
 
 template <typename T, typename Traits = WTF::VectorTraits<T>>
-class HeapVectorBacking final {
+class HeapVectorBacking final
+    : public WTF::ConditionalDestructor<HeapVectorBacking<T, Traits>,
+                                        !Traits::kNeedsDestruction> {
   DISALLOW_NEW();
   IS_GARBAGE_COLLECTED_TYPE();
 
@@ -33,12 +37,12 @@ class HeapVectorBacking final {
         type_name);
   }
 
-  static void Finalize(void* pointer);
-  void FinalizeGarbageCollectedObject() { Finalize(this); }
+  // Conditionally invoked via destructor.
+  void Finalize();
 };
 
 template <typename T, typename Traits>
-void HeapVectorBacking<T, Traits>::Finalize(void* pointer) {
+void HeapVectorBacking<T, Traits>::Finalize() {
   static_assert(Traits::kNeedsDestruction,
                 "Only vector buffers with items requiring destruction should "
                 "be finalized");
@@ -50,11 +54,11 @@ void HeapVectorBacking<T, Traits>::Finalize(void* pointer) {
   static_assert(
       !std::is_trivially_destructible<T>::value,
       "Finalization of trivially destructible classes should not happen.");
-  HeapObjectHeader* header = HeapObjectHeader::FromPayload(pointer);
+  HeapObjectHeader* header = HeapObjectHeader::FromPayload(this);
   // Use the payload size as recorded by the heap to determine how many
   // elements to finalize.
   size_t length = header->PayloadSize() / sizeof(T);
-  char* payload = static_cast<char*>(pointer);
+  Address payload = header->Payload();
 #ifdef ANNOTATE_CONTIGUOUS_CONTAINER
   ANNOTATE_CHANGE_SIZE(payload, length * sizeof(T), 0, length * sizeof(T));
 #endif
@@ -62,7 +66,7 @@ void HeapVectorBacking<T, Traits>::Finalize(void* pointer) {
   // (which are already zeroed out).
   if (std::is_polymorphic<T>::value) {
     for (unsigned i = 0; i < length; ++i) {
-      char* element = payload + i * sizeof(T);
+      Address element = payload + i * sizeof(T);
       if (blink::VTableInitialized(element))
         reinterpret_cast<T*>(element)->~T();
     }
@@ -88,16 +92,6 @@ struct MakeGarbageCollectedTrait<HeapVectorBacking<T>> {
   }
 };
 
-template <typename T, typename Traits>
-struct FinalizerTrait<HeapVectorBacking<T, Traits>> {
-  STATIC_ONLY(FinalizerTrait);
-  static const bool kNonTrivialFinalizer = Traits::kNeedsDestruction;
-  static void Finalize(void* obj) {
-    internal::FinalizerTraitImpl<HeapVectorBacking<T, Traits>,
-                                 kNonTrivialFinalizer>::Finalize(obj);
-  }
-};
-
 template <typename T, typename Traits>
 struct ThreadingTrait<HeapVectorBacking<T, Traits>> {
   STATIC_ONLY(ThreadingTrait);

third_party/blink/renderer/platform/heap/finalizer_traits.h

@@ -8,19 +8,13 @@
 #include <type_traits>
 
 #include "base/template_util.h"
-#include "third_party/blink/renderer/platform/heap/garbage_collected.h"
-
-namespace WTF {
-
-template <typename ValueArg, typename Allocator>
-class ListHashSetNode;
-
-}  // namespace WTF
+#include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
 
 namespace blink {
-
 namespace internal {
 
+using FinalizationCallback = void (*)(void*);
+
 template <typename T, typename = void>
 struct HasFinalizeGarbageCollectedObject : std::false_type {};
 
@@ -75,66 +69,27 @@ struct FinalizerTraitImpl<T, false> {
   }
 };
 
-}  // namespace internal
-
 // The FinalizerTrait is used to determine if a type requires finalization and
 // what finalization means.
 template <typename T>
 struct FinalizerTrait {
   STATIC_ONLY(FinalizerTrait);
+
+ private:
   static constexpr bool kNonTrivialFinalizer =
       internal::HasFinalizeGarbageCollectedObject<T>::value ||
       !std::is_trivially_destructible<typename std::remove_cv<T>::type>::value;
-  static void Finalize(void* obj) {
-    internal::FinalizerTraitImpl<T, kNonTrivialFinalizer>::Finalize(obj);
-  }
-};
-
-class HeapAllocator;
-
-template <typename T, typename U, typename V>
-struct FinalizerTrait<LinkedHashSet<T, U, V, HeapAllocator>> {
-  STATIC_ONLY(FinalizerTrait);
-  static constexpr bool kNonTrivialFinalizer = true;
-  static void Finalize(void* obj) {
-    internal::FinalizerTraitImpl<LinkedHashSet<T, U, V, HeapAllocator>,
-                                 kNonTrivialFinalizer>::Finalize(obj);
-  }
-};
 
-template <typename T, typename Allocator>
-struct FinalizerTrait<WTF::ListHashSetNode<T, Allocator>> {
-  STATIC_ONLY(FinalizerTrait);
-  static constexpr bool kNonTrivialFinalizer =
-      !std::is_trivially_destructible<T>::value;
   static void Finalize(void* obj) {
-    internal::FinalizerTraitImpl<WTF::ListHashSetNode<T, Allocator>,
-                                 kNonTrivialFinalizer>::Finalize(obj);
-  }
-};
-
-template <typename T, size_t inlineCapacity>
-struct FinalizerTrait<Vector<T, inlineCapacity, HeapAllocator>> {
-  STATIC_ONLY(FinalizerTrait);
-  static constexpr bool kNonTrivialFinalizer =
-      inlineCapacity && VectorTraits<T>::kNeedsDestruction;
-  static void Finalize(void* obj) {
-    internal::FinalizerTraitImpl<Vector<T, inlineCapacity, HeapAllocator>,
-                                 kNonTrivialFinalizer>::Finalize(obj);
+    internal::FinalizerTraitImpl<T, kNonTrivialFinalizer>::Finalize(obj);
   }
-};
 
-template <typename T, size_t inlineCapacity>
-struct FinalizerTrait<Deque<T, inlineCapacity, HeapAllocator>> {
-  STATIC_ONLY(FinalizerTrait);
-  static const bool kNonTrivialFinalizer =
-      inlineCapacity && VectorTraits<T>::kNeedsDestruction;
-  static void Finalize(void* obj) {
-    internal::FinalizerTraitImpl<Deque<T, inlineCapacity, HeapAllocator>,
-                                 kNonTrivialFinalizer>::Finalize(obj);
-  }
+ public:
+  static constexpr FinalizationCallback kCallback =
+      kNonTrivialFinalizer ? Finalize : nullptr;
 };
 
+}  // namespace internal
 }  // namespace blink
 
 #endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_FINALIZER_TRAITS_H_

third_party/blink/renderer/platform/heap/gc_info.h

@@ -7,8 +7,10 @@
 
 #include <atomic>
 #include "base/gtest_prod_util.h"
+#include "third_party/blink/renderer/platform/heap/blink_gc.h"
 #include "third_party/blink/renderer/platform/heap/finalizer_traits.h"
 #include "third_party/blink/renderer/platform/heap/name_traits.h"
+#include "third_party/blink/renderer/platform/wtf/threading_primitives.h"
 
 namespace blink {
 
@@ -23,7 +25,7 @@ struct PLATFORM_EXPORT GCInfo final {
   static inline const GCInfo& From(GCInfoIndex);
 
   const TraceCallback trace;
-  const FinalizationCallback finalize;
+  const internal::FinalizationCallback finalize;
   const NameCallback name;
   const bool has_v_table;
 };
@@ -102,9 +104,7 @@ struct GCInfoTrait {
   static GCInfoIndex Index() {
     static_assert(sizeof(T), "T must be fully defined");
     static const GCInfo kGcInfo = {
-        TraceTrait<T>::Trace,
-        FinalizerTrait<T>::kNonTrivialFinalizer ? FinalizerTrait<T>::Finalize
-                                                : nullptr,
+        TraceTrait<T>::Trace, internal::FinalizerTrait<T>::kCallback,
         NameTrait<T>::GetName, std::is_polymorphic<T>::value};
     // This is more complicated than using threadsafe initialization, but this
     // is instantiated many times (once for every GC type).

third_party/blink/renderer/platform/wtf/deque.h

@@ -52,11 +52,15 @@ class DequeConstIterator;
 template <typename T,
           wtf_size_t inlineCapacity = 0,
           typename Allocator = PartitionAllocator>
-class Deque : public ConditionalDestructor<Deque<T, INLINE_CAPACITY, Allocator>,
-                                           (INLINE_CAPACITY == 0) &&
-                                               Allocator::kIsGarbageCollected> {
+class Deque
+    : public ConditionalDestructor<Deque<T, INLINE_CAPACITY, Allocator>,
+                                   !VectorTraits<T>::kNeedsDestruction &&
+                                       Allocator::kIsGarbageCollected> {
   USE_ALLOCATOR(Deque, Allocator);
 
+  static_assert((inlineCapacity == 0) || !Allocator::kIsGarbageCollected,
+                "inlineCapacity not supported with garbage collection.");
+
  public:
   typedef DequeIterator<T, inlineCapacity, Allocator> iterator;
   typedef DequeConstIterator<T, inlineCapacity, Allocator> const_iterator;

third_party/blink/renderer/platform/wtf/linked_hash_set.h

@@ -262,11 +262,6 @@ class LinkedHashSet {
   // Needs finalization. The anchor needs to unlink itself from the chain.
   ~LinkedHashSet();
 
-  static void Finalize(void* pointer) {
-    reinterpret_cast<LinkedHashSet*>(pointer)->~LinkedHashSet();
-  }
-  void FinalizeGarbageCollectedObject() { Finalize(this); }
-
   void Swap(LinkedHashSet&);
 
   unsigned size() const { return impl_.size(); }

third_party/blink/renderer/platform/wtf/list_hash_set.h

@@ -24,6 +24,7 @@
 #define THIRD_PARTY_BLINK_RENDERER_PLATFORM_WTF_LIST_HASH_SET_H_
 
 #include <memory>
+#include <type_traits>
 #include "third_party/blink/renderer/platform/wtf/allocator/partition_allocator.h"
 #include "third_party/blink/renderer/platform/wtf/conditional_destructor.h"
 #include "third_party/blink/renderer/platform/wtf/hash_set.h"
@@ -454,7 +455,19 @@ struct ListHashSetAllocator : public PartitionAllocator {
 };
 
 template <typename ValueArg, typename AllocatorArg>
-class ListHashSetNode : public ListHashSetNodeBase<ValueArg, AllocatorArg> {
+class ListHashSetNode
+    : public ListHashSetNodeBase<ValueArg, AllocatorArg>,
+      // Destruction handling:
+      // !AllocatorArg::kIsGarbageCollected (PartitionAlloc):
+      // - ListHashSet has destructor and manually destructs all nodes.
+      // - ListHashSetNode has no destructor.
+      // AllocatorArg::kIsGarbageCollected (Oilpan):
+      // - ListHashSet has no destructor.
+      // - ListHashSetNode has a destructor if it is not trivially destructible.
+      public ConditionalDestructor<
+          ListHashSetNode<ValueArg, AllocatorArg>,
+          !AllocatorArg::kIsGarbageCollected ||
+              std::is_trivially_destructible<ValueArg>::value> {
  public:
   typedef AllocatorArg NodeAllocator;
   typedef ValueArg Value;
@@ -481,12 +494,12 @@ class ListHashSetNode : public ListHashSetNodeBase<ValueArg, AllocatorArg> {
     return this->prev_ == UnlinkedNodePointer();
   }
 
-  static void Finalize(void* pointer) {
+  void Finalize() {
     // No need to waste time calling finalize if it's not needed.
     static_assert(
         !std::is_trivially_destructible<ValueArg>::value,
         "Finalization of trivially destructible classes should not happen.");
-    ListHashSetNode* self = reinterpret_cast_ptr<ListHashSetNode*>(pointer);
+    ListHashSetNode* self = reinterpret_cast_ptr<ListHashSetNode*>(this);
 
     // Check whether this node was already destructed before being unlinked
     // from the collection.
@@ -495,7 +508,6 @@ class ListHashSetNode : public ListHashSetNodeBase<ValueArg, AllocatorArg> {
 
     self->value_.~ValueArg();
   }
-  void FinalizeGarbageCollectedObject() { Finalize(this); }
 
   void Destroy(NodeAllocator* allocator) {
     this->~ListHashSetNode();

third_party/blink/renderer/platform/wtf/vector.h

@@ -1054,6 +1054,10 @@ class VectorBuffer : protected VectorBufferBase<T, Allocator> {
 template <typename T, wtf_size_t inlineCapacity, typename Allocator>
 class Vector
     : private VectorBuffer<T, INLINE_CAPACITY, Allocator>,
+      // ConditionalDestructor could in addition check for
+      // VectorTraits<T>::kNeedsDestruction which requires that the complete
+      // type is available though. Unfortunately, there's some use cases that
+      // use Vector with foward-declared types.
       public ConditionalDestructor<Vector<T, INLINE_CAPACITY, Allocator>,
                                    (INLINE_CAPACITY == 0) &&
                                        Allocator::kIsGarbageCollected> {