Deque: Add HeapDeque and prevent buggy use of swap and operator=

Source/platform/heap/Heap.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 1395 matching lines @@
     }
 
     template<typename U, size_t otherCapacity>
     void appendVector(const HeapVector<U, otherCapacity>& other)
     {
         const Vector<U, otherCapacity, HeapAllocator>& otherVector = other;
         Vector<T, inlineCapacity, HeapAllocator>::appendVector(otherVector);
     }
 };
 
+template<typename T, size_t inlineCapacity = 0>
+class HeapDeque : public Deque<T, inlineCapacity, HeapAllocator> {
+public:
+    HeapDeque() { }
+
+    explicit HeapDeque(size_t size) : Deque<T, inlineCapacity, HeapAllocator>(size)
+    {
+    }
+
+    HeapDeque(size_t size, const T& val) : Deque<T, inlineCapacity, HeapAllocator>(size, val)
+    {
+    }
+
+    // FIXME: Doesn't work if there is an inline buffer, due to crbug.com/360572
+    HeapDeque<T, 0>& operator=(const HeapDeque& other)
+    {
+        HeapDeque<T> copy(other);
+        swap(copy);
+        return *this;
+    }
+
+    // FIXME: Doesn't work if there is an inline buffer, due to crbug.com/360572
+    inline void swap(HeapDeque& other)
+    {
+        Deque<T, inlineCapacity, HeapAllocator>::swap(other);
+    }
+
+    template<size_t otherCapacity>
+    HeapDeque(const HeapDeque<T, otherCapacity>& other)
+        : Deque<T, inlineCapacity, HeapAllocator>(other)
+    {
+    }
+
+    template<typename U>
+    void append(const U& other)
+    {
+        Deque<T, inlineCapacity, HeapAllocator>::append(other);
+    }
+};
+
 template<typename T>
 struct ThreadingTrait<Member<T> > {
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
 template<typename T>
 struct ThreadingTrait<WeakMember<T> > {
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
@@ skipping 20 matching lines @@
 template<typename T, size_t inlineCapacity>
 struct ThreadingTrait<Vector<T, inlineCapacity, HeapAllocator> > {
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
 template<typename T, typename Traits>
 struct ThreadingTrait<HeapVectorBacking<T, Traits> > {
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
+template<typename T, size_t inlineCapacity>
+struct ThreadingTrait<Deque<T, inlineCapacity, HeapAllocator> > {
+    static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
+};
+
 template<typename Table>
 struct ThreadingTrait<HeapHashTableBacking<Table> > {
     typedef typename Table::KeyType Key;
     typedef typename Table::ValueType Value;
     static const ThreadAffinity Affinity =
         (ThreadingTrait<Key>::Affinity == MainThreadOnly)
         && (ThreadingTrait<Value>::Affinity == MainThreadOnly) ? MainThreadOnly : AnyThread;
 };
 
 template<typename T, typename U, typename V, typename W, typename X>
 struct ThreadingTrait<HeapHashMap<T, U, V, W, X> > : public ThreadingTrait<HashMap<T, U, V, W, X, HeapAllocator> > { };
 
 template<typename T, typename U, typename V>
 struct ThreadingTrait<HeapHashSet<T, U, V> > : public ThreadingTrait<HashSet<T, U, V, HeapAllocator> > { };
 
 template<typename T, size_t inlineCapacity>
 struct ThreadingTrait<HeapVector<T, inlineCapacity> > : public ThreadingTrait<Vector<T, inlineCapacity, HeapAllocator> > { };
 
+template<typename T, size_t inlineCapacity>
+struct ThreadingTrait<HeapDeque<T, inlineCapacity> > : public ThreadingTrait<Deque<T, inlineCapacity, HeapAllocator> > { };
+
 // The standard implementation of GCInfoTrait<T>::get() just returns a static
-// from the class T, but we can't do that for HashMap, HashSet and Vector
-// because they are in WTF and know nothing of GCInfos. Instead we have a
-// specialization of GCInfoTrait for these three classes here.
+// from the class T, but we can't do that for HashMap, HashSet, Deque and
+// Vector because they are in WTF and know nothing of GCInfos. Instead we have
+// a specialization of GCInfoTrait for these four classes here.
 
 template<typename Key, typename Value, typename T, typename U, typename V>
 struct GCInfoTrait<HashMap<Key, Value, T, U, V, HeapAllocator> > {
     static const GCInfo* get() { return &info; }
     static const GCInfo info;
 };
 
 template<typename Key, typename Value, typename T, typename U, typename V>
 const GCInfo GCInfoTrait<HashMap<Key, Value, T, U, V, HeapAllocator> >::info = {
     TraceTrait<HashMap<Key, Value, T, U, V, HeapAllocator> >::trace,
@@ skipping 37 matching lines @@
 struct FinalizerTrait<Vector<T, inlineCapacity, HeapAllocator> > : public FinalizerTraitImpl<Vector<T, inlineCapacity, HeapAllocator>, true> { };
 
 template<typename T, size_t inlineCapacity>
 const GCInfo GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator> >::info = {
     TraceTrait<Vector<T, inlineCapacity, HeapAllocator> >::trace,
     FinalizerTrait<Vector<T, inlineCapacity, HeapAllocator> >::finalize,
     // Finalizer is needed to destruct things stored in the inline capacity.
     inlineCapacity && VectorTraits<T>::needsDestruction,
 };
 
+template<typename T>
+struct GCInfoTrait<Deque<T, 0, HeapAllocator> > {
+    static const GCInfo* get() { return &info; }
+    static const GCInfo info;
+};
+
+template<typename T>
+const GCInfo GCInfoTrait<Deque<T, 0, HeapAllocator> >::info = {
+    TraceTrait<Deque<T, 0, HeapAllocator> >::trace,
+    0,
+    false, // Deque needs no finalizer if it has no inline capacity.
+};
+
+template<typename T, size_t inlineCapacity>
+struct GCInfoTrait<Deque<T, inlineCapacity, HeapAllocator> > {
+    static const GCInfo* get() { return &info; }
+    static const GCInfo info;
+};
+
+template<typename T, size_t inlineCapacity>
+struct FinalizerTrait<Deque<T, inlineCapacity, HeapAllocator> > : public FinalizerTraitImpl<Deque<T, inlineCapacity, HeapAllocator>, true> { };
+
+template<typename T, size_t inlineCapacity>
+const GCInfo GCInfoTrait<Deque<T, inlineCapacity, HeapAllocator> >::info = {
+    TraceTrait<Deque<T, inlineCapacity, HeapAllocator> >::trace,
+    FinalizerTrait<Deque<T, inlineCapacity, HeapAllocator> >::finalize,
+    // Finalizer is needed to destruct things stored in the inline capacity.
+    inlineCapacity && VectorTraits<T>::needsDestruction,
+};
+
 template<typename T, typename Traits>
 struct GCInfoTrait<HeapVectorBacking<T, Traits> > {
     static const GCInfo* get() { return &info; }
     static const GCInfo info;
 };
 
 template<typename T, typename Traits>
 const GCInfo GCInfoTrait<HeapVectorBacking<T, Traits> >::info = {
     TraceTrait<HeapVectorBacking<T, Traits> >::trace,
     FinalizerTrait<HeapVectorBacking<T, Traits> >::finalize,
@@ skipping 142 matching lines @@
     {
         TraceTrait<T>::trace(visitor, &t);
     }
 };
 
 template<typename T, typename Traits>
 struct TraceTrait<HeapVectorBacking<T, Traits> > {
     typedef HeapVectorBacking<T, Traits> Backing;
     static void trace(WebCore::Visitor* visitor, void* self)
     {
-        COMPILE_ASSERT(!Traits::isWeak, WeDontSupportWeaknessInHeapVectors);
+        COMPILE_ASSERT(!Traits::isWeak, WeDontSupportWeaknessInHeapVectorsOrDeques);
         if (WTF::ShouldBeTraced<Traits>::value)
             CollectionBackingTraceTrait<WTF::ShouldBeTraced<Traits>::value, false, false, HeapVectorBacking<T, Traits>, void>::mark(visitor, self);
     }
     static void mark(Visitor* visitor, const Backing* backing)
     {
         visitor->mark(backing, &trace);
     }
     static void checkGCInfo(Visitor* visitor, const Backing* backing)
     {
 #ifndef NDEBUG
@@ skipping 47 matching lines @@
             table[i].~Value();
     }
 }
 
 template<typename T, typename U, typename V, typename W, typename X>
 struct GCInfoTrait<HeapHashMap<T, U, V, W, X> > : public GCInfoTrait<HashMap<T, U, V, W, X, HeapAllocator> > { };
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HeapHashSet<T, U, V> > : public GCInfoTrait<HashSet<T, U, V, HeapAllocator> > { };
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapVector<T, inlineCapacity> > : public GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator> > { };
+template<typename T, size_t inlineCapacity>
+struct GCInfoTrait<HeapDeque<T, inlineCapacity> > : public GCInfoTrait<Deque<T, inlineCapacity, HeapAllocator> > { };
 
 template<typename T>
 struct IfWeakMember;
 
 template<typename T>
 struct IfWeakMember {
     template<typename U>
     static bool isDead(Visitor*, const U&) { return false; }
 };
 
 template<typename T>
 struct IfWeakMember<WeakMember<T> > {
     static bool isDead(Visitor* visitor, const WeakMember<T>& t) { return !visitor->isAlive(t.get()); }
 };
 
 #if COMPILER(CLANG)
 // Clang does not export the symbols that we have explicitly asked it
 // to export. This forces it to export all the methods from ThreadHeap.
 template<> void ThreadHeap<FinalizedHeapObjectHeader>::addPageToHeap(const GCInfo*);
 template<> void ThreadHeap<HeapObjectHeader>::addPageToHeap(const GCInfo*);
 extern template class PLATFORM_EXPORT ThreadHeap<FinalizedHeapObjectHeader>;
 extern template class PLATFORM_EXPORT ThreadHeap<HeapObjectHeader>;
 #endif
 
 }
 
 #endif // Heap_h