Move to protocol::Vector

third_party/WebKit/Source/platform/inspector_protocol/CollectionsSTL.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 CollectionsSTL_h
 #define CollectionsSTL_h
 
-#include "wtf/Allocator.h"
-#include "wtf/HashMap.h"
+#include "platform/inspector_protocol/String16.h"
+#include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 
 #include <algorithm>
 #include <unordered_map>
 #include <vector>
 
 namespace std {
 template<>
-struct hash<String> {
-    std::size_t operator()(const String& k) const { return StringHash::hash(k); }
+struct hash<String16> {
+std::size_t operator()(const String16& k) const
+{
+    size_t hash = 0;

[kozy, 2016/04/12 17:09:59]

StringHash::hash caches result. Can we add cache here?

+    for (size_t i = 0; i < k.length(); ++i)
+        hash += 31 * k[i];

[alph, 2016/04/12 19:05:25]

looks like a very bad hash. This is basically just 31*∑k[i], so lots of strings
will collide.

Consider:
hash = 31 * hash + k[i];
It is much better while being a simple enough.

[kozy, 2016/04/12 19:07:50]

Or we can reuse calculateHash from V8DebuggerAgentImpl.cpp :)

+    return hash;
+}
 };
 }
 
 namespace blink {
 namespace protocol {
 
 template <typename T>
 class Vector {
 public:
     Vector() { }
@@ skipping 25 matching lines @@
 private:
     std::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&& other) : m_impl(std::move(other.m_impl)) { }
     ~Vector() { }
 
     typedef typename std::vector<OwnPtr<T>>::iterator iterator;
     typedef typename std::vector<OwnPtr<T>>::const_iterator 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.size(); }
     OwnPtr<T>& operator[](size_t i) { return at(i); }
     const OwnPtr<T>& operator[](size_t i) const { return at(i); }
     OwnPtr<T>& at(size_t i) { return m_impl[i]; }
     const OwnPtr<T>& at(size_t i) const { return m_impl.at(i); }
     OwnPtr<T>& last() { return m_impl[m_impl.size() - 1]; }
     const OwnPtr<T>& last() const { return m_impl[m_impl.size() - 1]; }
     void append(const PassOwnPtr<T>& t) { m_impl.push_back(t); }
     void prepend(const PassOwnPtr<T>& t) { m_impl.insert(m_impl.begin(), t); }
     void remove(size_t i) { m_impl.erase(m_impl.begin() + i); }
     void clear() { m_impl.clear(); }
     void swap(Vector& other) { m_impl.swap(other.m_impl); }
+    void swap(Vector&& other) { m_impl.swap(other.m_impl); }
     void removeLast() { m_impl.pop_back(); }
 
 private:
     std::vector<OwnPtr<T>> m_impl;
 };
 
 template <typename K, typename V, typename I>
 class HashMapIterator {
     STACK_ALLOCATED();
 public:
@@ skipping 114 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(CollectionsSTL_h)