Implicit prefinalizer registration.

third_party/WebKit/Source/platform/heap/HeapTest.cpp

 /*
  * Copyright (C) 2013 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 1142 matching lines @@
     : public GarbageCollectedFinalized<ObservableWithPreFinalizer> {
   USING_PRE_FINALIZER(ObservableWithPreFinalizer, dispose);
 
  public:
   static ObservableWithPreFinalizer* create() {
     return new ObservableWithPreFinalizer();
   }
   ~ObservableWithPreFinalizer() { m_wasDestructed = true; }
   DEFINE_INLINE_TRACE() {}
   void dispose() {
-    ThreadState::current()->unregisterPreFinalizer(this);
     EXPECT_FALSE(m_wasDestructed);
     s_disposeWasCalled = true;
   }
   static bool s_disposeWasCalled;
 
  protected:
   ObservableWithPreFinalizer() : m_wasDestructed(false) {
-    ThreadState::current()->registerPreFinalizer(this);
   }
 
   bool m_wasDestructed;
 };
 
 bool ObservableWithPreFinalizer::s_disposeWasCalled = false;
 
 bool s_disposeWasCalledForPreFinalizerBase = false;
 bool s_disposeWasCalledForPreFinalizerMixin = false;
 bool s_disposeWasCalledForPreFinalizerSubClass = false;
 
 class PreFinalizerBase : public GarbageCollectedFinalized<PreFinalizerBase> {
   USING_PRE_FINALIZER(PreFinalizerBase, dispose);
 
  public:
   static PreFinalizerBase* create() { return new PreFinalizerBase(); }
   virtual ~PreFinalizerBase() { m_wasDestructed = true; }
   DEFINE_INLINE_VIRTUAL_TRACE() {}
   void dispose() {
     EXPECT_FALSE(s_disposeWasCalledForPreFinalizerBase);
     EXPECT_TRUE(s_disposeWasCalledForPreFinalizerSubClass);
     EXPECT_TRUE(s_disposeWasCalledForPreFinalizerMixin);
     EXPECT_FALSE(m_wasDestructed);
     s_disposeWasCalledForPreFinalizerBase = true;
   }
 
  protected:
   PreFinalizerBase() : m_wasDestructed(false) {
-    ThreadState::current()->registerPreFinalizer(this);
   }
   bool m_wasDestructed;
 };
 
 class PreFinalizerMixin : public GarbageCollectedMixin {
   USING_PRE_FINALIZER(PreFinalizerMixin, dispose);
 
  public:
   ~PreFinalizerMixin() { m_wasDestructed = true; }
   DEFINE_INLINE_VIRTUAL_TRACE() {}
   void dispose() {
     EXPECT_FALSE(s_disposeWasCalledForPreFinalizerBase);
     EXPECT_TRUE(s_disposeWasCalledForPreFinalizerSubClass);
     EXPECT_FALSE(s_disposeWasCalledForPreFinalizerMixin);
     EXPECT_FALSE(m_wasDestructed);
     s_disposeWasCalledForPreFinalizerMixin = true;
   }
 
  protected:
   PreFinalizerMixin() : m_wasDestructed(false) {
-    ThreadState::current()->registerPreFinalizer(this);
   }
   bool m_wasDestructed;
 };
 
 class PreFinalizerSubClass : public PreFinalizerBase, public PreFinalizerMixin {
   USING_GARBAGE_COLLECTED_MIXIN(PreFinalizerSubClass);
   USING_PRE_FINALIZER(PreFinalizerSubClass, dispose);
 
  public:
   static PreFinalizerSubClass* create() { return new PreFinalizerSubClass(); }
   ~PreFinalizerSubClass() { m_wasDestructed = true; }
   DEFINE_INLINE_VIRTUAL_TRACE() {}
   void dispose() {
     EXPECT_FALSE(s_disposeWasCalledForPreFinalizerBase);
     EXPECT_FALSE(s_disposeWasCalledForPreFinalizerSubClass);
     EXPECT_FALSE(s_disposeWasCalledForPreFinalizerMixin);
     EXPECT_FALSE(m_wasDestructed);
     s_disposeWasCalledForPreFinalizerSubClass = true;
   }
 
  protected:
   PreFinalizerSubClass() : m_wasDestructed(false) {
-    ThreadState::current()->registerPreFinalizer(this);
   }
   bool m_wasDestructed;
 };
 
 template <typename T>
 class FinalizationObserver : public GarbageCollected<FinalizationObserver<T>> {
  public:
   static FinalizationObserver* create(T* data) {
     return new FinalizationObserver(data);
   }
@@ skipping 299 matching lines @@
   Persistent<IntWrapper>* m_wrapper;
 };
 
 class PreFinalizationAllocator
     : public GarbageCollectedFinalized<PreFinalizationAllocator> {
   USING_PRE_FINALIZER(PreFinalizationAllocator, dispose);
 
  public:
   PreFinalizationAllocator(Persistent<IntWrapper>* wrapper)
       : m_wrapper(wrapper) {
-    ThreadState::current()->registerPreFinalizer(this);
   }
 
   void dispose() {
     for (int i = 0; i < 10; ++i)
       *m_wrapper = IntWrapper::create(42);
     for (int i = 0; i < 512; ++i)
       new OneKiloByteObject();
     for (int i = 0; i < 32; ++i)
       LargeHeapObject::create();
   }
@@ skipping 2299 matching lines @@
   preciselyCollectGarbage();
   EXPECT_EQ(0u, Bar::s_live);
   EXPECT_EQ(0u, map.size());
   EXPECT_TRUE(FinalizationObserverWithHashMap::s_didCallWillFinalize);
 
   FinalizationObserverWithHashMap::clearObservers();
 }
 
 TEST(HeapTest, PreFinalizer) {
   Observable::s_willFinalizeWasCalled = false;
-  {
-    Observable* foo = Observable::create(Bar::create());
-    ThreadState::current()->registerPreFinalizer(foo);
-  }
+  { Observable::create(Bar::create()); }
   preciselyCollectGarbage();
   EXPECT_TRUE(Observable::s_willFinalizeWasCalled);
 }
 
-TEST(HeapTest, PreFinalizerIsNotCalledIfUnregistered) {
-  Observable::s_willFinalizeWasCalled = false;
-  {
-    Observable* foo = Observable::create(Bar::create());
-    ThreadState::current()->registerPreFinalizer(foo);
-    ThreadState::current()->unregisterPreFinalizer(foo);
-  }
-  preciselyCollectGarbage();
-  EXPECT_FALSE(Observable::s_willFinalizeWasCalled);
-}
-
 TEST(HeapTest, PreFinalizerUnregistersItself) {
   ObservableWithPreFinalizer::s_disposeWasCalled = false;
   ObservableWithPreFinalizer::create();
   preciselyCollectGarbage();
   EXPECT_TRUE(ObservableWithPreFinalizer::s_disposeWasCalled);
   // Don't crash, and assertions don't fail.
 }
 
 TEST(HeapTest, NestedPreFinalizer) {
   s_disposeWasCalledForPreFinalizerBase = false;
@@ skipping 2894 matching lines @@
       "HeapVector");
   static_assert(
       WTF::IsGarbageCollectedType<HeapDeque<Member<IntWrapper>>>::value,
       "HeapDeque");
   static_assert(WTF::IsGarbageCollectedType<
                     HeapTerminatedArray<Member<IntWrapper>>>::value,
                 "HeapTerminatedArray");
 }
 
 }  // namespace blink