Switch v8 inspector to stl collections

third_party/WebKit/Source/platform/v8_inspector/V8InspectorSessionImpl.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/v8_inspector/V8InspectorSessionImpl.h"
 
 #include "platform/inspector_protocol/Parser.h"
 #include "platform/v8_inspector/InjectedScript.h"
 #include "platform/v8_inspector/InspectedContext.h"
 #include "platform/v8_inspector/RemoteObjectId.h"
@@ skipping 93 matching lines @@
     discardInjectedScripts();
 }
 
 void V8InspectorSessionImpl::discardInjectedScripts()
 {
     m_inspectedObjects.clear();
     const V8DebuggerImpl::ContextByIdMap* contexts = m_debugger->contextGroup(m_contextGroupId);
     if (!contexts)
         return;
 
-    protocol::Vector<int> keys;
+    std::vector<int> keys;
+    keys.reserve(contexts->size());
     for (auto& idContext : *contexts)
-        keys.append(idContext.first);
+        keys.push_back(idContext.first);
     for (auto& key : keys) {
         contexts = m_debugger->contextGroup(m_contextGroupId);
-        if (contexts && contexts->contains(key))
-            contexts->get(key)->discardInjectedScript(); // This may destroy some contexts.
+        if (contexts) {
+            auto context_iter = contexts->find(key);

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

Blink avoids abbreviations as much as possible, but for iterators the common one
is |it|:
context_iter -> contextIt

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

Done.

+            if (context_iter != contexts->end()) {

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

style: extra {}

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

Done.

+                context_iter->second->discardInjectedScript(); // This may destroy some contexts.
+            }
+        }
     }
 }
 
 InjectedScript* V8InspectorSessionImpl::findInjectedScript(ErrorString* errorString, int contextId)
 {
     if (!contextId) {
         *errorString = "Cannot find context with specified id";
         return nullptr;
     }
 
     const V8DebuggerImpl::ContextByIdMap* contexts = m_debugger->contextGroup(m_contextGroupId);
-    if (!contexts || !contexts->contains(contextId)) {
+    auto contexts_iter = contexts ? contexts->find(contextId) : contexts->end();
+    if (contexts_iter == contexts->end()) {
         *errorString = "Cannot find context with specified id";
         return nullptr;
     }
 
-    InspectedContext* context = contexts->get(contextId);
+    const std::unique_ptr<InspectedContext>& context = contexts_iter->second;
     if (!context->getInjectedScript()) {
         context->createInjectedScript();
         if (!context->getInjectedScript()) {
             *errorString = "Cannot access specified execution context";
             return nullptr;
         }
         if (m_customObjectFormatterEnabled)
             context->getInjectedScript()->setCustomObjectFormatterEnabled(true);
     }
     return context->getInjectedScript();
 }
 
 InjectedScript* V8InspectorSessionImpl::findInjectedScript(ErrorString* errorString, RemoteObjectIdBase* objectId)
 {
     return objectId ? findInjectedScript(errorString, objectId->contextId()) : nullptr;
 }
 
 void V8InspectorSessionImpl::releaseObjectGroup(const String16& objectGroup)
 {
     const V8DebuggerImpl::ContextByIdMap* contexts = m_debugger->contextGroup(m_contextGroupId);
     if (!contexts)
         return;
 
-    protocol::Vector<int> keys;
+    std::vector<int> keys;
     for (auto& idContext : *contexts)
-        keys.append(idContext.first);
+        keys.push_back(idContext.first);
     for (auto& key : keys) {
         contexts = m_debugger->contextGroup(m_contextGroupId);
-        if (contexts && contexts->contains(key)) {
-            InjectedScript* injectedScript = contexts->get(key)->getInjectedScript();
-            if (injectedScript)
-                injectedScript->releaseObjectGroup(objectGroup); // This may destroy some contexts.
+        if (contexts) {

[alph, 2016/06/24 17:37:27]

nit: here and everywhere:
if (!contexts) continue;

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

Done.

+            auto contexts_iter = contexts->find(key);
+            if (contexts_iter != contexts->end()) {
+                InjectedScript* injectedScript = contexts_iter->second->getInjectedScript();
+                if (injectedScript)
+                    injectedScript->releaseObjectGroup(objectGroup); // This may destroy some contexts.
+            }
         }
     }
 }
 
 v8::Local<v8::Value> V8InspectorSessionImpl::findObject(ErrorString* errorString, const String16& objectId, v8::Local<v8::Context>* context, String16* groupName)
 {
     std::unique_ptr<RemoteObjectId> remoteId = RemoteObjectId::parse(errorString, objectId);
     if (!remoteId)
         return v8::Local<v8::Value>();
     InjectedScript* injectedScript = findInjectedScript(errorString, remoteId.get());
@@ skipping 40 matching lines @@
             injectedScript->setCustomObjectFormatterEnabled(enabled);
     }
 }
 
 void V8InspectorSessionImpl::reportAllContexts(V8RuntimeAgentImpl* agent)
 {
     const V8DebuggerImpl::ContextByIdMap* contexts = m_debugger->contextGroup(m_contextGroupId);
     if (!contexts)
         return;
     for (auto& idContext : *contexts)
-        agent->reportExecutionContextCreated(idContext.second);
+        agent->reportExecutionContextCreated(idContext.second.get());
 }
 
 void V8InspectorSessionImpl::changeInstrumentationCounter(int delta)
 {
     DCHECK_GE(m_instrumentationCounter + delta, 0);
     if (!m_instrumentationCounter)
         m_client->startInstrumenting();
     m_instrumentationCounter += delta;
     if (!m_instrumentationCounter)
         m_client->stopInstrumenting();
 }
 
 void V8InspectorSessionImpl::dispatchProtocolMessage(const String16& message)
 {
     m_dispatcher.dispatch(message);
 }
 
 String16 V8InspectorSessionImpl::stateJSON()
 {
     return m_state->toJSONString();
 }
 
 void V8InspectorSessionImpl::addInspectedObject(std::unique_ptr<V8InspectorSession::Inspectable> inspectable)
 {
-    m_inspectedObjects.prepend(std::move(inspectable));
-    while (m_inspectedObjects.size() > kInspectedObjectBufferSize)
-        m_inspectedObjects.removeLast();
+    m_inspectedObjects.insert(m_inspectedObjects.begin(), std::move(inspectable));
+    if (m_inspectedObjects.size() > kInspectedObjectBufferSize)
+        m_inspectedObjects.resize(kInspectedObjectBufferSize);
 }
 
 V8InspectorSession::Inspectable* V8InspectorSessionImpl::inspectedObject(unsigned num)
 {
     if (num >= m_inspectedObjects.size())
         return nullptr;
-    return m_inspectedObjects[num];
+    return m_inspectedObjects[num].get();
 }
 
 void V8InspectorSessionImpl::schedulePauseOnNextStatement(const String16& breakReason, std::unique_ptr<protocol::DictionaryValue> data)
 {
     m_debuggerAgent->schedulePauseOnNextStatement(breakReason, std::move(data));
 }
 
 void V8InspectorSessionImpl::cancelPauseOnNextStatement()
 {
     m_debuggerAgent->cancelPauseOnNextStatement();
@@ skipping 46 matching lines @@
 {
     m_debuggerAgent->asyncTaskFinished(task);
 }
 
 void V8InspectorSessionImpl::allAsyncTasksCanceled()
 {
     m_debuggerAgent->allAsyncTasksCanceled();
 }
 
 } // namespace blink