Store raw pointers in ScriptWrappableVisitor markind deque

third_party/WebKit/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/Allocator.h"
 #include "wtf/Assertions.h"
@@ skipping 56 matching lines @@
 //
 class PLATFORM_EXPORT GarbageCollectedMixin {
 public:
     typedef int IsGarbageCollectedMixinMarker;
     virtual void adjustAndMark(Visitor*) const = 0;
     virtual void trace(Visitor*) { }
     virtual void adjustAndMark(InlinedGlobalMarkingVisitor) const = 0;
     virtual void trace(InlinedGlobalMarkingVisitor);
     virtual void adjustAndMarkWrapper(const WrapperVisitor*) const = 0;
     virtual bool isHeapObjectAlive() const = 0;
+    virtual HeapObjectHeader* adjustAndGetHeapObjectHeader() const = 0;
 };
 
 #define DEFINE_GARBAGE_COLLECTED_MIXIN_METHODS(VISITOR, TYPE)           \
     public:                                                             \
     void adjustAndMark(VISITOR visitor) const override                  \
     {                                                                   \
         typedef WTF::IsSubclassOfTemplate<typename std::remove_const<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); \
     }                                                                   \
     private:
 
 #define DEFINE_GARBAGE_COLLECTED_MIXIN_WRAPPER_METHODS(TYPE)            \
     public:                                                             \
     void adjustAndMarkWrapper(const WrapperVisitor* visitor) const override \
     {                                                                   \
         typedef WTF::IsSubclassOfTemplate<typename std::remove_const<TYPE>::type, blink::GarbageCollected> IsSubclassOfGarbageCollected; \
         static_assert(IsSubclassOfGarbageCollected::value, "only garbage collected objects can have garbage collected mixins"); \
-        if (visitor->markWrapperHeader(static_cast<const TYPE*>(this))) { \
-            visitor->dispatchTraceWrappers(static_cast<const TYPE*>(this)); \
-        }                                                               \
+        TraceTrait<TYPE>::markWrapper(visitor, static_cast<const TYPE*>(this));  \
+    }                                                                   \
+    HeapObjectHeader* adjustAndGetHeapObjectHeader() const override     \
+    {                                                                   \
+        typedef WTF::IsSubclassOfTemplate<typename std::remove_const<TYPE>::type, blink::GarbageCollected> IsSubclassOfGarbageCollected; \
+        static_assert(IsSubclassOfGarbageCollected::value, "only garbage collected objects can have garbage collected mixins"); \
+        return TraceTrait<TYPE>::heapObjectHeader(static_cast<const TYPE*>(this)); \
     }                                                                   \
     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
@@ skipping 148 matching lines @@
     template<typename U, size_t sz = sizeof(U)> static TrueType isSizeofKnown(U*);
     static FalseType isSizeofKnown(...);
     static T& t;
 public:
     static const bool value = sizeof(TrueType) == sizeof(isSizeofKnown(&t));
 };
 
 } // namespace blink
 
 #endif