Oilpan: introduce sticky forcedForTesting flag to ensure that a precise

Source/heap/ThreadState.h

 /*
  * 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 260 matching lines @@
     // collect garbage at this point.
     bool shouldGC();
     bool shouldForceConservativeGC();
 
     // If gcRequested returns true when a thread returns to its event
     // loop the thread will initiate a garbage collection.
     bool gcRequested();
     void setGCRequested();
     void clearGCRequested();
 
+    void performPendingGC(StackState);

[wibling-chromium, 2014/04/01 13:26:09]

NIT: Could be made private.

[Mads Ager (chromium), 2014/04/01 13:45:38]

Done.

+
+    // Was the last GC forced for testing? This is set when garbage collection
+    // is forced for testing and there are pointers on the stack. It remains
+    // set until a garbage collection is triggered with no pointers on the stack.
+    // This is used for layout tests that trigger GCs and check if objects are
+    // dead at a given point in time. That only reliably works when we get
+    // precise GCs with no conservative stack scanning.
+    void setForcedForTesting(bool);
+    bool forcedForTesting();

[wibling-chromium, 2014/04/01 13:26:09]

NIT: Could be made private.

[Mads Ager (chromium), 2014/04/01 13:45:38]

This one is called from Heap. We could make heap a friend to hide some of these.
However, that goes for a lot of stuff here, so let's do that as a separate
change?

+
     bool sweepRequested();
     void setSweepRequested();
     void clearSweepRequested();
     void performPendingSweep();
 
     // Support for disallowing allocation. Mainly used for sanity
     // checks asserts.
     bool isAllocationAllowed() const { return !isAtSafePoint() && !m_noAllocationCount; }
     void enterNoAllocationScope() { m_noAllocationCount++; }
     void leaveNoAllocationScope() { m_noAllocationCount--; }
@@ skipping 242 matching lines @@
     ThreadIdentifier m_thread;
     OwnPtr<PersistentNode> m_persistents;
     StackState m_stackState;
     intptr_t* m_startOfStack;
     intptr_t* m_endOfStack;
     void* m_safePointScopeMarker;
     Vector<Address> m_safePointStackCopy;
     bool m_atSafePoint;
     Vector<Interruptor*> m_interruptors;
     bool m_gcRequested;
+    bool m_forcedForTesting;
     volatile int m_sweepRequested;
     bool m_sweepInProgress;
     size_t m_noAllocationCount;
     bool m_inGC;
     BaseHeap* m_heaps[NumberOfHeaps];
     OwnPtr<HeapContainsCache> m_heapContainsCache;
     HeapStats m_stats;
     HeapStats m_statsAfterLastGC;
 
     Vector<OwnPtr<CleanupTask> > m_cleanupTasks;
@@ skipping 15 matching lines @@
 };
 
 template<> class ThreadStateFor<AnyThread> {
 public:
     static ThreadState* state() { return ThreadState::current(); }
 };
 
 }
 
 #endif // ThreadState_h