Store raw pointers in ScriptWrappableVisitor markind deque

third_party/WebKit/Source/platform/heap/TraceTraits.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 TraceTraits_h
 #define TraceTraits_h
 
 #include "platform/heap/GCInfo.h"
 #include "platform/heap/Heap.h"
 #include "platform/heap/InlinedGlobalMarkingVisitor.h"
@@ skipping 21 matching lines @@
 template<typename T> class WeakPersistent;
 
 template<typename T, bool = NeedsAdjustAndMark<T>::value> class AdjustAndMarkTrait;
 
 template<typename T>
 class AdjustAndMarkTrait<T, false> {
     STATIC_ONLY(AdjustAndMarkTrait);
 public:
     static void markWrapper(const WrapperVisitor* visitor, const T* t)
     {
-        if (visitor->markWrapperHeader(t)) {
+        if (visitor->markWrapperHeader(heapObjectHeader(t))) {
+            visitor->markWrappersInAllWorlds(t);
             visitor->dispatchTraceWrappers(t);
         }
     }
+    static HeapObjectHeader* heapObjectHeader(const T* t)
+    {
+        return HeapObjectHeader::fromPayload(t);
+    }
 
     template<typename VisitorDispatcher>
     static void mark(VisitorDispatcher visitor, const T* t)
     {
 #if ENABLE(ASSERT)
         assertObjectHasGCInfo(const_cast<T*>(t), GCInfoTrait<T>::index());
 #endif
         // Default mark method of the trait just calls the two-argument mark
         // method on the visitor. The second argument is the static trace method
         // of the trait, which by default calls the instance method
@@ skipping 22 matching lines @@
 };
 
 template<typename T>
 class AdjustAndMarkTrait<T, true> {
     STATIC_ONLY(AdjustAndMarkTrait);
 public:
     static void markWrapper(const WrapperVisitor* visitor, const T* t)
     {
         t->adjustAndMarkWrapper(visitor);
     }
+    static HeapObjectHeader* heapObjectHeader(const T* t)
+    {
+        return t->adjustAndGetHeapObjectHeader();
+    }
 
     template<typename VisitorDispatcher>
     static void mark(VisitorDispatcher visitor, const T* self)
     {
         if (!self)
             return;
 
         // If you hit this ASSERT, it means that there is a dangling pointer
         // from a live thread heap to a dead thread heap. We must eliminate
         // the dangling pointer.
@@ skipping 65 matching lines @@
 // needed is when multiple inheritance leads to pointers that are not
 // to the start of the object in the Blink garbage-collected heap. In
 // that case the pointer has to be adjusted before marking.
 template<typename T>
 class TraceTrait {
     STATIC_ONLY(TraceTrait);
 public:
     static void trace(Visitor*, void* self);
     static void trace(InlinedGlobalMarkingVisitor, void* self);
 
-    static void markWrapper(const WrapperVisitor* visitor, const T* t)
+    static void markWrapper(const WrapperVisitor* visitor, const void* t)
     {
-        AdjustAndMarkTrait<T>::markWrapper(visitor, t);
+        AdjustAndMarkTrait<T>::markWrapper(visitor, reinterpret_cast<const T*>(t));
+    }
+    static HeapObjectHeader* heapObjectHeader(const void* t)
+    {
+        return AdjustAndMarkTrait<T>::heapObjectHeader(reinterpret_cast<const T*>(t));
     }
 
     template<typename VisitorDispatcher>
     static void mark(VisitorDispatcher visitor, const T* t)
     {
         AdjustAndMarkTrait<T>::mark(visitor, t);
     }
 };
 
 template<typename T> class TraceTrait<const T> : public TraceTrait<T> { };
@@ skipping 408 matching lines @@
         // since iterating over the hash table backing will find the whole
         // chain.
         visitor->markNoTracing(node);
         return false;
     }
 };
 
 } // namespace WTF
 
 #endif