Oilpan: Remove a visitor parameter from isHeapObjectAlive

Source/platform/heap/ThreadState.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 886 matching lines @@
 
     {
         if (isMainThread())
             ScriptForbiddenScope::enter();
 
         SweepForbiddenScope forbiddenScope(this);
         {
             // Disallow allocation during weak processing.
             NoAllocationScope noAllocationScope(this);
             {
+                // Perform thread-specific weak processing.
                 TRACE_EVENT0("blink_gc", "ThreadState::threadLocalWeakProcessing");
-                // Perform thread-specific weak processing.
+                // TODO(haraken): It is wrong to unconditionally use
+                // s_markingVisitor, which is for GlobalMarking.
+                // ThreadTerminationGC should use a visitor for
+                // ThreadLocalMarking. However, a better fix is just to remove
+                // the visitor parameter. The only user of the visitor parameter
+                // is HashTable::process.
                 while (popAndInvokeThreadLocalWeakCallback(Heap::s_markingVisitor)) { }
             }
             {
                 TRACE_EVENT0("blink_gc", "ThreadState::invokePreFinalizers");
-                invokePreFinalizers(*Heap::s_markingVisitor);
+                invokePreFinalizers();
             }
         }
 
         if (isMainThread())
             ScriptForbiddenScope::exit();
     }
 
 #if defined(ADDRESS_SANITIZER)
 // TODO(Oilpan): enable the poisoning always.
 #if ENABLE(OILPAN)
@@ skipping 280 matching lines @@
 void ThreadState::unregisterPreFinalizerInternal(void* target)
 {
     checkThread();
     if (sweepForbidden())
         return;
     auto it = m_preFinalizers.find(target);
     ASSERT(it != m_preFinalizers.end());
     m_preFinalizers.remove(it);
 }
 
-void ThreadState::invokePreFinalizers(Visitor& visitor)
+void ThreadState::invokePreFinalizers()
 {
     checkThread();
     Vector<void*> deadObjects;
     for (auto& entry : m_preFinalizers) {
-        if (entry.value(entry.key, visitor))
+        if (entry.value(entry.key))
             deadObjects.append(entry.key);
     }
     // FIXME: removeAll is inefficient.  It can shrink repeatedly.
     m_preFinalizers.removeAll(deadObjects);
 }
 
 void ThreadState::clearHeapAges()
 {
     memset(m_heapAges, 0, sizeof(size_t) * NumberOfHeaps);
     memset(m_likelyToBePromptlyFreed.get(), 0, sizeof(int) * likelyToBePromptlyFreedArraySize);
@@ skipping 121 matching lines @@
         json->beginArray(it->key.ascii().data());
         for (size_t age = 0; age <= maxHeapObjectAge; ++age)
             json->pushInteger(it->value.ages[age]);
         json->endArray();
     }
     TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(TRACE_DISABLED_BY_DEFAULT("blink_gc"), statsName, this, json.release());
 }
 #endif
 
 } // namespace blink