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):
+ * StyleEngine):
  *
- *     class NodeRareData {
+ *     class StyleEngine: public TraceWrapperBase {
  *     public:
  *         DECLARE_TRACE_WRAPPERS();
  *     }
  */
 #define DECLARE_TRACE_WRAPPERS() \
   void traceWrappers(const WrapperVisitor* visitor) const
 
 /**
+ * Declares markAndDispatchTraceWrappers and non-virtual traceWrappers methods.
+ * Use this on non-TraceWrapperBase classes that participate in wrapper tracing
+ * (e.g. NodeRareData):
+ *
+ *    class NodeRareData {
+ *    public:

[jbroman, 2017/03/07 17:46:10]

nit: here (and above): "public:" should be indented 1 space, following lines 2
spaces and there should be a semicolon at the end of the class. Might as well
fix both to be consistent.

[adithyas, 2017/03/07 18:40:46]

Fixed both.

+ *      DECLARE_TRACE_WRAPPERS_WITHOUT_BASE();
+ *    }
+ */
+#define DECLARE_TRACE_WRAPPERS_WITHOUT_BASE()                              \
+  void markAndDispatchTraceWrappers(const WrapperVisitor* visitor) const { \
+    traceWrappers(visitor);                                                \
+  }                                                                        \
+  DECLARE_TRACE_WRAPPERS()
+
+/**
  * Declares virtual traceWrappers method. It is used in ScriptWrappable, can be
  * used to override the method in the subclasses, and can be used by
  * non-ScriptWrappable classes which expect to be inherited.
  */
 #define DECLARE_VIRTUAL_TRACE_WRAPPERS() virtual DECLARE_TRACE_WRAPPERS()
 
 /**
  * Provides definition of traceWrappers method. Custom code will usually call
  * visitor->traceWrappers with all objects which could contribute to the set of
  * reachable wrappers:
@@ skipping 75 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