Devirtualize Visitor and remove inline visitor specialization.

third_party/WebKit/Source/platform/heap/GarbageCollected.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 GarbageCollected_h
 #define GarbageCollected_h
 
 #include "platform/heap/ThreadState.h"
 #include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/TypeTraits.h"
 
 namespace blink {
 
 template <typename T>
 class GarbageCollected;
-class InlinedGlobalMarkingVisitor;
 class TraceWrapperBase;
 
 // GC_PLUGIN_IGNORE is used to make the plugin ignore a particular class or
 // field when checking for proper usage.  When using GC_PLUGIN_IGNORE
 // a bug-number should be provided as an argument where the bug describes
 // what needs to happen to remove the GC_PLUGIN_IGNORE again.
 #if COMPILER(CLANG)
 #define GC_PLUGIN_IGNORE(bug) \
   __attribute__((annotate("blink_gc_plugin_ignore")))
 #else
@@ skipping 38 matching lines @@
 // With the helper, as long as we are using Member<B>, TypeTrait<B> will
 // dispatch adjustAndMark dynamically to find collect addr of the object header.
 // Note that this is only enabled for Member<B>. For Member<A> which we can
 // compute the object header addr statically, this dynamic dispatch is not used.
 //
 class PLATFORM_EXPORT GarbageCollectedMixin {
  public:
   typedef int IsGarbageCollectedMixinMarker;
   virtual void adjustAndMark(Visitor*) const = 0;
   virtual void trace(Visitor*) {}
-  virtual void adjustAndMark(InlinedGlobalMarkingVisitor) const = 0;
-  virtual void trace(InlinedGlobalMarkingVisitor);
   virtual bool isHeapObjectAlive() const = 0;
 };
 
 #define DEFINE_GARBAGE_COLLECTED_MIXIN_METHODS(VISITOR, TYPE)                 \
  public:                                                                      \
   void adjustAndMark(VISITOR visitor) const override {                        \
     typedef WTF::IsSubclassOfTemplate<typename std::remove_const<TYPE>::type, \
                                       blink::GarbageCollected>                \
         IsSubclassOfGarbageCollected;                                         \
     static_assert(                                                            \
@@ skipping 60 matching lines @@
 // upon construction, two GarbageCollectedMixinConstructorMarker constructors
 // will run -- one for A (first) and another for B (secondly). Only
 // the second one should leave the forbidden GC scope. This is realized by
 // recording the address of B's GarbageCollectedMixinConstructorMarker
 // when the "operator new" for B runs, and leaving the forbidden GC scope
 // when the constructor of the recorded GarbageCollectedMixinConstructorMarker
 // runs.
 #define USING_GARBAGE_COLLECTED_MIXIN(TYPE)                                  \
   IS_GARBAGE_COLLECTED_TYPE();                                               \
   DEFINE_GARBAGE_COLLECTED_MIXIN_METHODS(blink::Visitor*, TYPE)              \
-  DEFINE_GARBAGE_COLLECTED_MIXIN_METHODS(blink::InlinedGlobalMarkingVisitor, \
-                                         TYPE)                               \
   DEFINE_GARBAGE_COLLECTED_MIXIN_CONSTRUCTOR_MARKER(TYPE)                    \
  public:                                                                     \
   bool isHeapObjectAlive() const override {                                  \
     return ThreadHeap::isHeapObjectAlive(this);                              \
   }                                                                          \
                                                                              \
  private:
 
 // An empty class with a constructor that's arranged invoked when all derived
 // constructors of a mixin instance have completed and it is safe to allow GCs
@@ skipping 116 matching lines @@
   static FalseType isSizeofKnown(...);
   static T& t;
 
  public:
   static const bool value = sizeof(TrueType) == sizeof(isSizeofKnown(&t));
 };
 
 }  // namespace blink
 
 #endif