Remove HasInlinedTraceMethod<T>.

Source/platform/heap/Visitor.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 51 matching lines @@
 // with the Windows compiler which instantiates even unused variables. This causes problems
 // in header files where we have only forward declarations of classes.
 template<typename T, void (T::*method)(Visitor*)>
 struct TraceMethodDelegate {
     static void trampoline(Visitor* visitor, void* self)
     {
         (reinterpret_cast<T*>(self)->*method)(visitor);
     }
 };
 
-// HasInlinedTraceMethod<T>::value is true for T supporting
-// T::trace(InlinedGlobalMarkingVisitor).
-// The template works by checking if T::HasInlinedTraceMethodMarker type is
-// available using SFINAE. The HasInlinedTraceMethodMarker type is defined
-// by DECLARE_TRACE and DEFINE_INLINE_TRACE helper macros, which are used to
-// define trace methods supporting both inlined/uninlined tracing.
-template <typename T>
-struct HasInlinedTraceMethod {
-private:
-    typedef char YesType;
-    struct NoType {
-        char padding[8];
-    };
-
-    template <typename U> static YesType checkMarker(typename U::HasInlinedTraceMethodMarker*);
-    template <typename U> static NoType checkMarker(...);
-public:
-    static const bool value = sizeof(checkMarker<T>(nullptr)) == sizeof(YesType);
-};
-
 #define DECLARE_TRACE_IMPL(maybevirtual)                                     \
 public:                                                                      \
-    typedef int HasInlinedTraceMethodMarker;                                 \
     maybevirtual void trace(Visitor*);                                       \
     maybevirtual void trace(InlinedGlobalMarkingVisitor);                    \
                                                                              \
 private:                                                                     \
     template <typename VisitorDispatcher> void traceImpl(VisitorDispatcher); \
                                                                              \
 public:
 #define DEFINE_TRACE(T)                                                        \
     void T::trace(Visitor* visitor) { traceImpl(visitor); }                    \
     void T::trace(InlinedGlobalMarkingVisitor visitor) { traceImpl(visitor); } \
     template <typename VisitorDispatcher>                                      \
     ALWAYS_INLINE void T::traceImpl(VisitorDispatcher visitor)
 
 #define DEFINE_INLINE_TRACE_IMPL(maybevirtual)                                           \
-    typedef int HasInlinedTraceMethodMarker;                                             \
     maybevirtual void trace(Visitor* visitor) { traceImpl(visitor); }                    \
     maybevirtual void trace(InlinedGlobalMarkingVisitor visitor) { traceImpl(visitor); } \
     template <typename VisitorDispatcher>                                                \
     inline void traceImpl(VisitorDispatcher visitor)
 
 #define DECLARE_TRACE_AFTER_DISPATCH()                                                    \
 public:                                                                                   \
-    typedef int HasInlinedTraceAfterDispatchMethodMarker;                                 \
     void traceAfterDispatch(Visitor*);                                                    \
     void traceAfterDispatch(InlinedGlobalMarkingVisitor);                                 \
 private:                                                                                  \
     template <typename VisitorDispatcher> void traceAfterDispatchImpl(VisitorDispatcher); \
 public:
 
 #define DEFINE_TRACE_AFTER_DISPATCH(T)                                                                   \
     void T::traceAfterDispatch(Visitor* visitor) { traceAfterDispatchImpl(visitor); }                    \
     void T::traceAfterDispatch(InlinedGlobalMarkingVisitor visitor) { traceAfterDispatchImpl(visitor); } \
     template <typename VisitorDispatcher>                                                                \
     ALWAYS_INLINE void T::traceAfterDispatchImpl(VisitorDispatcher visitor)
 
 #define DEFINE_INLINE_TRACE_AFTER_DISPATCH()                                                          \
-    typedef int HasInlinedTraceAfterDispatchMethodMarker;                                             \
     void traceAfterDispatch(Visitor* visitor) { traceAfterDispatchImpl(visitor); }                    \
     void traceAfterDispatch(InlinedGlobalMarkingVisitor visitor) { traceAfterDispatchImpl(visitor); } \
     template <typename VisitorDispatcher>                                                             \
     inline void traceAfterDispatchImpl(VisitorDispatcher visitor)
 
 #define EMPTY_MACRO_ARGUMENT
 
 #define DECLARE_TRACE() DECLARE_TRACE_IMPL(EMPTY_MACRO_ARGUMENT)
 #define DECLARE_VIRTUAL_TRACE() DECLARE_TRACE_IMPL(virtual)
 #define DEFINE_INLINE_TRACE() DEFINE_INLINE_TRACE_IMPL(EMPTY_MACRO_ARGUMENT)
@@ skipping 275 matching lines @@
     {
         DEFINE_STATIC_LOCAL(String, typenameString, (WTF::extractTypeNameFromFunctionName(WTF::extractNameFunction<T>())));
         return typenameString;
     }
 };
 #endif
 
 } // namespace blink
 
 #endif // Visitor_h