[oilpan]: Make thread shutdown more robust.

Source/platform/heap/Visitor.h

Index: Source/platform/heap/Visitor.h
diff --git a/Source/platform/heap/Visitor.h b/Source/platform/heap/Visitor.h
index ffadc80fe99aa42561c757d29f9432d498d39a52..3568e14a07b7f272df4598db4eabe7b031a0eab4 100644
--- a/Source/platform/heap/Visitor.h
+++ b/Source/platform/heap/Visitor.h
@@ -594,8 +594,18 @@ class DefaultTraceTrait<T, true> {
 public:
     static void mark(Visitor* visitor, const T* self)
     {
-        if (self)
-            self->adjustAndMark(visitor);
+        if (!self)
+            return;
+
+        // Before doing adjustAndMark we need to check if the page is orphaned
+        // since we cannot call adjustAndMark if so, as there will be no vtable.
+        // If orphaned just mark the page as traced.
+        BaseHeapPage* heapPage = pageHeaderFromObject(self);
+        if (heapPage->orphaned()) {

[haraken, 2014/07/09 05:17:49]

Just to confirm: Is this the only place where we have to insert the
heapPage->orphaned() check before dispatching mark/trace/adjustAndMark? For
example, don't we need to insert the check into Visitor::mark() as well?

[wibling-chromium, 2014/07/09 10:32:31]

AFAICT we can get away with just checking here for the marking code.

We ideally don't want to put the check into the code where we are
marking/pushing the trace methods onto the marking stack. The only reason we add
it here is because we are calling a method on memory that is orphaned and hence
zapped.
Instead we are checking whether we hit an orphaned page when we pop the trace
callback off the marking stack since this means we only have to check once for
each object and it is done locally.

[haraken, 2014/07/13 17:30:38]

Just to help me understand, imagine the following object graph:

  root object => object X on an orphaned page A => object Y on a not-orphaned
page => object Z on an orphaned page B

Do we want to continue tracing from the object X to the object Y? Or do we want
to stop the tracing when we reach the object X? (In other words, do we want to
set an tracedAfterOrphaned flag on the page B or not?)

[wibling-chromium, 2014/07/14 08:06:11]

We don't want to continue tracing from X to Y. If Y is not reachable from other
objects than X then there is no need to set the traced bit on Z (ie. page B)
since it cannot be reached.
Even in the case where Y is not swept and we do a follow-up conservative GC the
dead bit should be set on Y meaning we won't continue tracing its pointers to Z.
This guarantees that we are not trying to trace through to a, now, decommited
page.

+            heapPage->setTraced();
+            return;
+        }
+        self->adjustAndMark(visitor);
     }
 
 #ifndef NDEBUG