Remove WRAPPER_VISITOR_SPECIAL_CLASSES

third_party/WebKit/Source/bindings/core/v8/TraceWrapperReference.md

 # Wrapper Tracing Reference
 
 This document describes wrapper tracing and how its API is supposed to be used.
 
 [TOC]
 
 ## Quickstart guide
 
 Wrapper tracing is used to represent reachability across V8 and Blink. The
 following checklist highlights the modifications needed to make a class
@@ skipping 114 matching lines @@
   Member<NonWrappable> m_nonWrappable;
 };
 
 DEFINE_TRACE_WRAPPERS(SomeDOMObject) {
   visitor->traceWrappers(m_otherWrappable);
 }
 ```
 
 
 Blink and V8 implement *incremental* wrapper tracing, which means that marking
-can be interleaved with JavaSCript or even DOM operations. This poses a
+can be interleaved with JavaScript or even DOM operations. This poses a
 challenge, because already marked objects will not be considered again if they
 are reached through some other path.
 
 For example, consider an object ``A`` that has already been marked and a write
 to a field ``A.x`` setting ``x`` to an unmarked object ``Y``.  Since ``A.x`` is
 the only reference keeping ``Y``, and ``A`` has already been marked, the garbage
 collector will not find ``Y`` and reclaim it.
 
 To overcome this problem we require all writes of interesting objects, i.e.,
 writes to traced fields, to go through a write barrier.  Repeat for simpler
@@ skipping 103 matching lines @@
 ``ScriptWrappable``. For example, consider the object graph
 ``A -> B -> C`` where both ``A`` and ``C`` are ``ScriptWrappable``s that
 need to be traced.
 
 In this case, the same rules as with ``ScriptWrappables`` apply, except for the
 difference that these classes need to inherit from ``TraceWrapperBase``.
 
 ### Memory-footprint critical uses
 
 In the case we cannot afford inheriting from ``TraceWrapperBase``, which will
-add a vtable pointer for tracing wrappers, an entry in a macro
-``WRAPPER_VISITOR_SPECIAL_CASES``
-is required in
-``platform/heap/WrapperVisitor.h``.
+add a vtable pointer for tracing wrappers, use
+``DECLARE_TRACE_WRAPPERS_WITHOUT_BASE`` to declare a traceWrappers method.
 
 ## Explicit write barriers
 
 Sometimes it is necessary to stick with the regular types and issue the write
 barriers explicitly. For example, if memory footprint is really important and
 it's not possible to use ``TraceWrapperMember`` which adds another pointer
 field. In this case, tracing needs to be adjusted to tell the system that all
 barriers will be done manually.
 
 ```c++
 class ManualWrappable : public ScriptWrappable {
  public:
   void setNew(OtherWrappable* newValue) {
     m_otherWrappable = newValue;
     SriptWrappableVisitor::writeBarrier(this, m_otherWrappable);
   }
 
   DECLARE_VIRTUAL_TRACE_WRAPPERS();
  private:
   Member<OtherWrappable>> m_otherWrappable;
 };
 
 DEFINE_TRACE_WRAPPERS(ManualWrappable) {
   for (auto other : m_otherWrappables)
     visitor->traceWrappersWithManualWriteBarrier(other);
 }
 ```