[wrapper-tracing] Simplify tracing and reduce technical debt

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 170 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*, 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:
@@ skipping 25 matching lines @@
   }
 }
 
 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) {
@@ skipping 545 matching lines @@
     // since iterating over the hash table backing will find the whole
     // chain.
     visitor->markNoTracing(node);
     return false;
   }
 };
 
 }  // namespace WTF
 
 #endif