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

third_party/WebKit/Source/platform/inspector_protocol/Dispatcher_cpp.template

 // This file is generated
 
 // Copyright (c) 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.
 
 #include "platform/inspector_protocol/{{class_name}}.h"
 
+#include "platform/inspector_protocol/Collections.h"
 #include "platform/inspector_protocol/FrontendChannel.h"
 #include "platform/inspector_protocol/Parser.h"
-#include "wtf/HashSet.h"
 
 namespace blink {
 namespace protocol {
 
 using protocol::Maybe;
 
 class DispatcherImpl;
 
 class DispatcherImplWeakPtr {
 public:
@@ skipping 10 matching lines @@
     DispatcherImpl(FrontendChannel* frontendChannel)
         : m_frontendChannel(frontendChannel)
 {% for domain in api.domains %}
         , m_{{domain.domain | lower}}Agent(0)
 {% endfor %}
     {
 {% for domain in api.domains %}
   {% for command in domain.commands %}
     {% if "redirect" in command %}{% continue %}{% endif %}
     {% if "handlers" in command and not ("renderer" in command["handlers"]) %}{% continue %}{% endif %}
-        m_dispatchMap.add("{{domain.domain}}.{{command.name}}", &DispatcherImpl::{{domain.domain}}_{{command.name}});
+        m_dispatchMap.set("{{domain.domain}}.{{command.name}}", &DispatcherImpl::{{domain.domain}}_{{command.name}});
   {% endfor %}
 {% endfor %}
 
         // Initialize common errors.
         m_commonErrors.insert(ParseError, -32700);
         m_commonErrors.insert(InvalidRequest, -32600);
         m_commonErrors.insert(MethodNotFound, -32601);
         m_commonErrors.insert(InvalidParams, -32602);
         m_commonErrors.insert(InternalError, -32603);
         m_commonErrors.insert(ServerError, -32000);
     }
 
     ~DispatcherImpl() { clearFrontend(); }
 
     virtual void clearFrontend()
     {
         m_frontendChannel = nullptr;
         for (auto& weak : m_weakPtrs)
-            weak->dispose();
+            weak.first->dispose();
         m_weakPtrs.clear();
     }
 
     PassOwnPtr<DispatcherImplWeakPtr> weakPtr()
     {
         OwnPtr<DispatcherImplWeakPtr> weak = adoptPtr(new DispatcherImplWeakPtr(this));
         m_weakPtrs.add(weak.get());
         return weak.release();
     }
 
     virtual void dispatch(int sessionId, const String& message);
     virtual void reportProtocolError(int sessionId, int callId, CommonErrorCode, const String& errorMessage, ErrorSupport* errors) const;
     using Dispatcher::reportProtocolError;
 
     void sendResponse(int sessionId, int callId, const ErrorString& invocationError, ErrorSupport* errors, PassOwnPtr<protocol::DictionaryValue> result);
 
 {% for domain in api.domains %}
     virtual void registerAgent({{domain.domain}}CommandHandler* agent) { ASSERT(!m_{{domain.domain | lower}}Agent); m_{{domain.domain | lower}}Agent = agent; }
 {% endfor %}
 
 private:
     friend class CallbackBase;
     friend class DispatcherImplWeakPtr;
     using CallHandler = void (DispatcherImpl::*)(int sessionId, int callId, PassOwnPtr<DictionaryValue> messageObject, ErrorSupport* errors);
-    using DispatchMap = HashMap<String, CallHandler>;
+    using DispatchMap = protocol::HashMap<String, CallHandler>;
 
 {% for domain in api.domains %}
   {% for command in domain.commands %}
     {% if "redirect" in command %}{% continue %}{% endif %}
     {% if "handlers" in command and not ("renderer" in command["handlers"]) %}{% continue %}{% endif %}
     void {{domain.domain}}_{{command.name}}(int sessionId, int callId, PassOwnPtr<DictionaryValue> requestMessageObject, ErrorSupport*);
   {% endfor %}
 {% endfor %}
 
     FrontendChannel* m_frontendChannel;
 
 {% for domain in api.domains %}
     {{domain.domain}}CommandHandler* m_{{domain.domain | lower}}Agent;
 {% endfor %}
 
     void sendResponse(int sessionId, int callId, ErrorString invocationError, PassOwnPtr<protocol::DictionaryValue> result)
     {
         sendResponse(sessionId, callId, invocationError, nullptr, result);
     }
 
     void sendResponse(int sessionId, int callId, ErrorString invocationError)
     {
         sendResponse(sessionId, callId, invocationError, nullptr, DictionaryValue::create());
     }
 
     static const char InvalidParamsFormatString[];
 
     DispatchMap m_dispatchMap;
-    Vector<int> m_commonErrors;
-    HashSet<DispatcherImplWeakPtr*> m_weakPtrs;
+    protocol::Vector<int> m_commonErrors;
+    protocol::HashSet<DispatcherImplWeakPtr*> m_weakPtrs;
 };
 
 DispatcherImplWeakPtr::~DispatcherImplWeakPtr()
 {
     if (m_dispatcher)
         m_dispatcher->m_weakPtrs.remove(this);
 }
 
 const char DispatcherImpl::InvalidParamsFormatString[] = "Some arguments of method '%s' can't be processed";
 {% for domain in api.domains %}
@@ skipping 128 matching lines @@
 
     protocol::Value* callIdValue = messageObject->get("id");
     bool success = callIdValue->asNumber(&callId);
     ASSERT_UNUSED(success, success);
 
     protocol::Value* methodValue = messageObject->get("method");
     String method;
     success = methodValue && methodValue->asString(&method);
     ASSERT_UNUSED(success, success);
 
-    HashMap<String, CallHandler>::iterator it = m_dispatchMap.find(method);
+    protocol::HashMap<String, CallHandler>::iterator it = m_dispatchMap.find(method);
     if (it == m_dispatchMap.end()) {
         reportProtocolError(sessionId, callId, MethodNotFound, "'" + method + "' wasn't found");
         return;
     }
 
     protocol::ErrorSupport errors;
-    ((*this).*it->value)(sessionId, callId, messageObject.release(), &errors);
+    ((*this).*(*it->second))(sessionId, callId, messageObject.release(), &errors);
 }
 
 void DispatcherImpl::sendResponse(int sessionId, int callId, const ErrorString& invocationError, ErrorSupport* errors, PassOwnPtr<protocol::DictionaryValue> result)
 {
     if (invocationError.length() || (errors && errors->hasErrors())) {
         reportProtocolError(sessionId, callId, ServerError, invocationError, errors);
         return;
     }
 
     OwnPtr<protocol::DictionaryValue> responseMessage = DictionaryValue::create();
@@ skipping 62 matching lines @@
 void Dispatcher::CallbackBase::sendIfActive(PassOwnPtr<protocol::DictionaryValue> partialMessage, const ErrorString& invocationError)
 {
     if (!m_backendImpl->get())
         return;
     m_backendImpl->get()->sendResponse(m_sessionId, m_id, invocationError, nullptr, partialMessage);
     m_backendImpl = nullptr;
 }
 
 } // namespace protocol
 } // namespace blink