Oilpan: Remove a visitor parameter from isHeapObjectAlive

Source/platform/heap/HeapTest.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 125 matching lines @@
     bool isHashTableDeletedValue() const { return first == reinterpret_cast<IntWrapper*>(-1); }
 
     // Since we don't allocate independent objects of this type, we don't need
     // a regular trace method. Instead, we use a traceInCollection method. If
     // the entry should be deleted from the collection we return true and don't
     // trace the strong pointer.
     template<typename VisitorDispatcher>
     bool traceInCollection(VisitorDispatcher visitor, WTF::ShouldWeakPointersBeMarkedStrongly strongify)
     {
         visitor->traceInCollection(second, strongify);
-        if (!visitor->isHeapObjectAlive(second))
+        if (!Heap::isHeapObjectAlive(second))
             return true;
         // FIXME: traceInCollection is also called from WeakProcessing to check if the entry is dead.
         // The below if avoids calling trace in that case by only calling trace when |first| is not yet marked.
-        if (!visitor->isHeapObjectAlive(first))
+        if (!Heap::isHeapObjectAlive(first))
             visitor->trace(first);
         return false;
     }
 };
 
 template<typename T> struct WeakHandlingHashTraits : WTF::SimpleClassHashTraits<T> {
     // We want to treat the object as a weak object in the sense that it can
     // disappear from hash sets and hash maps.
     static const WTF::WeakHandlingFlag weakHandlingFlag = WTF::WeakHandlingInCollections;
     // Normally whether or not an object needs tracing is inferred
@@ skipping 128 matching lines @@
     virtual void registerDelayedMarkNoTracing(const void*) override { }
     virtual void registerWeakMembers(const void*, const void*, WeakCallback) override { }
     virtual void registerWeakTable(const void*, EphemeronCallback, EphemeronCallback) override { }
 #if ENABLE(ASSERT)
     virtual bool weakTableRegistered(const void*) override { return false; }
 #endif
     virtual void registerWeakCellWithCallback(void**, WeakCallback) override { }
 #if ENABLE(GC_PROFILING)
     virtual void recordObjectGraphEdge(const void*) override { }
 #endif
-    virtual bool isMarked(const void*) override { return false; }
     virtual bool ensureMarked(const void* objectPointer) override
     {
-        if (!objectPointer || isMarked(objectPointer))
+        if (!objectPointer || HeapObjectHeader::fromPayload(objectPointer)->isMarked())
             return false;
         markNoTracing(objectPointer);
         return true;
     }
 
     size_t count() { return m_count; }
     void reset() { m_count = 0; }
 
 private:
     StackFrameDepthScope m_scope;
@@ skipping 401 matching lines @@
 
 class ClassWithMember : public GarbageCollected<ClassWithMember> {
 public:
     static ClassWithMember* create()
     {
         return new ClassWithMember();
     }
 
     DEFINE_INLINE_TRACE()
     {
-        EXPECT_TRUE(visitor->isMarked(this));
+        EXPECT_TRUE(Heap::isHeapObjectAlive(this));
         if (!traceCount())
-            EXPECT_FALSE(visitor->isMarked(m_traceCounter));
+            EXPECT_FALSE(Heap::isHeapObjectAlive(m_traceCounter));
         else
-            EXPECT_TRUE(visitor->isMarked(m_traceCounter));
+            EXPECT_TRUE(Heap::isHeapObjectAlive(m_traceCounter));
 
         visitor->trace(m_traceCounter);
     }
 
     int traceCount() { return m_traceCounter->traceCount(); }
 
 private:
     ClassWithMember()
         : m_traceCounter(TraceCounter::create())
     { }
@@ skipping 353 matching lines @@
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_strongBar);
         visitor->template registerWeakMembers<Weak, &Weak::zapWeakMembers>(this);
     }
 
     void zapWeakMembers(Visitor* visitor)
     {
-        if (!visitor->isHeapObjectAlive(m_weakBar))
+        if (!Heap::isHeapObjectAlive(m_weakBar))
             m_weakBar = 0;
     }
 
     bool strongIsThere() { return !!m_strongBar; }
     bool weakIsThere() { return !!m_weakBar; }
 
 private:
     Weak(Bar* strongBar, Bar* weakBar)
         : Bar()
         , m_strongBar(strongBar)
@@ skipping 98 matching lines @@
     static FinalizationObserver* create(T* data) { return new FinalizationObserver(data); }
     bool didCallWillFinalize() const { return m_didCallWillFinalize; }
 
     DEFINE_INLINE_TRACE()
     {
         visitor->template registerWeakMembers<FinalizationObserver<T>, &FinalizationObserver<T>::zapWeakMembers>(this);
     }
 
     void zapWeakMembers(Visitor* visitor)
     {
-        if (m_data && !visitor->isHeapObjectAlive(m_data)) {
+        if (m_data && !Heap::isHeapObjectAlive(m_data)) {
             m_data->willFinalize();
             m_data = nullptr;
             m_didCallWillFinalize = true;
         }
     }
 
 private:
     FinalizationObserver(T* data)
         : m_data(data)
         , m_didCallWillFinalize(false)
@@ skipping 3529 matching lines @@
 
 // These special traits will remove a set from a map when the set is empty.
 struct EmptyClearingHashSetTraits : HashTraits<WeakSet> {
     static const WTF::WeakHandlingFlag weakHandlingFlag = WTF::WeakHandlingInCollections;
     template<typename VisitorDispatcher>
     static bool traceInCollection(VisitorDispatcher visitor, WeakSet& set, WTF::ShouldWeakPointersBeMarkedStrongly strongify)
     {
         bool liveEntriesFound = false;
         WeakSet::iterator end = set.end();
         for (WeakSet::iterator it = set.begin(); it != end; ++it) {
-            if (visitor->isHeapObjectAlive(*it)) {
+            if (Heap::isHeapObjectAlive(*it)) {
                 liveEntriesFound = true;
                 break;
             }
         }
         // If there are live entries in the set then the set cannot be removed
         // from the map it is contained in, and we need to mark it (and its
         // backing) live. We just trace normally, which will invoke the normal
         // weak handling for any entries that are not live.
         if (liveEntriesFound)
             set.trace(visitor);
@@ skipping 1329 matching lines @@
 {
     Persistent<ClassWithMember> object = ClassWithMember::create();
     EXPECT_EQ(0, object->traceCount());
     TestMixinAllocatingObject* mixin = TestMixinAllocatingObject::create(object.get());
     EXPECT_TRUE(mixin);
     EXPECT_GT(object->traceCount(), 0);
     EXPECT_GT(mixin->traceCount(), 0);
 }
 
 } // namespace blink