[wrapper-tracing] Redesign dispatching on non-inheriting cases

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/StackFrameDepth.h"
@@ skipping 186 matching lines @@
   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>
@@ skipping 14 matching lines @@
 }
 
 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.
-  traceable->markAndDispatchTraceWrappers(visitor);
+  visitor->dispatchTraceWrappers(traceable);
+  visitor->markWrappersInAllWorlds(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);
@@ skipping 528 matching lines @@
     // since iterating over the hash table backing will find the whole
     // chain.
     visitor->markNoTracing(node);
     return false;
   }
 };
 
 }  // namespace WTF
 
 #endif