Allow Oilpan heap objects account for their external allocations.

Source/platform/heap/ThreadState.cpp

Index: Source/platform/heap/ThreadState.cpp
diff --git a/Source/platform/heap/ThreadState.cpp b/Source/platform/heap/ThreadState.cpp
index 2be4900377a959a67d0a37c7ef6748bc9f184f78..7c9559e8d7fb5c76e5fbbcdc6d0dd88d3590a8a6 100644
--- a/Source/platform/heap/ThreadState.cpp
+++ b/Source/platform/heap/ThreadState.cpp
@@ -673,6 +673,9 @@ bool ThreadState::shouldForceConservativeGC()
     if (UNLIKELY(m_gcForbiddenCount))
         return false;
 
+    if (Heap::isUrgentGCRequested())
+        return true;
+
     size_t newSize = Heap::allocatedObjectSize();
     if (newSize >= 300 * 1024 * 1024) {
         // If we consume too much memory, trigger a conservative GC
@@ -698,13 +701,21 @@ void ThreadState::scheduleGCIfNeeded()
     checkThread();
     // Allocation is allowed during sweeping, but those allocations should not
     // trigger nested GCs
-    if (isSweepingInProgress())
-        return;
+    if (isSweepingInProgress()) {
+        if (!Heap::isUrgentGCRequested() || !isSweepingScheduled())

[haraken, 2015/02/23 16:40:29]

Sorry to bug you a lot of times on this... I reconsidered but am not yet sure
why we need the '|| !isSweepingScheduled()' check.

Even if we don't have the check, Heap::collectGarbage() will make the heap
consistent (by makeConsitentForSweeping) before starting the next GC, so the
nested GC won't cause any issue.

If we interpret Heap::isUrgentGCRequested() as a signal to indicate that "Please
trigger a conservative GC right now even if the current sweeping is not yet
complete", it seems more straightforward just to trigger a conservative GC
without any additional check.

(The reason I'm skeptical about the check is that the check means that we treat
Sweeping and SweepingAndPreciseGCScheduled differently. There should be no
difference between the two states in a case where an urgent GC is requested (we
should just trigger an urgent GC immediately), so I think we should just remove
the check.)

[sof, 2015/02/23 20:47:05]

Yes, we don't want to make a distinction between the "pure" sweeping state and
the sweeping-and-scheduled-gc ones here. I'm getting these GC states mixed up,
somehow.

Removed the check; sorry about all these iterations (fatigue setting in, i
suppose.) 

+            return;
+        // Urgent GC requested with only a GC scheduled; fall through
+        // and have it be serviced by a conservative GC.
+    }
     ASSERT(!sweepForbidden());
 
-    if (shouldForceConservativeGC())
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithoutSweep);
-    else if (shouldSchedulePreciseGC())
+    if (shouldForceConservativeGC()) {
+        // If GC is deemed urgent, eagerly sweep and finalize any external allocations right away.
+        GCType gcType = Heap::isUrgentGCRequested() ? GCWithSweep : GCWithoutSweep;
+        Heap::collectGarbage(HeapPointersOnStack, gcType);
+        return;
+    }
+    if (shouldSchedulePreciseGC())
         schedulePreciseGC();
     else if (shouldScheduleIdleGC())
         scheduleIdleGC();