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 729 matching lines @@
         HeapPage* page = m_firstUnsweptPage;
         if (page->isEmpty()) {
             page->unlink(&m_firstUnsweptPage);
             page->removeFromHeap(this);
         } else {
             // Sweep a page and move the page from m_firstUnsweptPages to
             // m_firstPages.
             page->sweep();
             page->unlink(&m_firstUnsweptPage);
             page->link(&m_firstPage);
+            page->markAsSwept();
 
             result = allocateFromFreeList(allocationSize, gcInfoIndex);
-            if (result) {
+            if (result)
                 break;
-            }
         }
     }
 
     if (threadState()->isMainThread())
         ScriptForbiddenScope::exit();
     return result;
 }
 
 bool ThreadHeap::lazySweepLargeObjects(size_t allocationSize)
 {
@@ skipping 32 matching lines @@
             if (sweptSize >= allocationSize) {
                 result = true;
                 break;
             }
         } else {
             // Sweep a large object and move the large object from
             // m_firstUnsweptLargeObjects to m_firstLargeObjects.
             largeObject->sweep();
             largeObject->unlink(&m_firstUnsweptLargeObject);
             largeObject->link(&m_firstLargeObject);
+            largeObject->markAsSwept();
         }
     }
 
     if (threadState()->isMainThread())
         ScriptForbiddenScope::exit();
     return result;
 }
 
 void ThreadHeap::completeSweep()
 {
     RELEASE_ASSERT(threadState()->isSweepingInProgress());
     ASSERT(threadState()->sweepForbidden());
 
     if (threadState()->isMainThread())
         ScriptForbiddenScope::enter();
 
     // Sweep normal pages.
     while (m_firstUnsweptPage) {
         HeapPage* page = m_firstUnsweptPage;
         if (page->isEmpty()) {
             page->unlink(&m_firstUnsweptPage);
             page->removeFromHeap(this);
         } else {
             // Sweep a page and move the page from m_firstUnsweptPages to
             // m_firstPages.
             page->sweep();
             page->unlink(&m_firstUnsweptPage);
             page->link(&m_firstPage);
+            page->markAsSwept();
         }
     }
 
     // Sweep large objects.
     while (m_firstUnsweptLargeObject) {
         LargeObject* largeObject = m_firstUnsweptLargeObject;
         if (largeObject->isEmpty()) {
             largeObject->unlink(&m_firstUnsweptLargeObject);
             largeObject->removeFromHeap(this);
         } else {
             // Sweep a large object and move the large object from
             // m_firstUnsweptLargeObjects to m_firstLargeObjects.
             largeObject->sweep();
             largeObject->unlink(&m_firstUnsweptLargeObject);
             largeObject->link(&m_firstLargeObject);
+            largeObject->markAsSwept();
         }
     }
 
     if (threadState()->isMainThread())
         ScriptForbiddenScope::exit();
 }
 
 #if ENABLE(ASSERT)
 static bool isLargeObjectAligned(LargeObject* largeObject, Address address)
 {
@@ skipping 367 matching lines @@
         // We got some memory, but failed to commit it, try again.
         delete memory;
     }
     return nullptr;
 }
 
 BaseHeapPage::BaseHeapPage(PageMemory* storage, ThreadHeap* heap)
     : m_storage(storage)
     , m_heap(heap)
     , m_terminating(false)
+    , m_swept(true)
 {
     ASSERT(isPageHeaderAddress(reinterpret_cast<Address>(this)));
 }
 
 void BaseHeapPage::markOrphaned()
 {
     m_heap = nullptr;
     m_terminating = false;
     // Since we zap the page payload for orphaned pages we need to mark it as
     // unused so a conservative pointer won't interpret the object headers.
@@ skipping 189 matching lines @@
     if (hasCurrentAllocationArea()) {
         if (pagesToBeSweptContains(currentAllocationPoint()))
             return false;
     }
     return true;
 }
 #endif
 
 void ThreadHeap::makeConsistentForSweeping()
 {
-    markUnmarkedObjectsDead();
+    preparePagesForSweeping();
     setAllocationPoint(nullptr, 0);
     clearFreeLists();
 }
 
-void ThreadHeap::markUnmarkedObjectsDead()
+void ThreadHeap::preparePagesForSweeping()
 {
     ASSERT(isConsistentForSweeping());
+    for (HeapPage* page = m_firstPage; page; page = page->next())
+        page->markAsUnswept();
+
     // If a new GC is requested before this thread got around to sweep,
     // ie. due to the thread doing a long running operation, we clear
     // the mark bits and mark any of the dead objects as dead. The latter
     // is used to ensure the next GC marking does not trace already dead
     // objects. If we trace a dead object we could end up tracing into
     // garbage or the middle of another object via the newly conservatively
     // found object.
     HeapPage* previousPage = nullptr;
     for (HeapPage* page = m_firstUnsweptPage; page; previousPage = page, page = page->next()) {
         page->markUnmarkedObjectsDead();
+        ASSERT(!page->hasBeenSwept());
     }
     if (previousPage) {
         ASSERT(m_firstUnsweptPage);
         previousPage->m_next = m_firstPage;
         m_firstPage = m_firstUnsweptPage;
         m_firstUnsweptPage = nullptr;
     }
     ASSERT(!m_firstUnsweptPage);
 
+    for (LargeObject* largeObject = m_firstLargeObject; largeObject; largeObject = largeObject->next())
+        largeObject->markAsUnswept();
+
     LargeObject* previousLargeObject = nullptr;
     for (LargeObject* largeObject = m_firstUnsweptLargeObject; largeObject; previousLargeObject = largeObject, largeObject = largeObject->next()) {
         largeObject->markUnmarkedObjectsDead();
+        ASSERT(!largeObject->hasBeenSwept());
     }
     if (previousLargeObject) {
         ASSERT(m_firstUnsweptLargeObject);
         previousLargeObject->m_next = m_firstLargeObject;
         m_firstLargeObject = m_firstUnsweptLargeObject;
         m_firstUnsweptLargeObject = nullptr;
     }
     ASSERT(!m_firstUnsweptLargeObject);
 }
 
@@ skipping 25 matching lines @@
     , m_next(nullptr)
 {
     m_objectStartBitMapComputed = false;
     ASSERT(isPageHeaderAddress(reinterpret_cast<Address>(this)));
 }
 
 size_t HeapPage::objectPayloadSizeForTesting()
 {
     size_t objectPayloadSize = 0;
     Address headerAddress = payload();
+    markAsSwept();
     ASSERT(headerAddress != payloadEnd());
     do {
         HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(headerAddress);
         if (!header->isFree()) {
             header->checkHeader();
             objectPayloadSize += header->payloadSize();
         }
         ASSERT(header->size() < blinkPagePayloadSize());
         headerAddress += header->size();
         ASSERT(headerAddress <= payloadEnd());
@@ skipping 214 matching lines @@
             // Count objects that are dead before the final generation.
             if (age < maxHeapObjectAge)
                 info->generations[tag][age] += 1;
         }
     }
 }
 #endif
 
 size_t LargeObject::objectPayloadSizeForTesting()
 {
+    markAsSwept();
     return payloadSize();
 }
 
 #if ENABLE(GC_PROFILE_HEAP)
 void LargeObject::snapshot(TracedValue* json, ThreadState::SnapshotInfo* info)
 {
     HeapObjectHeader* header = heapObjectHeader();
     size_t tag = info->getClassTag(Heap::gcInfo(header->gcInfoIndex()));
     size_t age = header->age();
     if (header->isMarked()) {
@@ skipping 929 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