Add InlinedMarkingVisitor::shouldMarkObject() predicate.

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 531 matching lines @@
                 EXPECT_TRUE(weakMap2.isEmpty());
             }
             ThreadState::SafePointScope scope(ThreadState::NoHeapPointersOnStack);
             Platform::current()->yieldCurrentThread();
         }
         ThreadState::detach();
         atomicDecrement(&m_threadsToFinish);
     }
 };
 
+class ThreadPersistentHeapTester : public ThreadedTesterBase {
+public:
+    static void test()
+    {
+        ThreadedTesterBase::test(new ThreadPersistentHeapTester);
+    }
+
+protected:
+    class Local final : public GarbageCollected<Local> {
+    public:
+        Local() { }
+
+        void trace(Visitor* visitor) { }
+    };
+
+    class BookEnd;
+
+    class PersistentStore {
+    public:
+        static PersistentStore* create(int count, int* gcCount, BookEnd* bookend)
+        {
+            return new PersistentStore(count, gcCount, bookend);
+        }
+
+        void advance()
+        {
+            (*m_gcCount)++;
+            m_store.removeLast();
+            // Remove reference to BookEnd when there are no Persistent<Local>s left.
+            // The BookEnd object will then be swept out at the next GC, and pre-finalized,
+            // causing this PersistentStore instance to be destructed, along with
+            // the Persistent<BookEnd>. It being the very last Persistent<>, causing the
+            // GC loop in ThreadState::detach() to terminate.
+            if (!m_store.size())
+                m_bookend = nullptr;
+        }
+
+    private:
+        PersistentStore(int count, int* gcCount, BookEnd* bookend)
+        {
+            m_gcCount = gcCount;
+            m_bookend = bookend;
+            for (int i = 0; i < count; ++i)
+                m_store.append(Persistent<ThreadPersistentHeapTester::Local>(new ThreadPersistentHeapTester::Local()));
+        }
+
+        Vector<Persistent<Local>> m_store;
+        Persistent<BookEnd> m_bookend;
+        int* m_gcCount;
+    };
+
+    class BookEnd final : public GarbageCollected<BookEnd> {
+        USING_PRE_FINALIZER(BookEnd, dispose);
+    public:
+        BookEnd()
+            : m_store(nullptr)
+        {
+            ThreadState::current()->registerPreFinalizer(*this);
+        }
+
+        void initialize(PersistentStore* store)
+        {
+            m_store = store;
+        }
+
+        void dispose()
+        {
+            delete m_store;
+        }
+
+        void trace(Visitor* visitor)
+        {
+            ASSERT(m_store);
+            m_store->advance();
+        }
+
+    private:
+        PersistentStore* m_store;
+    };
+
+    virtual void runThread() override
+    {
+        ThreadState::attach();
+
+        const int iterations = 5;
+        int gcCount = 0;
+        BookEnd* bookend = new BookEnd();
+        PersistentStore* store = PersistentStore::create(iterations, &gcCount, bookend);
+        bookend->initialize(store);
+
+        bookend = nullptr;
+        store = nullptr;
+
+        // Upon thread detach, GCs will run until all persistents have been
+        // released. We verify that the draining of persistents proceeds
+        // as expected by dropping one Persistent<> per GC until there
+        // are none left.
+        ThreadState::detach();
+        EXPECT_EQ(iterations, gcCount);
+        atomicDecrement(&m_threadsToFinish);
+    }
+};
+
 // The accounting for memory includes the memory used by rounding up object
 // sizes. This is done in a different way on 32 bit and 64 bit, so we have to
 // have some slack in the tests.
 template<typename T>
 void CheckWithSlack(T expected, T actual, int slack)
 {
     EXPECT_LE(expected, actual);
     EXPECT_GE((intptr_t)expected + slack, (intptr_t)actual);
 }
 
@@ skipping 949 matching lines @@
 TEST(HeapTest, Threading)
 {
     ThreadedHeapTester::test();
 }
 
 TEST(HeapTest, ThreadedWeakness)
 {
     ThreadedWeaknessTester::test();
 }
 
+TEST(HeapTest, ThreadPersistent)
+{
+    ThreadPersistentHeapTester::test();
+}
+
 TEST(HeapTest, BasicFunctionality)
 {
     clearOutOldGarbage();
     size_t initialObjectPayloadSize = Heap::objectPayloadSizeForTesting();
     {
         size_t slack = 0;
 
         // When the test starts there may already have been leaked some memory
         // on the heap, so we establish a base line.
         size_t baseLevel = initialObjectPayloadSize;
@@ skipping 3810 matching lines @@
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
 
     // Verify that the DeepEagerly chain isn't completely unravelled
     // by performing eager trace() calls, but the explicit mark
     // stack is switched once some nesting limit is exceeded.
     EXPECT_GT(DeepEagerly::sTraceLazy, 2);
 #endif
 }
 
 } // namespace blink