Do not fire timers for finalizing objects.

Source/platform/heap/Heap.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 2107 matching lines @@
 
 #if !ENABLE(ASSERT)
     s_heapDoesNotContainCache->addEntry(address);
 #else
     if (!s_heapDoesNotContainCache->lookup(address))
         s_heapDoesNotContainCache->addEntry(address);
 #endif
     return nullptr;
 }
 
+bool Heap::isObjectAlive(const void* objectPointer)
+{
+    if (!ThreadState::current()->isSweepingInProgress())
+        return true;
+
+    return s_markingVisitor->isMarked(objectPointer);

[haraken, 2015/01/14 14:29:08]

Hmm, what happens in the following case?

(1) Marking marks object A and B.
(2) Lazy sweeping unmarks A.
(3) isObjectAlive(X) is called.
(4) Lazy sweeping unmarks B.
(5) Lazy sweeping is complete.

In this case, isObjectAlive(X) returns false if X==A, but returns true if X==B.
This seems wrong.

[sof, 2015/01/14 14:36:19]

I suppose we can look at the page & see if it has yet to be swept. If we can
assume no cross thread access here, that would do it. 

[haraken, 2015/01/14 14:37:44]

That would work :)

Also should we use isMarked or isAlive? (I haven't studied code.)

[sof, 2015/01/14 15:53:32]

Actually, if we constrain ourselves to GC objects with finalizers, the CL as is
(ps#1) is sufficient. The method could have a better name in that case though.

Can be generalized later (but hopefully we won't have to.)

[sof, 2015/01/14 16:06:01]

Renamed to isFinalizedObjectAlive() + clarified that the predicate isn't
supported over already finalized references.

+}
+
 #if ENABLE(GC_PROFILE_MARKING)
 const GCInfo* Heap::findGCInfo(Address address)
 {
     return ThreadState::findGCInfoFromAllThreads(address);
 }
 #endif
 
 #if ENABLE(GC_PROFILE_MARKING)
 void Heap::dumpPathToObjectOnNextGC(void* p)
 {
@@ skipping 548 matching lines @@
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
 FreePagePool* Heap::s_freePagePool;
 OrphanedPagePool* Heap::s_orphanedPagePool;
 Heap::RegionTree* Heap::s_regionTree = nullptr;
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 
 } // namespace blink