Oilpan: Remove a visitor parameter from isHeapObjectAlive

Source/platform/heap/Visitor.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 123 matching lines @@
     template <typename VisitorDispatcher>                                                             \
     inline void traceAfterDispatchImpl(VisitorDispatcher visitor)
 
 #define EMPTY_MACRO_ARGUMENT
 
 #define DECLARE_TRACE() DECLARE_TRACE_IMPL(EMPTY_MACRO_ARGUMENT)
 #define DECLARE_VIRTUAL_TRACE() DECLARE_TRACE_IMPL(virtual)
 #define DEFINE_INLINE_TRACE() DEFINE_INLINE_TRACE_IMPL(EMPTY_MACRO_ARGUMENT)
 #define DEFINE_INLINE_VIRTUAL_TRACE() DEFINE_INLINE_TRACE_IMPL(virtual)
 
-template<typename T, bool = WTF::IsSubclassOfTemplate<typename WTF::RemoveConst<T>::Type, GarbageCollected>::value> class NeedsAdjustAndMark;
-
-template<typename T>
-class NeedsAdjustAndMark<T, true> {
-    static_assert(sizeof(T), "T must be fully defined");
-public:
-    static const bool value = false;
-};
-template <typename T> const bool NeedsAdjustAndMark<T, true>::value;
-
-template<typename T>
-class NeedsAdjustAndMark<T, false> {
-    static_assert(sizeof(T), "T must be fully defined");
-public:
-    static const bool value = IsGarbageCollectedMixin<typename WTF::RemoveConst<T>::Type>::value;
-};
-template <typename T> const bool NeedsAdjustAndMark<T, false>::value;
-
-template<typename T, bool = NeedsAdjustAndMark<T>::value> class ObjectAliveTrait;
-
-template<typename T>
-class ObjectAliveTrait<T, false> {
-public:
-    template<typename VisitorDispatcher>
-    static bool isHeapObjectAlive(VisitorDispatcher visitor, T* obj)
-    {
-        static_assert(sizeof(T), "T must be fully defined");
-        return visitor->isMarked(obj);
-    }
-};
-
-template<typename T>
-class ObjectAliveTrait<T, true> {
-public:
-    template<typename VisitorDispatcher>
-    static bool isHeapObjectAlive(VisitorDispatcher visitor, T* obj)
-    {
-        static_assert(sizeof(T), "T must be fully defined");
-        return obj->isHeapObjectAlive(visitor);
-    }
-};
-
 // VisitorHelper contains common implementation of Visitor helper methods.
 //
 // VisitorHelper avoids virtual methods by using CRTP.
 // c.f. http://en.wikipedia.org/wiki/Curiously_Recurring_Template_Pattern
 template<typename Derived>
 class VisitorHelper {
 public:
     // One-argument templated mark method. This uses the static type of
     // the argument to get the TraceTrait. By default, the mark method
     // of the TraceTrait just calls the virtual two-argument mark method on this
@@ skipping 150 matching lines @@
     template<typename T, void (T::*method)(Visitor*)>
     void registerWeakMembers(const T* obj)
     {
         registerWeakMembers(obj, &TraceMethodDelegate<T, method>::trampoline);
     }
     void registerWeakMembers(const void* object, WeakCallback callback)
     {
         Derived::fromHelper(this)->registerWeakMembers(object, object, callback);
     }
 
-    template<typename T> inline bool isHeapObjectAlive(T* obj)
-    {
-        static_assert(sizeof(T), "T must be fully defined");
-        // The strongification of collections relies on the fact that once a
-        // collection has been strongified, there is no way that it can contain
-        // non-live entries, so no entries will be removed. Since you can't set
-        // the mark bit on a null pointer, that means that null pointers are
-        // always 'alive'.
-        if (!obj)
-            return true;
-        return ObjectAliveTrait<T>::isHeapObjectAlive(Derived::fromHelper(this), obj);
-    }
-    template<typename T> inline bool isHeapObjectAlive(const Member<T>& member)
-    {
-        return isHeapObjectAlive(member.get());
-    }
-    template<typename T> inline bool isHeapObjectAlive(const WeakMember<T>& member)
-    {
-        return isHeapObjectAlive(member.get());
-    }
-    template<typename T> inline bool isHeapObjectAlive(const RawPtr<T>& ptr)
-    {
-        return isHeapObjectAlive(ptr.get());
-    }
-
 private:
-    template <typename T>
-    static void handleWeakCell(Visitor* self, void* obj);
+    template<typename T>
+    static void handleWeakCell(Visitor* self, void* object);
 };
 
 // Visitor is used to traverse the Blink object graph. Used for the
 // marking phase of the mark-sweep garbage collector.
 //
 // Pointers are marked and pushed on the marking stack by calling the
 // |mark| method with the pointer as an argument.
 //
 // Pointers within objects are traced by calling the |trace| methods
 // with the object as an argument. Tracing objects will mark all of the
@@ skipping 51 matching lines @@
     // the weak callback. Since other threads have been resumed the
     // mark bits are not valid for objects from other threads.
     virtual void registerWeakMembers(const void*, const void*, WeakCallback) = 0;
     using VisitorHelper<Visitor>::registerWeakMembers;
 
     virtual void registerWeakTable(const void*, EphemeronCallback, EphemeronCallback) = 0;
 #if ENABLE(ASSERT)
     virtual bool weakTableRegistered(const void*) = 0;
 #endif
 
-    virtual bool isMarked(const void*) = 0;
     virtual bool ensureMarked(const void*) = 0;
 
 #if ENABLE(GC_PROFILING)
     void setHostInfo(void* object, const String& name)
     {
         m_hostObject = object;
         m_hostName = name;
     }
 #endif
 
@@ skipping 15 matching lines @@
 #if ENABLE(ASSERT)
     virtual void checkMarkingAllowed() { }
 #endif
 
 private:
     static Visitor* fromHelper(VisitorHelper<Visitor>* helper) { return static_cast<Visitor*>(helper); }
 
     bool m_isGlobalMarkingVisitor;
 };
 
-template <typename Derived>
-template <typename T>
-void VisitorHelper<Derived>::handleWeakCell(Visitor* self, void* obj)
-{
-    T** cell = reinterpret_cast<T**>(obj);
-    if (*cell && !self->isHeapObjectAlive(*cell))
-        *cell = nullptr;
-}
-
 #if ENABLE(GC_PROFILING)
 template<typename T>
 struct TypenameStringTrait {
     static const String& get()
     {
         DEFINE_STATIC_LOCAL(String, typenameString, (WTF::extractTypeNameFromFunctionName(WTF::extractNameFunction<T>())));
         return typenameString;
     }
 };
 #endif
 
 } // namespace blink
 
 #endif // Visitor_h