Switch v8 inspector to stl collections

third_party/WebKit/Source/platform/inspector_protocol/DispatcherBase.cpp

 // 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.
 
 #include "platform/inspector_protocol/DispatcherBase.h"
 
 #include "platform/inspector_protocol/FrontendChannel.h"
 #include "platform/inspector_protocol/Parser.h"
 
 namespace blink {
 namespace protocol {
 
 // static
 const char DispatcherBase::kInvalidRequest[] = "Invalid request";
 
 DispatcherBase::WeakPtr::WeakPtr(DispatcherBase* dispatcher) : m_dispatcher(dispatcher) { }
 
 DispatcherBase::WeakPtr::~WeakPtr()
 {
     if (m_dispatcher)
-        m_dispatcher->m_weakPtrs.remove(this);
+        m_dispatcher->m_weakPtrs.erase(this);
 }
 
 DispatcherBase::Callback::Callback(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId)
     : m_backendImpl(std::move(backendImpl))
     , m_callId(callId) { }
 
 DispatcherBase::Callback::~Callback() = default;
 
 void DispatcherBase::Callback::dispose()
 {
@@ skipping 74 matching lines @@
 void DispatcherBase::reportProtocolError(int callId, CommonErrorCode code, const String16& errorMessage, ErrorSupport* errors)
 {
     if (m_frontendChannel)
         ::blink::protocol::reportProtocolError(m_frontendChannel, callId, code, errorMessage, errors);
 }
 
 void DispatcherBase::clearFrontend()
 {
     m_frontendChannel = nullptr;
     for (auto& weak : m_weakPtrs)
-        weak.first->dispose();
+        weak->dispose();
     m_weakPtrs.clear();
 }
 
 std::unique_ptr<DispatcherBase::WeakPtr> DispatcherBase::weakPtr()
 {
     std::unique_ptr<DispatcherBase::WeakPtr> weak(new DispatcherBase::WeakPtr(this));
-    m_weakPtrs.add(weak.get());
+    m_weakPtrs.insert(weak.get());
     return weak;
 }
 
 UberDispatcher::UberDispatcher(FrontendChannel* frontendChannel)
     : m_frontendChannel(frontendChannel) { }
 
 void UberDispatcher::registerBackend(const String16& name, std::unique_ptr<protocol::DispatcherBase> dispatcher)
 {
-    m_dispatchers.set(name, std::move(dispatcher));
+    m_dispatchers[name] = std::move(dispatcher);
 }
 
 void UberDispatcher::dispatch(const String16& message)
 {
     std::unique_ptr<protocol::Value> parsedMessage = parseJSON(message);
     if (!parsedMessage)
         return;
     std::unique_ptr<protocol::DictionaryValue> messageObject = DictionaryValue::cast(std::move(parsedMessage));
     if (!messageObject)
         return;
@@ skipping 21 matching lines @@
         reportProtocolError(m_frontendChannel, callId, DispatcherBase::MethodNotFound, "'" + method + "' wasn't found", nullptr);
         return;
     }
     it->second->dispatch(callId, method, std::move(messageObject));
 }
 
 UberDispatcher::~UberDispatcher() = default;
 
 } // namespace protocol
 } // namespace blink