Cleanly release thread-local static persistents during termination GCs.

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 6480 matching lines @@
 class ThreadedClearOnShutdownTester : public ThreadedTesterBase {
 public:
     static void test()
     {
         IntWrapper::s_destructorCalls = 0;
         ThreadedTesterBase::test(new ThreadedClearOnShutdownTester);
         EXPECT_EQ(numberOfThreads, IntWrapper::s_destructorCalls);
     }
 
 private:
+    void runWhileAttached();
+
     void runThread() override
     {
         ThreadState::attachCurrentThread(false);
         EXPECT_EQ(42, threadSpecificIntWrapper().value());
+        runWhileAttached();
         ThreadState::detachCurrentThread();
         atomicDecrement(&m_threadsToFinish);
     }
 
+    class HeapObject;
+    friend class HeapObject;
+
+    using WeakHeapObjectSet = PersistentHeapHashSet<WeakMember<HeapObject>>;
+
+    static WeakHeapObjectSet& weakHeapObjectSet();
+
+    using HeapObjectSet = PersistentHeapHashSet<Member<HeapObject>>;
+    static HeapObjectSet& heapObjectSet();
+
     static IntWrapper& threadSpecificIntWrapper()
     {
         DEFINE_THREAD_SAFE_STATIC_LOCAL(
             ThreadSpecific<Persistent<IntWrapper>>, intWrapper,
             new ThreadSpecific<Persistent<IntWrapper>>);
         Persistent<IntWrapper>& handle = *intWrapper;
         if (!handle) {
             handle = new IntWrapper(42);
             handle.registerAsStaticReference();
         }
         return *handle;
     }
 };
 
+class ThreadedClearOnShutdownTester::HeapObject final : public GarbageCollectedFinalized<ThreadedClearOnShutdownTester::HeapObject> {
+public:
+    static HeapObject* create(bool testDestructor)
+    {
+        return new HeapObject(testDestructor);
+    }
+
+    ~HeapObject()
+    {
+        if (!m_testDestructor)
+            return;
+
+        // Verify that the weak reference is gone.
+        EXPECT_FALSE(weakHeapObjectSet().contains(this));
+
+        // Add a new member to the static singleton; this will
+        // re-initializes the persistent node of the collection
+        // object. Done while terminating the test thread, so
+        // verify that this brings about the release of the
+        // persistent also.
+        heapObjectSet().add(create(false));
+    }
+
+    DEFINE_INLINE_TRACE() { }
+
+private:
+    explicit HeapObject(bool testDestructor)
+        : m_testDestructor(testDestructor)
+    {
+    }
+
+    bool m_testDestructor;
+};
+
+ThreadedClearOnShutdownTester::WeakHeapObjectSet& ThreadedClearOnShutdownTester::weakHeapObjectSet()
+{
+    DEFINE_THREAD_SAFE_STATIC_LOCAL(
+        ThreadSpecific<WeakHeapObjectSet>, singleton,
+        new ThreadSpecific<WeakHeapObjectSet>);
+    if (!singleton.isSet())
+        singleton->registerAsStaticReference();
+
+    return *singleton;
+}
+
+ThreadedClearOnShutdownTester::HeapObjectSet& ThreadedClearOnShutdownTester::heapObjectSet()
+{
+    DEFINE_THREAD_SAFE_STATIC_LOCAL(
+        ThreadSpecific<HeapObjectSet>, singleton,
+        new ThreadSpecific<HeapObjectSet>);
+    if (!singleton.isSet())
+        singleton->registerAsStaticReference();
+
+    return *singleton;
+}
+
+void ThreadedClearOnShutdownTester::runWhileAttached()
+{
+    EXPECT_EQ(42, threadSpecificIntWrapper().value());
+    // Creates a thread-specific singleton to a weakly held object.
+    weakHeapObjectSet().add(HeapObject::create(true));
+}
+
 } // namespace
 
 TEST(HeapTest, TestClearOnShutdown)
 {
     ThreadedClearOnShutdownTester::test();
 }
 
 // Verify that WeakMember<const T> compiles and behaves as expected.
 class WithWeakConstObject final : public GarbageCollected<WithWeakConstObject> {
 public:
@@ skipping 27 matching lines @@
         conservativelyCollectGarbage();
         EXPECT_EQ(wrapper, weakWrapper->value());
         // Stub out any stack reference.
         wrapper = nullptr;
     }
     preciselyCollectGarbage();
     EXPECT_EQ(nullptr, weakWrapper->value());
 }
 
 } // namespace blink