Remove do-nothing trace traits on primitive types

Source/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 465 matching lines @@
         for (typename Deque::const_iterator it = deque.begin(), end = deque.end(); it != end; ++it)
             TraceTrait<T>::trace(visitor, const_cast<T*>(&(*it)));
     }
 };
 
 template<typename T, typename Traits = WTF::VectorTraits<T> >
 class HeapVectorBacking;
 template<typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
 class HeapHashTableBacking;
 
-inline void doNothingTrace(Visitor*, void*) { }
-
-// Non-class types like char don't have an trace method, so we provide a more
-// specialized template instantiation here that will be selected in preference
-// to the default. Most of them do nothing, since the type in question cannot
-// point to other heap allocated objects.
-#define ITERATE_DO_NOTHING_TYPES(f)                                  \
-    f(uint8_t)                                                       \
-    f(void)
-
-#define DECLARE_DO_NOTHING_TRAIT(type)                               \
-    template<>                                                       \
-    class TraceTrait<type> {                                         \
-    public:                                                          \
-        static void checkGCInfo(Visitor*, const void*) { }       \
-        static void mark(Visitor* visitor, const type* p) {          \
-            visitor->mark(p, reinterpret_cast<TraceCallback>(0));    \
-        }                                                            \
-    };                                                               \
-    template<>                                                       \
-    struct FinalizerTrait<type> {                                    \
-        static void finalize(void*) { }                              \
-        static const bool nonTrivialFinalizer = false;               \
-    };                                                               \
-    template<>                                                       \
-    struct HEAP_EXPORT GCInfoTrait<type> {                           \
-        static const GCInfo* get()                                   \
-        {                                                            \
-            return &info;                                            \
-        }                                                            \
-        static const GCInfo info;                                    \
-    };
-
-ITERATE_DO_NOTHING_TYPES(DECLARE_DO_NOTHING_TRAIT)
-
-#undef DECLARE_DO_NOTHING_TRAIT
-
 template<typename T>
 class DefaultTraceTrait<T, false> {
 public:
     static void mark(Visitor* visitor, const T* t)
     {
         // Default mark method of the trait just calls the two-argument mark
         // method on the visitor. The second argument is the static trace method
         // of the trait, which by default calls the instance method
         // trace(Visitor*) on the object.
         visitor->mark(const_cast<T*>(t), &TraceTrait<T>::trace);
@@ skipping 125 matching lines @@
 struct GCInfoTrait {
     static const GCInfo* get()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::get();
     }
 };
 
 }
 
 #endif