Oilpan: expose near-finalized predicate as Heap::willObjectBeLazilySwept()

Source/platform/heap/Heap.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 834 matching lines @@
     static void init();
     static void shutdown();
     static void doShutdown();
 
 #if ENABLE(ASSERT)
     static BaseHeapPage* findPageFromAddress(Address);
     static BaseHeapPage* findPageFromAddress(void* pointer) { return findPageFromAddress(reinterpret_cast<Address>(pointer)); }
     static bool containedInHeapOrOrphanedPage(void*);
 #endif
 
-    // Is the finalizable GC object still alive? If no GC is in progress,
-    // it must be true. If a lazy sweep is in progress, it will be true if
-    // the object hasn't been swept yet and it is marked, or it has
-    // been swept and it is still alive.
+    // Is the finalizable GC object still alive, but slated for lazy sweeping?
+    // If a lazy sweep is in progress, returns true if the object was found
+    // to be not reachable during the marking phase, but it has yet to be swept
+    // and finalized. The predicate returns false in all other cases.
     //
-    // isFinalizedObjectAlive() must not be used with already-finalized object
-    // references.
-    //
+    // Holding a reference to an already-dead object is not a valid state
+    // to be in; willObjectBeLazilySwept() has undefined behavior if passed

[haraken, 2015/01/22 09:29:29]

Can we assert this by checking header->checkHeader()?

[sof, 2015/01/22 09:56:23]

That would be helpful, added.

+    // such a reference.
     template<typename T>
-    static bool isFinalizedObjectAlive(const T* objectPointer)
+    static bool willObjectBeLazilySwept(const T* objectPointer)
     {
         static_assert(IsGarbageCollectedType<T>::value, "only objects deriving from GarbageCollected can be used.");
 #if ENABLE(OILPAN)
         BaseHeapPage* page = pageFromObject(objectPointer);
         if (page->hasBeenSwept())
-            return true;
+            return false;
         ASSERT(page->heap()->threadState()->isSweepingInProgress());
 
-        return ObjectAliveTrait<T>::isHeapObjectAlive(s_markingVisitor, const_cast<T*>(objectPointer));
+        return !ObjectAliveTrait<T>::isHeapObjectAlive(s_markingVisitor, const_cast<T*>(objectPointer));
 #else
         // FIXME: remove when lazy sweeping is always on
         // (cf. ThreadState::postGCProcessing()).
-        return true;
+        return false;
 #endif
     }
 
     // Push a trace callback on the marking stack.
     static void pushTraceCallback(void* containerObject, TraceCallback);
 
     // Push a trace callback on the post-marking callback stack.  These
     // callbacks are called after normal marking (including ephemeron
     // iteration).
     static void pushPostMarkingCallback(void*, TraceCallback);
@@ skipping 1540 matching lines @@
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapVector<T, inlineCapacity>> : public GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapDeque<T, inlineCapacity>> : public GCInfoTrait<Deque<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HeapHashCountedSet<T, U, V>> : public GCInfoTrait<HashCountedSet<T, U, V, HeapAllocator>> { };
 
 } // namespace blink
 
 #endif // Heap_h