Devirtualize Visitor and remove inline visitor specialization.

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"
 #include "platform/heap/StackFrameDepth.h"
 #include "platform/heap/Visitor.h"
 #include "platform/heap/WrapperVisitor.h"
 #include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/HashCountedSet.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/HashTable.h"
 #include "wtf/LinkedHashSet.h"
@@ skipping 174 matching lines @@
 // implementation. A common case where a TraceTrait specialization is
 // needed is when multiple inheritance leads to pointers that are not
 // 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 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);
   }
 
@@ skipping 10 matching lines @@
     return reinterpret_cast<const T*>(t);
   }
 };
 
 template <typename T>
 class TraceTrait<const T> : public TraceTrait<T> {};
 
 template <typename T>
 void TraceTrait<T>::trace(Visitor* visitor, void* self) {
   static_assert(WTF::IsTraceable<T>::value, "T should not be traced");
-  if (visitor->isGlobalMarking()) {
-    // Switch to inlined global marking dispatch.
-    static_cast<T*>(self)->trace(InlinedGlobalMarkingVisitor(
-        visitor->state(), visitor->getMarkingMode()));
-  } else {
-    static_cast<T*>(self)->trace(visitor);
-  }
-}
-
-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>::markWrapperNoTracing(const WrapperVisitor* visitor,
                                          const void* t) {
   const T* traceable = ToWrapperTracingType(t);
   DCHECK(!heapObjectHeader(traceable)->isWrapperHeaderMarked());
   visitor->markWrapperHeader(heapObjectHeader(traceable));
 }
@@ skipping 549 matching lines @@
     // since iterating over the hash table backing will find the whole
     // chain.
     visitor->markNoTracing(node);
     return false;
   }
 };
 
 }  // namespace WTF
 
 #endif