Fix test crashes by doing an additional GC on cleanup.

Source/heap/ThreadState.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 280 matching lines @@
     // From here on ignore all conservatively discovered
     // pointers into the heap owned by this thread.
     m_isCleaningUp = true;
 
     for (size_t i = 0; i < m_cleanupTasks.size(); i++)
         m_cleanupTasks[i]->preCleanup();
 
     // After this GC we expect heap to be empty because
     // preCleanup tasks should have cleared all persistent
     // handles that were externally owned.
+    // FIXME: oilpan: get rid of the additional GC.

[haraken, 2014/02/27 11:30:31]

Just help me understand: Why is this a FIXME? I guess that we need to call
multiple GCs to break persistent chains.

[Vyacheslav Egorov (Chromium), 2014/02/27 11:32:26]

Because in the end everything will be moved to the heap and persistents will
disappear.

[haraken, 2014/02/27 11:37:20]

I'm not sure how realistic it is. We'll anyway have off-heap and on-heap, and
will have a pointer from off-heap to on-heap (which is persistent).

+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);

[haraken, 2014/02/27 11:30:31]

Are two GCs enough?

[Vyacheslav Egorov (Chromium), 2014/02/27 11:32:26]

It is enough for the test we are trying to fix.

 
     // Verify that all heaps are empty now.
     for (int i = 0; i < NumberOfHeaps; i++)
         m_heaps[i]->assertEmpty();

[haraken, 2014/02/27 11:37:20]

As long as we assert this (this assertion is enabled in release mode), I think
we should call collectGarbage multiple times until we remove all persistent
handles.

It won't make sense that we call only one GC and assert the emptiness whereas we
still have a lot of persistent handles.

 
     for (size_t i = 0; i < m_cleanupTasks.size(); i++)
         m_cleanupTasks[i]->postCleanup();
 
     m_cleanupTasks.clear();
 }
 
 void ThreadState::detach()
 {
     ThreadState* state = current();
@@ skipping 380 matching lines @@
     state->safePoint(HeapPointersOnStack);
 }
 
 ThreadState::AttachedThreadStateSet& ThreadState::attachedThreads()
 {
     DEFINE_STATIC_LOCAL(AttachedThreadStateSet, threads, ());
     return threads;
 }
 
 }