DevTools: introduce collections shim to be backed by non-wtf in v8_inspector.

third_party/WebKit/Source/platform/v8_inspector/V8InjectedScriptHost.cpp

 // Copyright 2015 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.
 
 #include "platform/v8_inspector/V8InjectedScriptHost.h"
 
 #include "platform/inspector_protocol/Values.h"
 #include "platform/v8_inspector/InjectedScript.h"
 #include "platform/v8_inspector/InjectedScriptHost.h"
 #include "platform/v8_inspector/InspectorWrapper.h"
 #include "platform/v8_inspector/JavaScriptCallFrame.h"
 #include "platform/v8_inspector/V8DebuggerImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
 #include "platform/v8_inspector/public/V8DebuggerClient.h"
 #include "platform/v8_inspector/public/V8EventListenerInfo.h"
 #include "platform/v8_inspector/public/V8ToProtocolValue.h"
-#include "wtf/HashSet.h"
 #include "wtf/text/WTFString.h"
 #include <algorithm>
 
 namespace blink {
 
 namespace {
 
 template<typename CallbackInfo, typename S>
 inline void v8SetReturnValue(const CallbackInfo& info, const v8::Local<S> handle)
 {
@@ skipping 187 matching lines @@
 void V8InjectedScriptHost::getInternalPropertiesCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1 || !info[0]->IsObject())
         return;
 
     v8::Local<v8::Object> object = v8::Local<v8::Object>::Cast(info[0]);
     v8::MaybeLocal<v8::Array> properties = v8::Debug::GetInternalProperties(info.GetIsolate(), object);
     v8SetReturnValue(info, properties);
 }
 
-static v8::Local<v8::Array> wrapListenerFunctions(v8::Isolate* isolate, const Vector<V8EventListenerInfo>& listeners)
+static v8::Local<v8::Array> wrapListenerFunctions(v8::Isolate* isolate, const protocol::Vector<V8EventListenerInfo>& listeners)
 {
     v8::Local<v8::Array> result = v8::Array::New(isolate);
     size_t handlersCount = listeners.size();
     for (size_t i = 0, outputIndex = 0; i < handlersCount; ++i) {
         v8::Local<v8::Object> function = listeners[i].handler;
         v8::Local<v8::Object> listenerEntry = v8::Object::New(isolate);
         listenerEntry->Set(toV8StringInternalized(isolate, "listener"), function);
         listenerEntry->Set(toV8StringInternalized(isolate, "useCapture"), v8::Boolean::New(isolate, listeners[i].useCapture));
         result->Set(v8::Number::New(isolate, outputIndex++), listenerEntry);
     }
     return result;
 }
 
 void V8InjectedScriptHost::getEventListenersCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1)
         return;
 
     InjectedScriptHost* host = V8InjectedScriptHost::unwrap(info.GetIsolate()->GetCurrentContext(), info.Holder());
     if (!host->debugger())
         return;
     V8DebuggerClient* client = host->debugger()->client();
     V8EventListenerInfoMap listenerInfo;
     client->eventListeners(info[0], listenerInfo);
 
     v8::Local<v8::Object> result = v8::Object::New(info.GetIsolate());
-    Vector<String> types;
+    protocol::Vector<String> types;
     for (auto& it : listenerInfo)
-        types.append(it.key);
+        types.append(it.first);
     std::sort(types.begin(), types.end(), WTF::codePointCompareLessThan);
     for (const String& type : types) {
         v8::Local<v8::Array> listeners = wrapListenerFunctions(info.GetIsolate(), *listenerInfo.get(type));
         if (!listeners->Length())
             continue;
         result->Set(toV8String(info.GetIsolate(), type), listeners);
     }
 
     v8SetReturnValue(info, result);
 }
@@ skipping 272 matching lines @@
         info.GetReturnValue().Set(toV8String(info.GetIsolate(), groupName));
 }
 
 v8::Local<v8::Symbol> V8Debugger::commandLineAPISymbol(v8::Isolate* isolate)
 {
     return v8::Symbol::ForApi(isolate, toV8StringInternalized(isolate, "commandLineAPI"));
 }
 
 bool V8Debugger::isCommandLineAPIMethod(const AtomicString& name)
 {
-    DEFINE_STATIC_LOCAL(HashSet<String>, methods, ());
+    DEFINE_STATIC_LOCAL(protocol::HashSet<String>, methods, ());
     if (methods.size() == 0) {
         const char* members[] = { "$", "$$", "$x", "dir", "dirxml", "keys", "values", "profile", "profileEnd",
             "monitorEvents", "unmonitorEvents", "inspect", "copy", "clear", "getEventListeners",
             "debug", "undebug", "monitor", "unmonitor", "table", "$_", "$0", "$1", "$2", "$3", "$4" };
         for (size_t i = 0; i < sizeof(members) / sizeof(const char*); ++i)
             methods.add(members[i]);
     }
     return methods.find(name) != methods.end();
 }
 
@@ skipping 28 matching lines @@
     {"setFunctionVariableValue", V8InjectedScriptHost::setFunctionVariableValueCallback},
     {"bind", V8InjectedScriptHost::bindCallback},
     {"objectForId", V8InjectedScriptHost::objectForIdCallback},
     {"idToObjectGroupName", V8InjectedScriptHost::idToObjectGroupNameCallback},
 };
 
 } // namespace
 
 v8::Local<v8::FunctionTemplate> V8InjectedScriptHost::createWrapperTemplate(v8::Isolate* isolate)
 {
-    Vector<InspectorWrapperBase::V8MethodConfiguration> methods(WTF_ARRAY_LENGTH(V8InjectedScriptHostMethods));
+    protocol::Vector<InspectorWrapperBase::V8MethodConfiguration> methods(WTF_ARRAY_LENGTH(V8InjectedScriptHostMethods));
     std::copy(V8InjectedScriptHostMethods, V8InjectedScriptHostMethods + WTF_ARRAY_LENGTH(V8InjectedScriptHostMethods), methods.begin());
-    Vector<InspectorWrapperBase::V8AttributeConfiguration> attributes;
+    protocol::Vector<InspectorWrapperBase::V8AttributeConfiguration> attributes;
     return InjectedScriptHostWrapper::createWrapperTemplate(isolate, methods, attributes);
 }
 
 v8::Local<v8::Object> V8InjectedScriptHost::wrap(V8DebuggerClient* client, v8::Local<v8::FunctionTemplate> constructorTemplate, v8::Local<v8::Context> context, InjectedScriptHost* host)
 {
     return InjectedScriptHostWrapper::wrap(client, constructorTemplate, context, host);
 }
 
 InjectedScriptHost* V8InjectedScriptHost::unwrap(v8::Local<v8::Context> context, v8::Local<v8::Object> object)
 {
     return InjectedScriptHostWrapper::unwrap(context, object);
 }
 
 } // namespace blink