[wrapper-tracing] Simplify tracing by forbidding tracing from within mixins

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 29 matching lines @@
 class WeakPersistent;
 
 template <typename T, bool = NeedsAdjustAndMark<T>::value>
 class AdjustAndMarkTrait;
 
 template <typename T>
 class AdjustAndMarkTrait<T, false> {
   STATIC_ONLY(AdjustAndMarkTrait);
 
  public:
-  static void markAndTraceWrapper(const WrapperVisitor* visitor, const T* t) {
-    if (visitor->markWrapperHeader(heapObjectHeader(t))) {
-      visitor->markWrappersInAllWorlds(t);
-      visitor->dispatchTraceWrappers(t);
-    }
-  }
-  static void markWrapperNoTracing(const WrapperVisitor* visitor, const T* t) {
-    DCHECK(!heapObjectHeader(t)->isWrapperHeaderMarked());
-    visitor->markWrapperHeader(heapObjectHeader(t));
-  }
-  static void traceMarkedWrapper(const WrapperVisitor* visitor, const T* t) {
-    DCHECK(heapObjectHeader(t)->isWrapperHeaderMarked());
-    // The term *mark* is misleading here as we effectively trace through the
-    // API boundary, i.e., tell V8 that an object is alive. Actual marking
-    // will be done in V8.
-    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
     // trace(Visitor*) on the object.
     //
@@ skipping 22 matching lines @@
     }
     visitor->mark(const_cast<T*>(t), &TraceTrait<T>::trace);
   }
 };
 
 template <typename T>
 class AdjustAndMarkTrait<T, true> {
   STATIC_ONLY(AdjustAndMarkTrait);
 
  public:
-  static void markAndTraceWrapper(const WrapperVisitor* visitor, const T* t) {
-    t->adjustAndMarkAndTraceWrapper(visitor);
-  }
-  static void markWrapperNoTracing(const WrapperVisitor* visitor, const T* t) {
-    t->adjustAndMarkWrapperNoTracing(visitor);
-  }
-  static void traceMarkedWrapper(const WrapperVisitor* visitor, const T* t) {
-    t->adjustAndTraceMarkedWrapper(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.
     // Release builds don't have the ASSERT, but it is OK because
     // release builds will crash at the following self->adjustAndMark
@@ skipping 79 matching lines @@
 // 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 markAndTraceWrapper(const WrapperVisitor* visitor,
-                                  const void* t) {
-    static_assert(CanTraceWrappers<T>::value,
-                  "T should be able to trace wrappers. See "
-                  "dispatchTraceWrappers in WrapperVisitor.h");
-    AdjustAndMarkTrait<T>::markAndTraceWrapper(visitor,
-                                               reinterpret_cast<const T*>(t));
-  }
-  static void markWrapperNoTracing(const WrapperVisitor* visitor,
-                                   const void* t) {
-    static_assert(CanTraceWrappers<T>::value,
-                  "T should be able to trace wrappers. See "
-                  "dispatchTraceWrappers in WrapperVisitor.h");
-    AdjustAndMarkTrait<T>::markWrapperNoTracing(visitor,
-                                                reinterpret_cast<const T*>(t));
-  }
-  static void traceMarkedWrapper(const WrapperVisitor* visitor, const void* t) {
-    static_assert(CanTraceWrappers<T>::value,
-                  "T should be able to trace wrappers. See "
-                  "dispatchTraceWrappers in WrapperVisitor.h");
-    AdjustAndMarkTrait<T>::traceMarkedWrapper(visitor,
-                                              reinterpret_cast<const T*>(t));
-  }
-  static HeapObjectHeader* heapObjectHeader(const void* t) {
-    static_assert(CanTraceWrappers<T>::value,
-                  "T should be able to trace wrappers. See "
-                  "dispatchTraceWrappers in WrapperVisitor.h");
-    return AdjustAndMarkTrait<T>::heapObjectHeader(
-        reinterpret_cast<const T*>(t));
-  }
+  static void markAndTraceWrapper(const WrapperVisitor*, const void*);
+  static void markWrapperNoTracing(const WrapperVisitor*, const void*);
+  static void traceMarkedWrapper(const WrapperVisitor*, const void*);
+  static HeapObjectHeader* heapObjectHeader(const void*);
 
   template <typename VisitorDispatcher>
   static void mark(VisitorDispatcher visitor, const T* t) {
     AdjustAndMarkTrait<T>::mark(visitor, t);
   }
+
+ private:
+  static const T* ToWrapperTracingType(const void* t) {
+    static_assert(CanTraceWrappers<T>::value,
+                  "T should be able to trace wrappers. See "
+                  "dispatchTraceWrappers in WrapperVisitor.h");
+    static_assert(!NeedsAdjustAndMark<T>::value,
+                  "wrapper tracing is not supported within mixins");
+#if DCHECK_IS_ON()
+    DCHECK(HeapObjectHeader::fromPayload(t)->checkHeader());
+#endif
+    return reinterpret_cast<const T*>(t);
+  }
 };
 
 template <typename T>
 class TraceTrait<const T> : public TraceTrait<T> {};
 
 template <typename T>
 void TraceTrait<T>::trace(Visitor* visitor, void* self) {
   static_assert(WTF::IsTraceable<T>::value, "T should not be traced");
   if (visitor->isGlobalMarking()) {
     // Switch to inlined global marking dispatch.
     static_cast<T*>(self)->trace(InlinedGlobalMarkingVisitor(
         visitor->state(), visitor->getMarkingMode()));
   } else {
     static_cast<T*>(self)->trace(visitor);
   }
 }
 
 template <typename T>
 void TraceTrait<T>::trace(InlinedGlobalMarkingVisitor visitor, void* self) {
   static_assert(WTF::IsTraceable<T>::value, "T should not be traced");
   static_cast<T*>(self)->trace(visitor);
 }
 
+template <typename T>
+void TraceTrait<T>::markAndTraceWrapper(const WrapperVisitor* visitor,
+                                        const void* t) {
+  const T* traceable = ToWrapperTracingType(t);
+  if (visitor->markWrapperHeader(heapObjectHeader(traceable))) {
+    visitor->markWrappersInAllWorlds(traceable);
+    visitor->dispatchTraceWrappers(traceable);
+  }
+}
+
+template <typename T>
+void TraceTrait<T>::markWrapperNoTracing(const WrapperVisitor* visitor,
+                                         const void* t) {
+  const T* traceable = ToWrapperTracingType(t);
+  DCHECK(!heapObjectHeader(traceable)->isWrapperHeaderMarked());
+  visitor->markWrapperHeader(heapObjectHeader(traceable));
+}
+
+template <typename T>
+void TraceTrait<T>::traceMarkedWrapper(const WrapperVisitor* visitor,
+                                       const void* t) {
+  const T* traceable = ToWrapperTracingType(t);
+  DCHECK(heapObjectHeader(t)->isWrapperHeaderMarked());
+  // The term *mark* is misleading here as we effectively trace through the
+  // API boundary, i.e., tell V8 that an object is alive. Actual marking
+  // will be done in V8.
+  visitor->markWrappersInAllWorlds(traceable);
+  visitor->dispatchTraceWrappers(traceable);
+}
+
+template <typename T>
+HeapObjectHeader* TraceTrait<T>::heapObjectHeader(const void* t) {
+  return HeapObjectHeader::fromPayload(ToWrapperTracingType(t));
+}
+
 template <typename T, typename Traits>
 struct TraceTrait<HeapVectorBacking<T, Traits>> {
   STATIC_ONLY(TraceTrait);
   using Backing = HeapVectorBacking<T, Traits>;
 
   template <typename VisitorDispatcher>
   static void trace(VisitorDispatcher visitor, void* self) {
     static_assert(!WTF::IsWeak<T>::value,
                   "weakness in HeapVectors and HeapDeques are not supported");
     if (WTF::IsTraceableInCollectionTrait<Traits>::value)
@@ skipping 521 matching lines @@
     // since iterating over the hash table backing will find the whole
     // chain.
     visitor->markNoTracing(node);
     return false;
   }
 };
 
 }  // namespace WTF
 
 #endif