Experimental: How to implement willFinalize()?

Source/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 513 matching lines @@
     {
         return new Bar();
     }
 
     void finalize()
     {
         EXPECT_TRUE(m_magic == magic);
         m_magic = 0;
         s_live--;
     }
+    bool isLive() const { return m_magic; }
 
     virtual void trace(Visitor* visitor) { }
     static unsigned s_live;
 
 protected:
     static const int magic = 1337;
     int m_magic;
 
     Bar()
         : m_magic(magic)
@@ skipping 11 matching lines @@
         return new Baz(bar);
     }
 
     void trace(Visitor* visitor)
     {
         visitor->trace(m_bar);
     }
 
     void clear() { m_bar.release(); }
 
+    // willFinalize is called before finalize()/destructor.
+    void willFinalize()
+    {
+        EXPECT_TRUE(m_bar->isLive());
+        EXPECT_EQ(1u, Bar::s_live);
+    }
+
 private:
     explicit Baz(Bar* bar)
         : m_bar(bar)
     {
     }
 
     Member<Bar> m_bar;
 };
 
 class Foo : public Bar {
@@ skipping 283 matching lines @@
         : Bar()
         , m_strongBar(strongBar)
         , m_weakBar(weakBar)
     {
     }
 
     Member<Bar> m_strongBar;
     WeakMember<Bar> m_weakBar;
 };
 
+// FIXME: This should be moved to heap/Handle.h.
+template <typename T> class Observer : public GarbageCollected<Observer<T> > {
+public:
+    static Observer* create(T* data) { return new Observer(data); }
+
+    void trace(Visitor* visitor)
+    {
+        visitor->registerWeakMembers(this, zapWeakMembers);
+    }
+
+    static void zapWeakMembers(Visitor* visitor, void* self)
+    {
+        Observer* o = reinterpret_cast<Observer*>(self);
+        if (o->m_data && !visitor->isAlive(o->m_data)) {
+            o->m_data->willFinalize();
+            o->m_data = 0;
+        }
+    }
+
+private:
+    Observer(T* data) : m_data(data) { }
+    T* m_data;

[zerny-chromium, 2014/03/13 06:41:47]

Nit: WeakMember<T> m_data;

+};
+
+// This demonstrates how to use Observer<T> as a part object of the target.
+class WillFinalized : public GarbageCollectedFinalized<WillFinalized> {
+public:
+    WillFinalized(Bar* bar)
+        : m_data(2014)
+        , m_bar(bar)
+        , m_observer(Observer<WillFinalized>::create(this))
+    {
+    }
+
+    // willFinalize is called before finalize()/destructor.
+    void willFinalize()
+    {
+        EXPECT_NE(0, m_data);
+        EXPECT_TRUE(m_bar->isLive());
+        m_data = 0;
+    }
+
+    ~WillFinalized()
+    {
+        EXPECT_EQ(0, m_data);
+    }
+
+    void trace(Visitor* visitor)
+    {
+        visitor->trace(m_bar);
+    }
+
+private:
+    int m_data;
+    Member<Bar> m_bar;
+    // This is a trick. Use Persistent for Observer<T> to avoid it is collected

[zerny-chromium, 2014/03/13 06:41:47]

it is collected -> it from being collected

[Mads Ager (chromium), 2014/03/13 07:33:28]

Instead of embedding the Persistent in the object itself I would prefer to have
one static PersistentHashSet<Member<Observer<WillFinalized> > > observers. When
the observer dies it can pull itself out of the set (or pass itself to
willFinalize and it can be pulled out there).

+    // with the target.
+    Persistent<Observer<WillFinalized> > m_observer;
+};
 
 class SuperClass;
 
 class PointsBack : public RefCountedWillBeGarbageCollectedFinalized<PointsBack> {
 public:
     static PassRefPtrWillBeRawPtr<PointsBack> create()
     {
         return adoptRefWillBeNoop(new PointsBack());
     }
 
@@ skipping 1596 matching lines @@
         Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
         EXPECT_EQ(3u, Bar::s_live); // Only h4, h5 and h2 are left.
         EXPECT_TRUE(h4->strongIsThere()); // h2 is still pointed to from h4.
         EXPECT_TRUE(h5->strongIsThere()); // h2 is still pointed to from h5.
     }
     // h4 and h5 have gone out of scope now and they were keeping h2 alive.
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(0u, Bar::s_live); // All gone.
 }
 
+TEST(HeapTest, WillFinalize)
+{
+    // |o| observes |baz|.
+    Persistent<Observer<Baz> > o;
+    {
+        Baz* baz = Baz::create(Bar::create());
+        o = Observer<Baz>::create(baz);
+    }
+    // Observer doesn't have a strong reference to baz. So baz and its member
+    // will be collected.
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
+    EXPECT_EQ(0u, Bar::s_live);
+
+    // |wf| observes itself, and calls willFinalize().
+    {
+        WillFinalized* wf = new WillFinalized(Bar::create());
+        wf = 0;
+    }
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
+    EXPECT_EQ(0u, Bar::s_live);
+}
+
 TEST(HeapTest, Comparisons)
 {
     Persistent<Bar> barPersistent = Bar::create();
     Persistent<Foo> fooPersistent = Foo::create(barPersistent);
     EXPECT_TRUE(barPersistent != fooPersistent);
     barPersistent = fooPersistent;
     EXPECT_TRUE(barPersistent == fooPersistent);
 }
 
 TEST(HeapTest, CheckAndMarkPointer)
@@ skipping 320 matching lines @@
 
 namespace WTF {
 
 // We need the below vector trait specialization for the above HeapVectors to behave correctly wrt. memset, memcmp etc.
 template<> struct VectorTraits<WebCore::VectorObject> : public SimpleClassVectorTraits<WebCore::VectorObject> { };
 template<> struct VectorTraits<WebCore::VectorObjectInheritedTrace> : public SimpleClassVectorTraits<WebCore::VectorObjectInheritedTrace> { };
 template<> struct VectorTraits<WebCore::VectorObjectNoTrace> : public SimpleClassVectorTraits<WebCore::VectorObjectNoTrace> { };
 
 } // WTF namespace