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; }
     ThreadState* threadState() const { return m_threadState; }
     bool orphaned() { return !m_threadState; }
     bool terminating() { return m_terminating; }
     void setTerminating() { m_terminating = true; }
 
+    void markAsLazilySwept();
+    bool hasBeenLazilySwept() const;
+
 private:
     PageMemory* m_storage;
     ThreadState* m_threadState;
     // 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 392 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 has been marked. An unmarked object is otherwise
+    // slated for finalization once swept, and false is returned.
+    //
+    // The predicate must not be used with already finalized object
+    // references.
+    static bool isFinalizedObjectAlive(const void*);
+
     // 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