Oilpan: Remove OffHeapCollectionTrait

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 249 matching lines @@
     static const bool value = TraceEagerlyTrait<T>::value;
 };
 
 template<typename ValueArg, size_t inlineCapacity> class HeapListHashSetAllocator;
 template<typename T, size_t inlineCapacity>
 class TraceEagerlyTrait<WTF::ListHashSetNode<T, HeapListHashSetAllocator<T, inlineCapacity>>> {
 public:
     static const bool value = false;
 };
 
-template<typename Collection>
-struct OffHeapCollectionTraceTrait;
-
 template<typename T, bool = NeedsAdjustAndMark<T>::value> class ObjectAliveTrait;
 
 template<typename T>
 class ObjectAliveTrait<T, false> {
 public:
     template<typename VisitorDispatcher>
     static bool isHeapObjectAlive(VisitorDispatcher visitor, T* obj)
     {
         return visitor->isMarked(obj);
     }
@@ skipping 91 matching lines @@
         // Check that we actually know the definition of T when tracing.
         static_assert(sizeof(T), "T must be fully defined");
         if (WTF::IsPolymorphic<T>::value) {
             intptr_t vtable = *reinterpret_cast<const intptr_t*>(&t);
             if (!vtable)
                 return;
         }
         TraceTrait<T>::trace(Derived::fromHelper(this), &const_cast<T&>(t));
     }
 
-    // The following trace methods are for off-heap collections.
-    template<typename T, size_t inlineCapacity>
-    void trace(const Vector<T, inlineCapacity>& vector)
-    {
-        OffHeapCollectionTraceTrait<Vector<T, inlineCapacity, WTF::DefaultAllocator>>::trace(Derived::fromHelper(this), vector);
-    }
-
-    template<typename T, size_t N>
-    void trace(const Deque<T, N>& deque)
-    {
-        OffHeapCollectionTraceTrait<Deque<T, N>>::trace(Derived::fromHelper(this), deque);
-    }
-
 #if !ENABLE(OILPAN)
     // These trace methods are needed to allow compiling and calling trace on
     // transition types. We need to support calls in the non-oilpan build
     // because a fully transitioned type (which will have its trace method
     // called) might trace a field that is in transition. Once transition types
     // are removed these can be removed.
     template<typename T> void trace(const OwnPtr<T>&) { }
     template<typename T> void trace(const RefPtr<T>&) { }
     template<typename T> void trace(const RawPtr<T>&) { }
     template<typename T> void trace(const WeakPtr<T>&) { }
@@ skipping 199 matching lines @@
 
 template <typename Derived>
 template <typename T>
 void VisitorHelper<Derived>::handleWeakCell(Visitor* self, void* obj)
 {
     T** cell = reinterpret_cast<T**>(obj);
     if (*cell && !self->isHeapObjectAlive(*cell))
         *cell = nullptr;
 }
 
-// We trace vectors by using the trace trait on each element, which means you
-// can have vectors of general objects (not just pointers to objects) that can
-// be traced.
-template<typename T, size_t N>
-struct OffHeapCollectionTraceTrait<WTF::Vector<T, N, WTF::DefaultAllocator>> {
-    typedef WTF::Vector<T, N, WTF::DefaultAllocator> Vector;
-
-    template<typename VisitorDispatcher>
-    static void trace(VisitorDispatcher visitor, const Vector& vector)
-    {
-        if (vector.isEmpty())
-            return;
-        for (typename Vector::const_iterator it = vector.begin(), end = vector.end(); it != end; ++it)
-            TraceTrait<T>::trace(visitor, const_cast<T*>(it));
-    }
-};
-
-template<typename T, size_t N>
-struct OffHeapCollectionTraceTrait<WTF::Deque<T, N>> {
-    typedef WTF::Deque<T, N> Deque;
-
-    template<typename VisitorDispatcher>
-    static void trace(VisitorDispatcher visitor, const Deque& deque)
-    {
-        if (deque.isEmpty())
-            return;
-        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> struct GCInfoTrait;
 
 template<typename T>
 class DefaultTraceTrait<T, false> {
 public:
     template<typename VisitorDispatcher>
     static void mark(VisitorDispatcher 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
@@ skipping 66 matching lines @@
     {
         DEFINE_STATIC_LOCAL(String, typenameString, (WTF::extractTypeNameFromFunctionName(WTF::extractNameFunction<T>())));
         return typenameString;
     }
 };
 #endif
 
 } // namespace blink
 
 #endif // Visitor_h