Do not fire timers for finalizing objects.

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 383 matching lines @@
     virtual size_t size() = 0;
     virtual bool isLargeObject() { return false; }
 
     Address address() { return reinterpret_cast<Address>(this); }
     PageMemory* storage() const { return m_storage; }
     ThreadHeap* heap() const { return m_heap; }
     bool orphaned() { return !m_heap; }
     bool terminating() { return m_terminating; }
     void setTerminating() { m_terminating = true; }
 
+    void markAsLazilySwept();
+    PLATFORM_EXPORT bool hasBeenLazilySwept() const;
+
 private:
     PageMemory* m_storage;
     ThreadHeap* m_heap;
     // Whether the page is part of a terminating thread or not.
     bool m_terminating;
+
+protected:
+    // Track the (lazy) sweeping state of a page. The page's
+    // ThreadState keeps a sweep token value, with the page being
+    // updated with that value as it is swept.
+    //
+    // By comparing the ThreadState's current sweep token value with
+    // the page's sweep status, its swept/unswept status can
+    // readily be determined.
+    //
+    // 0 represents the unused/no-toggle state.
+    unsigned m_sweepStatus : 2;
 };
 
 class HeapPage final : public BaseHeapPage {
 public:
     HeapPage(PageMemory*, ThreadHeap*);
 
     Address payload()
     {
         return address() + sizeof(HeapPage) + headerPadding();
     }
@@ skipping 380 matching lines @@
     FreeList m_freeList;
 
     // Index into the page pools.  This is used to ensure that the pages of the
     // same type go into the correct page pool and thus avoid type confusion.
     int m_index;
 
     // The size of promptly freed objects in the heap.
     size_t m_promptlyFreedSize;
 };
 
+extern BaseHeapPage* pageFromObject(const void*);
+
 class PLATFORM_EXPORT Heap {
 public:
     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.
+    //
+    // isFinalizedObjectAlive() must not be used with already-finalized object
+    // references.
+    //
+    template<typename T>
+    static bool isFinalizedObjectAlive(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->heap()->threadState()->isSweepingInProgress())
+            return true;
+
+        if (page->hasBeenLazilySwept())
+            return true;
+
+        return ObjectAliveTrait<T>::isHeapObjectAlive(s_markingVisitor, const_cast<T*>(objectPointer));
+#else
+        // FIXME: remove when incremental sweeping is always on
+        // (cf. ThreadState::postGCProcessing()).
+        return true;
+#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);
 
     // Add a weak pointer callback to the weak callback work list.  General
     // object pointer callbacks are added to a thread local weak callback work
@@ skipping 1565 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