Refactor the Heap into ThreadHeap to prepare for per thread heaps

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/heap/PersistentNode.h"
 
 #include "platform/heap/Handle.h"
 
 namespace blink {
 
@@ skipping 31 matching lines @@
         ASSERT(node->isUnused());
     }
     slots->m_next = m_slots;
     m_slots = slots;
 }
 
 // This function traces all PersistentNodes. If we encounter
 // a PersistentNodeSlot that contains only freed PersistentNodes,
 // we delete the PersistentNodeSlot. This function rebuilds the free
 // list of PersistentNodes.
-void PersistentRegion::tracePersistentNodes(Visitor* visitor)
+void PersistentRegion::tracePersistentNodes(Visitor* visitor, bool (*shouldTrace)(Visitor*, PersistentNode*))
 {
     m_freeListHead = nullptr;
     int persistentCount = 0;
     PersistentNodeSlots** prevNext = &m_slots;
     PersistentNodeSlots* slots = m_slots;
     while (slots) {
         PersistentNode* freeListNext = nullptr;
         PersistentNode* freeListLast = nullptr;
         int freeCount = 0;
         for (int i = 0; i < PersistentNodeSlots::slotCount; ++i) {
             PersistentNode* node = &slots->m_slot[i];
             if (node->isUnused()) {
                 if (!freeListNext)
                     freeListLast = node;
                 node->setFreeListNext(freeListNext);
                 freeListNext = node;
                 ++freeCount;
             } else {
+                if (shouldTrace && !shouldTrace(visitor, node))
+                    return;

[haraken, 2016/01/28 15:52:50]

Shouldn't this be 'continue'?

[keishi, 2016/02/29 06:02:33]

Done.

                 node->tracePersistentNode(visitor);
                 ++persistentCount;
             }
         }
         if (freeCount == PersistentNodeSlots::slotCount) {
             PersistentNodeSlots* deadSlots = slots;
             *prevNext = slots->m_next;
             slots = slots->m_next;
             delete deadSlots;
         } else {
@@ skipping 10 matching lines @@
     ASSERT(persistentCount == m_persistentCount);
 }
 
 namespace {
 class GCObject final : public GarbageCollected<GCObject> {
 public:
     DEFINE_INLINE_TRACE() { }
 };
 }
 
+bool CrossThreadPersistentRegion::shouldTracePersistentNode(Visitor* visitor, PersistentNode* node)
+{

[haraken, 2016/01/28 15:52:50]

Add ASSERT(!node->isUnused()).

[keishi, 2016/02/29 06:02:33]

Done.

+    CrossThreadPersistent<GCObject>* persistent = reinterpret_cast<CrossThreadPersistent<GCObject>*>(node->self());
+    ASSERT(persistent);
+    Address rawObject = reinterpret_cast<Address>(persistent->get());
+    // TODO: Why do we need to return true?

[haraken, 2016/01/28 15:52:50]

I wonder why as well :) This should return false.

Maybe is this related to the above mistake between return and continue?

[keishi, 2016/02/29 06:02:33]

Thanks, looks like it was.

+    if (!rawObject)
+        return true;
+    return visitor->gcData()->threadState()->gcGroup()->threads().contains(ThreadState::forObject(rawObject));

[haraken, 2016/01/28 15:52:50]

forObject => fromAddress (for consistency with HeapPage's methods)

[keishi, 2016/02/29 06:02:33]

Done.

+}
+
 void CrossThreadPersistentRegion::prepareForThreadStateTermination(ThreadState* threadState)
 {
     // For heaps belonging to a thread that's detaching, any cross-thread persistents
     // pointing into them needs to be disabled. Do that by clearing out the underlying
     // heap reference.
     MutexLocker lock(m_mutex);
 
     // TODO(sof): consider ways of reducing overhead. (e.g., tracking number of active
     // CrossThreadPersistent<>s pointing into the heaps of each ThreadState and use that
     // count to bail out early.)
@@ skipping 16 matching lines @@
             if (page->orphaned())
                 continue;
             if (page->heap()->threadState() == threadState)
                 persistent->clear();
         }
         slots = slots->m_next;
     }
 }
 
 } // namespace blink