WTF: Implement move of Deques.

third_party/WebKit/Source/wtf/Deque.h

 /*
  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 34 matching lines @@
 template <typename T, size_t inlineCapacity = 0, typename Allocator = PartitionAllocator>
 class Deque : public ConditionalDestructor<Deque<T, INLINE_CAPACITY, Allocator>, (INLINE_CAPACITY == 0) && Allocator::isGarbageCollected> {
     WTF_USE_ALLOCATOR(Deque, Allocator);
 public:
     typedef DequeIterator<T, inlineCapacity, Allocator> iterator;
     typedef DequeConstIterator<T, inlineCapacity, Allocator> const_iterator;
     typedef std::reverse_iterator<iterator> reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
     Deque();
-    Deque(const Deque<T, inlineCapacity, Allocator>&);
+    Deque(const Deque&);
     Deque& operator=(const Deque&);
+    Deque(Deque&&);
+    Deque& operator=(Deque&&);
 
     void finalize();
     void finalizeGarbageCollectedObject() { finalize(); }
 
-    void swap(Deque<T, inlineCapacity, Allocator>&);
+    void swap(Deque&);
 
     size_t size() const { return m_start <= m_end ? m_end - m_start : m_end + m_buffer.capacity() - m_start; }
     bool isEmpty() const { return m_start == m_end; }
 
     iterator begin() { return iterator(this, m_start); }
     iterator end() { return iterator(this, m_end); }
     const_iterator begin() const { return const_iterator(this, m_start); }
     const_iterator end() const { return const_iterator(this, m_end); }
     reverse_iterator rbegin() { return reverse_iterator(end()); }
     reverse_iterator rend() { return reverse_iterator(begin()); }
@@ skipping 31 matching lines @@
     void remove(iterator&);
     void remove(const_iterator&);
 
     void clear();
 
     template <typename Predicate>
     iterator findIf(Predicate&);
 
     template <typename VisitorDispatcher> void trace(VisitorDispatcher);
 
+    static_assert(!std::is_polymorphic<T>::value || !VectorTraits<T>::canInitializeWithMemset, "Cannot initialize with memset if there is a vtable");
+#if ENABLE(OILPAN)
+    static_assert(Allocator::isGarbageCollected || !AllowsOnlyPlacementNew<T>::value || !NeedsTracing<T>::value, "Cannot put DISALLOW_NEW_EXCEPT_PLACEMENT_NEW objects that have trace methods into an off-heap Deque");
+#endif
+    static_assert(Allocator::isGarbageCollected || !IsPointerToGarbageCollectedType<T>::value, "Cannot put raw pointers to garbage-collected classes into a Deque. Use HeapDeque<Member<T>> instead.");
+
 private:
     friend class DequeIteratorBase<T, inlineCapacity, Allocator>;
 
     class Buffer : public VectorBuffer<T, INLINE_CAPACITY, Allocator> {
         WTF_MAKE_NONCOPYABLE(Buffer);
     private:
         using Base = VectorBuffer<T, INLINE_CAPACITY, Allocator>;
         using Base::m_size;
 
     public:
@@ skipping 107 matching lines @@
     // postfix ++ intentionally omitted
     Iterator& operator--() { Base::decrement(); return *this; }
     // postfix -- intentionally omitted
 };
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline Deque<T, inlineCapacity, Allocator>::Deque()
     : m_start(0)
     , m_end(0)
 {
-    static_assert(!std::is_polymorphic<T>::value || !VectorTraits<T>::canInitializeWithMemset, "Cannot initialize with memset if there is a vtable");
-#if ENABLE(OILPAN)
-    static_assert(Allocator::isGarbageCollected || !AllowsOnlyPlacementNew<T>::value || !NeedsTracing<T>::value, "Cannot put DISALLOW_NEW_EXCEPT_PLACEMENT_NEW objects that have trace methods into an off-heap Deque");
-#endif
-    static_assert(Allocator::isGarbageCollected || !IsPointerToGarbageCollectedType<T>::value, "Cannot put raw pointers to garbage-collected classes into a Deque. Use HeapDeque<Member<T>> instead.");
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
-inline Deque<T, inlineCapacity, Allocator>::Deque(const Deque<T, inlineCapacity, Allocator>& other)
+inline Deque<T, inlineCapacity, Allocator>::Deque(const Deque& other)
     : m_buffer(other.m_buffer.capacity())
     , m_start(other.m_start)
     , m_end(other.m_end)
 {
     const T* otherBuffer = other.m_buffer.buffer();
     if (m_start <= m_end) {
         TypeOperations::uninitializedCopy(otherBuffer + m_start, otherBuffer + m_end, m_buffer.buffer() + m_start);
     } else {
         TypeOperations::uninitializedCopy(otherBuffer, otherBuffer + m_end, m_buffer.buffer());
         TypeOperations::uninitializedCopy(otherBuffer + m_start, otherBuffer + m_buffer.capacity(), m_buffer.buffer() + m_start);
     }
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline Deque<T, inlineCapacity, Allocator>& Deque<T, inlineCapacity, Allocator>::operator=(const Deque& other)
 {
     Deque<T> copy(other);
     swap(copy);
     return *this;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
+inline Deque<T, inlineCapacity, Allocator>::Deque(Deque&& other)
+    : m_start(0)
+    , m_end(0)
+{
+    swap(other);
+}
+
+template <typename T, size_t inlineCapacity, typename Allocator>
+inline Deque<T, inlineCapacity, Allocator>& Deque<T, inlineCapacity, Allocator>::operator=(Deque&& other)
+{
+    swap(other);
+    return *this;
+}
+
+template <typename T, size_t inlineCapacity, typename Allocator>
 inline void Deque<T, inlineCapacity, Allocator>::destroyAll()
 {
     if (m_start <= m_end) {
         TypeOperations::destruct(m_buffer.buffer() + m_start, m_buffer.buffer() + m_end);
         m_buffer.clearUnusedSlots(m_buffer.buffer() + m_start, m_buffer.buffer() + m_end);
     } else {
         TypeOperations::destruct(m_buffer.buffer(), m_buffer.buffer() + m_end);
         m_buffer.clearUnusedSlots(m_buffer.buffer(), m_buffer.buffer() + m_end);
         TypeOperations::destruct(m_buffer.buffer() + m_start, m_buffer.buffer() + m_buffer.capacity());
         m_buffer.clearUnusedSlots(m_buffer.buffer() + m_start, m_buffer.buffer() + m_buffer.capacity());
@@ skipping 326 matching lines @@
 struct NeedsTracing<Deque<T, N>> {
     static const bool value = false;
 };
 #endif
 
 } // namespace WTF
 
 using WTF::Deque;
 
 #endif // WTF_Deque_h