Upon clearing, release PersistentNode of cross-thread-persistent also.

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 496 matching lines @@
 // declaration), so that subclasses can use it.
 const int ThreadedTesterBase::numberOfThreads;
 
 class ThreadedHeapTester : public ThreadedTesterBase {
 public:
     static void test()
     {
         ThreadedTesterBase::test(new ThreadedHeapTester);
     }
 
+    ~ThreadedHeapTester() override
+    {
+        // Verify that the threads cleared their CTPs when
+        // terminating, preventing access to a finalized heap.
+        for (auto& globalIntWrapper : m_crossPersistents) {
+            ASSERT(globalIntWrapper.get());
+            EXPECT_FALSE(globalIntWrapper.get()->get());
+        }
+    }
+
 protected:
     using GlobalIntWrapperPersistent = CrossThreadPersistent<IntWrapper>;
 
+    Mutex m_mutex;
+    Vector<OwnPtr<GlobalIntWrapperPersistent>> m_crossPersistents;
+
     PassOwnPtr<GlobalIntWrapperPersistent> createGlobalPersistent(int value)
     {
         return adoptPtr(new GlobalIntWrapperPersistent(IntWrapper::create(value)));
     }
 
+    void addGlobalPersistent()
+    {
+        MutexLocker lock(m_mutex);
+        m_crossPersistents.append(createGlobalPersistent(0x2a2a2a2a));
+    }
+
     void runThread() override
     {
-        OwnPtr<GlobalIntWrapperPersistent> longLivingPersistent;
         ThreadState::attachCurrentThread(false);
 
-        longLivingPersistent = createGlobalPersistent(0x2a2a2a2a);
+        // Add a cross-thread persistent from this thread; the test object
+        // verifies that it will have been cleared out after the threads
+        // have all detached, running their termination GCs while doing so.
+        addGlobalPersistent();
+
         int gcCount = 0;
         while (!done()) {
             ThreadState::current()->safePoint(BlinkGC::NoHeapPointersOnStack);
             {
                 Persistent<IntWrapper> wrapper;
 
                 OwnPtr<GlobalIntWrapperPersistent> globalPersistent = createGlobalPersistent(0x0ed0cabb);
 
                 for (int i = 0; i < numberOfAllocations; i++) {
                     wrapper = IntWrapper::create(0x0bbac0de);
@@ skipping 15 matching lines @@
                 // it at the moment. Fix the crash and enable it.
                 // ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::TakeSnapshot, BlinkGC::ForcedGC);
                 preciselyCollectGarbage();
                 EXPECT_EQ(wrapper->value(), 0x0bbac0de);
                 EXPECT_EQ((*globalPersistent)->value(), 0x0ed0cabb);
             }
             SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
             testing::yieldCurrentThread();
         }
 
-        // Intentionally leak the cross-thread persistent so as to verify
-        // that later GCs correctly handle cross-thread persistents that
-        // refer to finalized objects after their heaps have been detached
-        // and freed.
-        EXPECT_TRUE(longLivingPersistent.leakPtr());
-
         ThreadState::detachCurrentThread();
         atomicDecrement(&m_threadsToFinish);
     }
 };
 
 class ThreadedWeaknessTester : public ThreadedTesterBase {
 public:
     static void test()
     {
         ThreadedTesterBase::test(new ThreadedWeaknessTester);
@@ skipping 6054 matching lines @@
         conservativelyCollectGarbage();
         EXPECT_EQ(wrapper, weakWrapper->value());
         // Stub out any stack reference.
         wrapper = nullptr;
     }
     preciselyCollectGarbage();
     EXPECT_EQ(nullptr, weakWrapper->value());
 }
 
 } // namespace blink