More switching to standard type traits

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"
@@ skipping 367 matching lines @@
         //   traces only slots that are not zeroed out. This is because if
         //   the object has a vtable, the zeroed slot means that it is
         //   an unused slot (Remember that the unused slots are guaranteed
         //   to be zeroed out by VectorUnusedSlotClearer).
         //
         // - An object that can be initialized with memset. In this case,
         //   HeapVectorBacking traces all slots including unused slots.
         //   This is fine because the fact that the object can be initialized
         //   with memset indicates that it is safe to treat the zerod slot
         //   as a valid object.
-        static_assert(!NeedsTracingTrait<Traits>::value || Traits::canClearUnusedSlotsWithMemset || WTF::IsPolymorphic<T>::value, "HeapVectorBacking doesn't support objects that cannot be cleared as unused with memset.");
+        static_assert(!NeedsTracingTrait<Traits>::value || Traits::canClearUnusedSlotsWithMemset || std::is_polymorphic<T>::value, "HeapVectorBacking doesn't support objects that cannot be cleared as unused with memset.");
 
         // This trace method is instantiated for vectors where
         // NeedsTracingTrait<Traits>::value is false, but the trace method
         // should not be called. Thus we cannot static-assert
         // NeedsTracingTrait<Traits>::value but should runtime-assert it.
         ASSERT(NeedsTracingTrait<Traits>::value);
 
         T* array = reinterpret_cast<T*>(self);
         blink::HeapObjectHeader* header = blink::HeapObjectHeader::fromPayload(self);
         ASSERT(header->checkHeader());
         // Use the payload size as recorded by the heap to determine how many
         // elements to trace.
         size_t length = header->payloadSize() / sizeof(T);
-        if (WTF::IsPolymorphic<T>::value) {
+        if (std::is_polymorphic<T>::value) {
             for (size_t i = 0; i < length; ++i) {
                 if (blink::vTableInitialized(&array[i]))
                     blink::TraceIfEnabled<T, NeedsTracingTrait<Traits>::value>::trace(visitor, array[i]);
             }
         } else {
 #ifdef ANNOTATE_CONTIGUOUS_CONTAINER
             // As commented above, HeapVectorBacking can trace unused slots
             // (which are already zeroed out).
             ANNOTATE_CHANGE_SIZE(array, length, 0, length);
 #endif
@@ skipping 154 matching lines @@
         // since iterating over the hash table backing will find the whole
         // chain.
         visitor->markNoTracing(node);
         return false;
     }
 };
 
 } // namespace WTF
 
 #endif