Move to protocol::Vector

third_party/WebKit/Source/platform/inspector_protocol/CollectionsWTF.h

 // Copyright 2016 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 CollectionsWTF_h
 #define CollectionsWTF_h
 
 #include "wtf/Allocator.h"
 #include "wtf/HashMap.h"
 #include "wtf/PassOwnPtr.h"
@@ skipping 22 matching lines @@
     T& operator[](size_t i) { return at(i); }
     const T& operator[](size_t i) const { return at(i); }
     T& at(size_t i) { return m_impl.at(i); }
     const T& at(size_t i) const { return m_impl.at(i); }
     T& last() { return m_impl.last(); }
     const T& last() const { return m_impl.last(); }
     void append(const T& t) { m_impl.append(t); }
     void prepend(const T& t) { m_impl.prepend(t); }
     void remove(size_t i) { m_impl.remove(i); }
     void clear() { m_impl.clear(); }
-    void swap(Vector& other) { m_impl.swap(other.m_impl); }
+    void swap(Vector<T>& other) { m_impl.swap(other.m_impl); }
     void removeLast() { m_impl.removeLast(); }
 
 private:
     WTF::Vector<T> m_impl;
 };
 
 template <typename T>
 class Vector<OwnPtr<T>> {
     WTF_MAKE_NONCOPYABLE(Vector);
 public:
     Vector() { }
     Vector(size_t capacity) : m_impl(capacity) { }
+    Vector(Vector<OwnPtr<T>>&& other) : m_impl(std::move(other.m_impl)) { }
     ~Vector() { }
 
     typedef OwnPtr<T>* iterator;
     typedef const OwnPtr<T>* const_iterator;
 
     iterator begin() { return m_impl.begin(); }
     iterator end() { return m_impl.end(); }
     const_iterator begin() const { return m_impl.begin(); }
     const_iterator end() const { return m_impl.end(); }
 
     void resize(size_t s) { m_impl.resize(s); }
     size_t size() const { return m_impl.size(); }
     bool isEmpty() const { return m_impl.isEmpty(); }
     OwnPtr<T>& operator[](size_t i) { return m_impl.at(i); }
     const OwnPtr<T>& operator[](size_t i) const { return m_impl.at(i); }
     OwnPtr<T>& at(size_t i) { return m_impl.at(i); }
     const OwnPtr<T>& at(size_t i) const { return m_impl.at(i); }
     OwnPtr<T>& last() { return m_impl.last(); }
     const OwnPtr<T>& last() const { return m_impl.last(); }
     void append(PassOwnPtr<T> t) { m_impl.append(t); }
     void prepend(PassOwnPtr<T> t) { m_impl.prepend(t); }
     void remove(size_t i) { m_impl.remove(i); }
     void clear() { m_impl.clear(); }
-    void swap(Vector& other) { m_impl.swap(other.m_impl); }
+    void swap(Vector<OwnPtr<T>>& other) { m_impl.swap(other.m_impl); }
+    void swap(Vector<OwnPtr<T>>&& other) { m_impl.swap(other.m_impl); }
     void removeLast() { m_impl.removeLast(); }
 
 private:
     WTF::Vector<OwnPtr<T>> m_impl;
 };
 
 template <typename K, typename V, typename I>
 class HashMapIterator {
     STACK_ALLOCATED();
 public:
@@ skipping 92 matching lines @@
 template <typename K>
 class HashSet : public protocol::HashMap<K, K> {
 public:
     void add(const K& k) { this->set(k, k); }
 };
 
 } // namespace platform
 } // namespace blink
 
 #endif // !defined(CollectionsWTF_h)