[oilpan]: Make thread shutdown more robust.

Source/platform/heap/ThreadState.h

Index: Source/platform/heap/ThreadState.h
diff --git a/Source/platform/heap/ThreadState.h b/Source/platform/heap/ThreadState.h
index 5269820c6417a1cff55af4d7d8237da95eed2fb1..fa2d9fddf61f8cbedad8ba796d77fca8fb9dedc8 100644
--- a/Source/platform/heap/ThreadState.h
+++ b/Source/platform/heap/ThreadState.h
@@ -49,6 +49,7 @@ class FinalizedHeapObjectHeader;
 struct GCInfo;
 class HeapContainsCache;
 class HeapObjectHeader;
+class PageMemory;
 class PersistentNode;
 class Visitor;
 class SafePointBarrier;
@@ -507,6 +508,9 @@ public:
     HeapStats& stats() { return m_stats; }
     HeapStats& statsAfterLastGC() { return m_statsAfterLastGC; }
 
+    void setupHeapsForShutdown();
+    void visitLocalRoots(Visitor*);
+
 private:
     explicit ThreadState();
     ~ThreadState();
@@ -657,6 +661,63 @@ private:
     bool m_locked;
 };
 
+// Common header for heap pages. Needs to be defined before class Visitor.

[Mads Ager (chromium), 2014/07/08 08:24:56]

Our file setup is becoming really messy. :-\ This change is important to land,
so let's leave it this way but it seems messy to have BaseHeapPage here and all
the subclasses in Heap.h. Maybe we should split into more files, but let's leave
that for later.

[wibling-chromium, 2014/07/08 13:39:48]

Agree. I was more thinking about going in the opposite direction and combining
some of our header files, since they seems to be quite intertwined anyway.

+class BaseHeapPage {
+public:
+    BaseHeapPage(PageMemory*, const GCInfo*, ThreadState*);
+    virtual ~BaseHeapPage() { }
+
+    // Check if the given address points to an object in this
+    // heap page. If so, find the start of that object and mark it
+    // using the given Visitor. Otherwise do nothing. The pointer must
+    // be within the same aligned blinkPageSize as the this-pointer.
+    //
+    // This is used during conservative stack scanning to
+    // conservatively mark all objects that could be referenced from
+    // the stack.
+    virtual void checkAndMarkPointer(Visitor*, Address) = 0;
+    virtual bool contains(Address) = 0;
+
+#if ENABLE(GC_TRACING)
+    virtual const GCInfo* findGCInfo(Address) = 0;
+#endif
+
+    Address address() { return reinterpret_cast<Address>(this); }
+    PageMemory* storage() const { return m_storage; }
+    ThreadState* threadState() const { return m_threadState; }
+    const GCInfo* gcInfo() { return m_gcInfo; }
+    virtual bool isLargeObject() { return false; }
+    virtual void markOrphaned()
+    {
+        m_threadState = 0;
+        m_shuttingDown = false;
+        m_traced = false;
+    }
+    bool orphaned() { return !m_threadState; }
+    bool shuttingDown() { return m_shuttingDown; }
+    void setShutdown() { m_shuttingDown = true; }
+    bool traced() { return m_traced; }
+    void setTraced() { m_traced = true; }
+    bool reuseMemory() { return m_reuseMemory; }
+    void clearReuseMemory() { m_reuseMemory = false; }
+    void setReuseMemory() { m_reuseMemory = true; }

[haraken, 2014/07/08 05:44:51]

Instead of introducing clearReuseMemory and setReuseMemory, can we just override
reuseMemory() in LargeHeapObject so that reuseMemory() returns true only for
LargeHeapObjects?

[Mads Ager (chromium), 2014/07/08 08:24:56]

We already have this information. We have the virtual isLargeObject method, so I
think we should just use that one? :)

[wibling-chromium, 2014/07/08 13:39:48]

Done.

[wibling-chromium, 2014/07/08 13:39:48]

I got rid of this and used isLargeObject as suggested by Mads.

+
+private:
+    // Accessor to silence unused warnings for the m_padding field.
+    intptr_t padding() const { return m_padding; }
+
+    PageMemory* m_storage;
+    const GCInfo* m_gcInfo;
+    ThreadState* m_threadState;
+    bool m_shuttingDown;
+    bool m_traced;
+    bool m_reuseMemory;

[Mads Ager (chromium), 2014/07/08 08:24:56]

Are you sure we are maintaining correct alignment now? Unfortunately, this might
only break on Windows if we get it wrong.

[wibling-chromium, 2014/07/08 13:39:48]

No, I will spend some time to make sure it is okay.

+    // Pointer sized integer to ensure proper alignment of the
+    // HeapPage header. This can be used as a bit field if we need
+    // to associate more information with pages.
+    intptr_t m_padding;
+};
+
 }
 
 #endif // ThreadState_h