Switch v8 inspector to stl collections

third_party/WebKit/Source/platform/inspector_protocol/Values.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 Values_h
 #define Values_h
 
 #include "platform/inspector_protocol/Allocator.h"
 #include "platform/inspector_protocol/Collections.h"
 #include "platform/inspector_protocol/Platform.h"
 #include "platform/inspector_protocol/String16.h"
 
+#include <vector>
+
 namespace blink {
 namespace protocol {
 
 class ListValue;
 class DictionaryValue;
 class Value;
 
 class PLATFORM_EXPORT Value {
     PROTOCOL_DISALLOW_COPY(Value);
 public:
@@ skipping 144 matching lines @@
     Entry at(size_t index) const;
 
     bool booleanProperty(const String16& name, bool defaultValue) const;
     double numberProperty(const String16& name, double defaultValue) const;
     void remove(const String16& name);
 
     ~DictionaryValue() override;
 
 private:
     DictionaryValue();
+    template<typename T>
+    void set(const String16& key, std::unique_ptr<T>& value)
+    {
+        DCHECK(value);
+        bool isNew = m_data.find(key) == m_data.end();
+        m_data[key] = std::move(value);
+        if (isNew) {

[dgozman, 2016/06/24 17:01:12]

style: redundant {}

[eostroukhov-old, 2016/06/24 22:24:25]

Done.

+            m_order.push_back(key);
+        }
+    }
 
     using Dictionary = protocol::HashMap<String16, std::unique_ptr<Value>>;
     Dictionary m_data;
-    protocol::Vector<String16> m_order;
+    std::vector<String16> m_order;
 };
 
 class PLATFORM_EXPORT ListValue : public Value {
 public:
     static std::unique_ptr<ListValue> create()
     {
         return wrapUnique(new ListValue());
     }
 
     static ListValue* cast(Value* value)
@@ skipping 13 matching lines @@
     void writeJSON(String16Builder* output) const override;
     std::unique_ptr<Value> clone() const override;
 
     void pushValue(std::unique_ptr<Value>);
 
     Value* at(size_t index);
     size_t size() const { return m_data.size(); }
 
 private:
     ListValue();
-    protocol::Vector<std::unique_ptr<Value>> m_data;
+    std::vector<std::unique_ptr<Value>> m_data;
 };
 
 } // namespace protocol
 } // namespace blink
 
 #endif // Values_h