Oilpan: Rename DefaultTraceTrait to AdjustAndMarkTrait

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 11 matching lines @@
 
 namespace blink {
 
 template<typename T> class CrossThreadPersistent;
 template<typename T> struct GCInfoTrait;
 class HeapObjectHeader;
 template<typename T> class Member;
 template<typename T> class TraceTrait;
 template<typename T> class WeakMember;
 
-template<typename T, bool = NeedsAdjustAndMark<T>::value> class DefaultTraceTrait;
+template<typename T, bool = NeedsAdjustAndMark<T>::value> class AdjustAndMarkTrait;
 
 template<typename T>
-class DefaultTraceTrait<T, false> {
+class AdjustAndMarkTrait<T, false> {
 public:
     template<typename VisitorDispatcher>
     static void mark(VisitorDispatcher visitor, const T* t)
     {
 #if ENABLE(ASSERT)
         assertObjectHasGCInfo(const_cast<T*>(t), GCInfoTrait<T>::index());
 #endif
         // 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
@@ skipping 20 matching lines @@
                     TraceTrait<T>::trace(visitor, const_cast<T*>(t));
                 }
                 return;
             }
         }
         visitor->mark(const_cast<T*>(t), &TraceTrait<T>::trace);
     }
 };
 
 template<typename T>
-class DefaultTraceTrait<T, true> {
+class AdjustAndMarkTrait<T, true> {
 public:
     template<typename VisitorDispatcher>
     static void mark(VisitorDispatcher visitor, const T* self)
     {
         if (!self)
             return;
 
         // If you hit this ASSERT, it means that there is a dangling pointer
         // from a live thread heap to a dead thread heap. We must eliminate
         // the dangling pointer.
@@ skipping 54 matching lines @@
 // that case the pointer has to be adjusted before marking.
 template<typename T>
 class TraceTrait {
 public:
     static void trace(Visitor*, void* self);
     static void trace(InlinedGlobalMarkingVisitor, void* self);
 
     template<typename VisitorDispatcher>
     static void mark(VisitorDispatcher visitor, const T* t)
     {
-        DefaultTraceTrait<T>::mark(visitor, t);
+        AdjustAndMarkTrait<T>::mark(visitor, t);
     }
 };
 
 template<typename T> class TraceTrait<const T> : public TraceTrait<T> { };
 
 template<typename T>
 void TraceTrait<T>::trace(Visitor* visitor, void* self)
 {
     if (visitor->isGlobalMarkingVisitor()) {
         // Switch to inlined global marking dispatch.
@@ skipping 17 matching lines @@
     static void trace(VisitorDispatcher visitor, void* self)
     {
         static_assert(!WTF::IsWeak<T>::value, "weakness in HeapVectors and Deques are not supported");
         if (WTF::ShouldBeTraced<Traits>::value)
             WTF::TraceInCollectionTrait<WTF::NoWeakHandlingInCollections, WTF::WeakPointersActWeak, HeapVectorBacking<T, Traits>, void>::trace(visitor, self);
     }
 
     template<typename VisitorDispatcher>
     static void mark(VisitorDispatcher visitor, const Backing* backing)
     {
-        DefaultTraceTrait<Backing>::mark(visitor, backing);
+        AdjustAndMarkTrait<Backing>::mark(visitor, backing);
     }
 };
 
 // The trace trait for the heap hashtable backing is used when we find a
 // direct pointer to the backing from the conservative stack scanner.  This
 // normally indicates that there is an ongoing iteration over the table, and so
 // we disable weak processing of table entries.  When the backing is found
 // through the owning hash table we mark differently, in order to do weak
 // processing.
 template<typename Table>
 struct TraceTrait<HeapHashTableBacking<Table>> {
     using Backing = HeapHashTableBacking<Table>;
     using Traits = typename Table::ValueTraits;
 
     template<typename VisitorDispatcher>
     static void trace(VisitorDispatcher visitor, void* self)
     {
         if (WTF::ShouldBeTraced<Traits>::value || Traits::weakHandlingFlag == WTF::WeakHandlingInCollections)
             WTF::TraceInCollectionTrait<WTF::NoWeakHandlingInCollections, WTF::WeakPointersActStrong, Backing, void>::trace(visitor, self);
     }
 
     template<typename VisitorDispatcher>
     static void mark(VisitorDispatcher visitor, const Backing* backing)
     {
-        DefaultTraceTrait<Backing>::mark(visitor, backing);
+        AdjustAndMarkTrait<Backing>::mark(visitor, backing);
     }
 };
 
 // This trace trait for std::pair will null weak members if their referent is
 // collected. If you have a collection that contain weakness it does not remove
 // entries from the collection that contain nulled weak members.
 template<typename T, typename U>
 class TraceTrait<std::pair<T, U>> {
 public:
     static const bool firstNeedsTracing = WTF::NeedsTracing<T>::value || WTF::IsWeak<T>::value;
@@ skipping 316 matching lines @@
         // since iterating over the hash table backing will find the whole
         // chain.
         visitor->markNoTracing(node);
         return false;
     }
 };
 
 } // namespace WTF
 
 #endif