Remove WRAPPER_VISITOR_SPECIAL_CLASSES

third_party/WebKit/Source/platform/heap/WrapperVisitor.h

 // Copyright 2016 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 WrapperVisitor_h
 #define WrapperVisitor_h
 
 #include "platform/PlatformExport.h"
 #include "wtf/Allocator.h"
 
 namespace v8 {
 class Value;
 template <class T>
 class PersistentBase;
 }
 
 namespace blink {
 
 template <typename T>
 class TraceTrait;
 template <typename T>
 class Member;
 class ScriptWrappable;
 template <typename T>
 class TraceWrapperV8Reference;
 class TraceWrapperBase;
 template <typename T>
 class TraceWrapperMember;
 
-// Only add a special class here if the class cannot derive from
-// TraceWrapperBase.
-#define WRAPPER_VISITOR_SPECIAL_CLASSES(V) \
-  V(ElementRareData)                       \
-  V(NodeListsNodeData)                     \
-  V(NodeMutationObserverData)              \
-  V(NodeRareData)
-
-#define FORWARD_DECLARE_SPECIAL_CLASSES(className) class className;
-
-WRAPPER_VISITOR_SPECIAL_CLASSES(FORWARD_DECLARE_SPECIAL_CLASSES);
-
-#undef FORWARD_DECLARE_SPECIAL_CLASSES
-
 /**
  * Declares non-virtual traceWrappers method. Should be used on
  * non-ScriptWrappable classes which should participate in wrapper tracing (e.g.
  * NodeRareData):
  *
  *     class NodeRareData {
  *     public:
  *         DECLARE_TRACE_WRAPPERS();
  *     }
  */
@@ skipping 89 matching lines @@
   template <typename T>
   void traceWrappersWithManualWriteBarrier(const T* traceable) const {
     traceWrappers(traceable);
   }
 
   virtual void traceWrappers(
       const TraceWrapperV8Reference<v8::Value>&) const = 0;
   virtual void markWrapper(const v8::PersistentBase<v8::Value>*) const = 0;
 
   virtual void dispatchTraceWrappers(const TraceWrapperBase*) const = 0;
-#define DECLARE_DISPATCH_TRACE_WRAPPERS(ClassName) \
-  virtual void dispatchTraceWrappers(const ClassName*) const = 0;
-
-  WRAPPER_VISITOR_SPECIAL_CLASSES(DECLARE_DISPATCH_TRACE_WRAPPERS);
-
-#undef DECLARE_DISPATCH_TRACE_WRAPPERS
 
   virtual bool markWrapperHeader(HeapObjectHeader*) const = 0;
 
   virtual void markWrappersInAllWorlds(const ScriptWrappable*) const = 0;
 
-  void markWrappersInAllWorlds(const void*) const {
-    // Empty handler used for WRAPPER_VISITOR_SPECIAL_CLASSES. These types
-    // don't require marking wrappers in all worlds, so just nop on those.
-  }
-
   template <typename T>
   ALWAYS_INLINE void markAndPushToMarkingDeque(const T* traceable) const {
     if (pushToMarkingDeque(TraceTrait<T>::traceMarkedWrapper,
                            TraceTrait<T>::heapObjectHeader,
                            WrapperVisitor::missedWriteBarrier<T>, traceable)) {
       TraceTrait<T>::markWrapperNoTracing(this, traceable);
     }
   }
 
  protected:
   // Returns true if pushing to the marking deque was successful.
   virtual bool pushToMarkingDeque(
       void (*traceWrappersCallback)(const WrapperVisitor*, const void*),
       HeapObjectHeader* (*heapObjectHeaderCallback)(const void*),
       void (*missedWriteBarrierCallback)(void),
       const void*) const = 0;
 };
 
-#define SPECIALIZE_WRAPPER_TRACING_MARK_TRAIT(ClassName) \
-  template <>                                            \
-  class CanTraceWrappers<ClassName, false> {             \
-   public:                                               \
-    static const bool value = true;                      \
-  };
-
-WRAPPER_VISITOR_SPECIAL_CLASSES(SPECIALIZE_WRAPPER_TRACING_MARK_TRAIT)
-
-#undef SPECIALIZE_WRAPPER_TRACING_MARK_TRAIT
-
 }  // namespace blink
 
 #endif  // WrapperVisitor_h