Oilpan: Remove a visitor parameter from isHeapObjectAlive

Source/platform/heap/GarbageCollected.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef GarbageCollected_h
 #define GarbageCollected_h
 
 #include "platform/heap/ThreadState.h"
 #include "wtf/Assertions.h"
 #include "wtf/ListHashSet.h"
@@ skipping 94 matching lines @@
 // };
 //
 // With the helper, as long as we are using Member<B>, TypeTrait<B> will
 // dispatch adjustAndMark dynamically to find collect addr of the object header.
 // Note that this is only enabled for Member<B>. For Member<A> which we can
 // compute the object header addr statically, this dynamic dispatch is not used.
 class PLATFORM_EXPORT GarbageCollectedMixin {
 public:
     typedef int IsGarbageCollectedMixinMarker;
     virtual void adjustAndMark(Visitor*) const = 0;
-    virtual bool isHeapObjectAlive(Visitor*) const = 0;
     virtual void trace(Visitor*) { }
     virtual void adjustAndMark(InlinedGlobalMarkingVisitor) const = 0;
-    virtual bool isHeapObjectAlive(InlinedGlobalMarkingVisitor) const = 0;
     virtual void trace(InlinedGlobalMarkingVisitor);
+    virtual bool isHeapObjectAlive() const = 0;
 };
 
 #define DEFINE_GARBAGE_COLLECTED_MIXIN_METHODS(VISITOR, TYPE)           \
     public:                                                             \
     virtual void adjustAndMark(VISITOR visitor) const override          \
     {                                                                   \
         typedef WTF::IsSubclassOfTemplate<typename WTF::RemoveConst<TYPE>::Type, blink::GarbageCollected> IsSubclassOfGarbageCollected; \
         static_assert(IsSubclassOfGarbageCollected::value, "only garbage collected objects can have garbage collected mixins"); \
         if (TraceEagerlyTrait<TYPE>::value) {                           \
             if (visitor->ensureMarked(static_cast<const TYPE*>(this)))  \
                 TraceTrait<TYPE>::trace(visitor, const_cast<TYPE*>(this)); \
             return;                                                     \
         }                                                               \
         visitor->mark(static_cast<const TYPE*>(this), &blink::TraceTrait<TYPE>::trace); \
     }                                                                   \
-    virtual bool isHeapObjectAlive(VISITOR visitor) const override      \
-    {                                                                   \
-        return visitor->isHeapObjectAlive(this);                        \
-    }                                                                   \
-private:
+    private:
 
 // A C++ object's vptr will be initialized to its leftmost base's vtable after
 // the constructors of all its subclasses have run, so if a subclass constructor
 // tries to access any of the vtbl entries of its leftmost base prematurely,
 // it'll find an as-yet incorrect vptr and fail. Which is exactly what a
 // garbage collector will try to do if it tries to access the leftmost base
 // while one of the subclass constructors of a GC mixin object triggers a GC.
 // It is consequently not safe to allow any GCs while these objects are under
 // (sub constructor) construction.
 //
 // To prevent GCs in that restricted window of a mixin object's construction:
 //
 //  - The initial allocation of the mixin object will enter a no GC scope.
 //    This is done by overriding 'operator new' for mixin instances.
 //  - When the constructor for the mixin is invoked, after all the
 //    derived constructors have run, it will invoke the constructor
 //    for a field whose only purpose is to leave the GC scope.
 //    GarbageCollectedMixinConstructorMarker's constructor takes care of
 //    this and the field is declared by way of USING_GARBAGE_COLLECTED_MIXIN().
 
-#define DEFINE_GARBAGE_COLLECTED_MIXIN_CONSTRUCTOR_MARKER(TYPE)                         \
-public:                                                                                 \
-    GC_PLUGIN_IGNORE("crbug.com/456823") NO_SANITIZE_UNRELATED_CAST                     \
-    void* operator new(size_t size)                                                     \
-    {                                                                                   \
-        void* object = TYPE::allocateObject(size);                                      \
-        ThreadState* state = ThreadStateFor<ThreadingTrait<TYPE>::Affinity>::state();   \
+#define DEFINE_GARBAGE_COLLECTED_MIXIN_CONSTRUCTOR_MARKER(TYPE)         \
+    public:                                                             \

[Yuta Kitamura, 2015/06/03 04:58:29]

This indent looks wrong; inconsistent with ll. 191-196.

+    GC_PLUGIN_IGNORE("crbug.com/456823") NO_SANITIZE_UNRELATED_CAST     \
+    void* operator new(size_t size)                                     \
+    {                                                                   \
+        void* object = TYPE::allocateObject(size);                      \
+        ThreadState* state = ThreadStateFor<ThreadingTrait<TYPE>::Affinity>::state(); \
         state->enterGCForbiddenScopeIfNeeded(&(reinterpret_cast<TYPE*>(object)->m_mixinConstructorMarker)); \
-        return object;                                                                  \
-    }                                                                                   \
-    GarbageCollectedMixinConstructorMarker m_mixinConstructorMarker;                    \
-private:
+        return object;                                                  \
+    }                                                                   \
+    GarbageCollectedMixinConstructorMarker m_mixinConstructorMarker;    \
+    private:
 
 // Mixins that wrap/nest others requires extra handling:
 //
 //  class A : public GarbageCollected<A>, public GarbageCollectedMixin {
 //  USING_GARBAGE_COLLECTED_MIXIN(A);
 //  ...
 //  }'
 //  public B final : public A, public SomeOtherMixinInterface {
 //  USING_GARBAGE_COLLECTED_MIXIN(B);
 //  ...
 //  };
 //
 // The "operator new" for B will enter the forbidden GC scope, but
 // upon construction, two GarbageCollectedMixinConstructorMarker constructors
 // will run -- one for A (first) and another for B (secondly). Only
 // the second one should leave the forbidden GC scope. This is realized by
 // recording the address of B's GarbageCollectedMixinConstructorMarker
 // when the "operator new" for B runs, and leaving the forbidden GC scope
 // when the constructor of the recorded GarbageCollectedMixinConstructorMarker
 // runs.
-#define USING_GARBAGE_COLLECTED_MIXIN(TYPE)                       \
-    DEFINE_GARBAGE_COLLECTED_MIXIN_METHODS(blink::Visitor*, TYPE) \
+#define USING_GARBAGE_COLLECTED_MIXIN(TYPE)                             \
+    DEFINE_GARBAGE_COLLECTED_MIXIN_METHODS(blink::Visitor*, TYPE)       \
     DEFINE_GARBAGE_COLLECTED_MIXIN_METHODS(blink::InlinedGlobalMarkingVisitor, TYPE) \
-    DEFINE_GARBAGE_COLLECTED_MIXIN_CONSTRUCTOR_MARKER(TYPE)
+    DEFINE_GARBAGE_COLLECTED_MIXIN_CONSTRUCTOR_MARKER(TYPE)             \
+public:                                                                 \
+    virtual bool isHeapObjectAlive() const override                     \
+    {                                                                   \
+        return Heap::isHeapObjectAlive(this);                           \
+    }                                                                   \
+private:
 
 #if ENABLE(OILPAN)
 #define WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(TYPE) USING_GARBAGE_COLLECTED_MIXIN(TYPE)
 #else
 #define WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(TYPE)
 #endif
 
 // An empty class with a constructor that's arranged invoked when all derived constructors
 // of a mixin instance have completed and it is safe to allow GCs again. See
 // AllocateObjectTrait<> comment for more.
@@ skipping 190 matching lines @@
         void* operator new(size_t, NotNullTag, void*) = delete; \
         void* operator new(size_t, void*) = delete;
 
 #define GC_PLUGIN_IGNORE(bug)                           \
     __attribute__((annotate("blink_gc_plugin_ignore")))
 #else
 #define STACK_ALLOCATED() DISALLOW_ALLOCATION()
 #define GC_PLUGIN_IGNORE(bug)
 #endif
 
+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;
+
 } // namespace blink
 
 #endif