Switch v8 inspector to stl collections

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

 /*
  * Copyright (c) 2010-2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 144 matching lines @@
 void V8DebuggerImpl::debuggerAgentDisabled()
 {
     if (!--m_enabledAgentsCount)
         disable();
 }
 
 V8DebuggerAgentImpl* V8DebuggerImpl::findEnabledDebuggerAgent(int contextGroupId)
 {
     if (!contextGroupId)
         return nullptr;
-    V8InspectorSessionImpl* session = m_sessions.get(contextGroupId);
-    if (session && session->debuggerAgent()->enabled())
-        return session->debuggerAgent();
-    return nullptr;
+    SessionMap::iterator it = m_sessions.find(contextGroupId);
+    if (it == m_sessions.end())
+        return nullptr;
+    V8DebuggerAgentImpl* agent = it->second->debuggerAgent();
+    if (!agent->enabled())
+        return nullptr;
+    return agent;
 }
 
 V8DebuggerAgentImpl* V8DebuggerImpl::findEnabledDebuggerAgent(v8::Local<v8::Context> context)
 {
     return findEnabledDebuggerAgent(getGroupId(context));
 }
 
-void V8DebuggerImpl::getCompiledScripts(int contextGroupId, protocol::Vector<V8DebuggerParsedScript>& result)
+void V8DebuggerImpl::getCompiledScripts(int contextGroupId, std::vector<V8DebuggerParsedScript>& result)
 {
     v8::HandleScope scope(m_isolate);
     v8::MicrotasksScope microtasks(m_isolate, v8::MicrotasksScope::kDoNotRunMicrotasks);
     v8::Local<v8::Object> debuggerScript = m_debuggerScript.Get(m_isolate);
     DCHECK(!debuggerScript->IsUndefined());
     v8::Local<v8::Function> getScriptsFunction = v8::Local<v8::Function>::Cast(debuggerScript->Get(v8InternalizedString("getScripts")));
     v8::Local<v8::Value> argv[] = { v8::Integer::New(m_isolate, contextGroupId) };
     v8::Local<v8::Value> value;
     if (!getScriptsFunction->Call(debuggerContext(), debuggerScript, PROTOCOL_ARRAY_LENGTH(argv), argv).ToLocal(&value))
         return;
@@ skipping 213 matching lines @@
         v8result = maybeResult.ToLocalChecked();
     }
     DCHECK(!v8result.IsEmpty());
     v8::Local<v8::Object> resultTuple = v8result->ToObject(m_isolate);
     int code = static_cast<int>(resultTuple->Get(0)->ToInteger(m_isolate)->Value());
     switch (code) {
     case 0:
         {
             *stackChanged = resultTuple->Get(1)->BooleanValue();
             // Call stack may have changed after if the edited function was on the stack.
-            if (!preview && isPaused())
-                newCallFrames->swap(currentCallFrames());
+            if (!preview && isPaused()) {
+                JavaScriptCallFrames frames = currentCallFrames();
+                newCallFrames->swap(frames);
+            }
             return true;
         }
     // Compile error.
     case 1:
         {
             *errorData = protocol::Debugger::SetScriptSourceError::create()
                 .setMessage(toProtocolStringWithTypeCheck(resultTuple->Get(2)))
                 .setLineNumber(resultTuple->Get(3)->ToInteger(m_isolate)->Value())
                 .setColumnNumber(resultTuple->Get(4)->ToInteger(m_isolate)->Value()).build();
             return false;
@@ skipping 20 matching lines @@
         return JavaScriptCallFrames();
     v8::Local<v8::Array> callFramesArray = currentCallFramesV8.As<v8::Array>();
     JavaScriptCallFrames callFrames;
     for (size_t i = 0; i < callFramesArray->Length(); ++i) {
         v8::Local<v8::Value> callFrameValue;
         if (!callFramesArray->Get(debuggerContext(), i).ToLocal(&callFrameValue))
             return JavaScriptCallFrames();
         if (!callFrameValue->IsObject())
             return JavaScriptCallFrames();
         v8::Local<v8::Object> callFrameObject = callFrameValue.As<v8::Object>();
-        callFrames.append(JavaScriptCallFrame::create(debuggerContext(), v8::Local<v8::Object>::Cast(callFrameObject)));
+        callFrames.push_back(JavaScriptCallFrame::create(debuggerContext(), v8::Local<v8::Object>::Cast(callFrameObject)));
     }
     return callFrames;
 }
 
 static V8DebuggerImpl* toV8DebuggerImpl(v8::Local<v8::Value> data)
 {
     void* p = v8::Local<v8::External>::Cast(data)->Value();
     return static_cast<V8DebuggerImpl*>(p);
 }
 
@@ skipping 10 matching lines @@
 void V8DebuggerImpl::handleProgramBreak(v8::Local<v8::Context> pausedContext, v8::Local<v8::Object> executionState, v8::Local<v8::Value> exception, v8::Local<v8::Array> hitBreakpointNumbers, bool isPromiseRejection)
 {
     // Don't allow nested breaks.
     if (m_runningNestedMessageLoop)
         return;
 
     V8DebuggerAgentImpl* agent = findEnabledDebuggerAgent(pausedContext);
     if (!agent)
         return;
 
-    protocol::Vector<String16> breakpointIds;
+    std::vector<String16> breakpointIds;
     if (!hitBreakpointNumbers.IsEmpty()) {
-        breakpointIds.resize(hitBreakpointNumbers->Length());
+        breakpointIds.reserve(hitBreakpointNumbers->Length());
         for (size_t i = 0; i < hitBreakpointNumbers->Length(); i++) {
             v8::Local<v8::Value> hitBreakpointNumber = hitBreakpointNumbers->Get(i);
             DCHECK(!hitBreakpointNumber.IsEmpty() && hitBreakpointNumber->IsInt32());
-            breakpointIds[i] = String16::number(hitBreakpointNumber->Int32Value());
+            breakpointIds.push_back(String16::number(hitBreakpointNumber->Int32Value()));
         }
     }
 
     m_pausedContext = pausedContext;
     m_executionState = executionState;
     V8DebuggerAgentImpl::SkipPauseRequest result = agent->didPause(pausedContext, exception, breakpointIds, isPromiseRejection);
     if (result == V8DebuggerAgentImpl::RequestNoSkip) {
         m_runningNestedMessageLoop = true;
         int groupId = getGroupId(pausedContext);
         DCHECK(groupId);
@@ skipping 92 matching lines @@
     else if (type == v8AsyncTaskEventDidHandle)
         asyncTaskFinished(ptr);
     else
         NOTREACHED();
 }
 
 V8StackTraceImpl* V8DebuggerImpl::currentAsyncCallChain()
 {
     if (!m_currentStacks.size())
         return nullptr;
-    return m_currentStacks.last();
+    return m_currentStacks.back().get();
 }
 
 V8DebuggerParsedScript V8DebuggerImpl::createParsedScript(v8::Local<v8::Object> object, bool success)
 {
     v8::Local<v8::Value> id = object->Get(v8InternalizedString("id"));
     DCHECK(!id.IsEmpty() && id->IsInt32());
 
     V8DebuggerParsedScript parsedScript;
     parsedScript.scriptId = String16::number(id->Int32Value());
     parsedScript.script.setURL(toProtocolStringWithTypeCheck(object->Get(v8InternalizedString("name"))))
@@ skipping 140 matching lines @@
 }
 
 std::unique_ptr<V8StackTrace> V8DebuggerImpl::createStackTrace(v8::Local<v8::StackTrace> stackTrace)
 {
     int contextGroupId = m_isolate->InContext() ? getGroupId(m_isolate->GetCurrentContext()) : 0;
     return V8StackTraceImpl::create(this, contextGroupId, stackTrace, V8StackTrace::maxCallStackSizeToCapture);
 }
 
 std::unique_ptr<V8InspectorSession> V8DebuggerImpl::connect(int contextGroupId, protocol::FrontendChannel* channel, V8InspectorSessionClient* client, const String16* state)
 {
-    DCHECK(!m_sessions.contains(contextGroupId));
-    std::unique_ptr<V8InspectorSessionImpl> session = V8InspectorSessionImpl::create(this, contextGroupId, channel, client, state);
-    m_sessions.set(contextGroupId, session.get());
+    DCHECK(m_sessions.find(contextGroupId) == m_sessions.cend());
+    std::unique_ptr<V8InspectorSessionImpl> session =
+        V8InspectorSessionImpl::create(this, contextGroupId, channel, client, state);
+    m_sessions[contextGroupId] = session.get();
     return std::move(session);
 }
 
 void V8DebuggerImpl::disconnect(V8InspectorSessionImpl* session)
 {
-    DCHECK(m_sessions.contains(session->contextGroupId()));
-    m_sessions.remove(session->contextGroupId());
+    DCHECK(m_sessions.find(session->contextGroupId()) != m_sessions.end());
+    m_sessions.erase(session->contextGroupId());
+}
+
+InspectedContext* V8DebuggerImpl::getContext(int groupId, int contextId) const
+{
+    ContextsByGroupMap::const_iterator contextGroupIt = m_contexts.find(groupId);
+    if (contextGroupIt == m_contexts.cend())
+        return nullptr;
+
+    ContextByIdMap::iterator contextIt = contextGroupIt->second->find(contextId);
+    if (contextIt == contextGroupIt->second->end())
+        return nullptr;
+
+    return contextIt->second.get();
 }
 
 void V8DebuggerImpl::contextCreated(const V8ContextInfo& info)
 {
     DCHECK(info.context->GetIsolate() == m_isolate);
     // TODO(dgozman): make s_lastContextId non-static.
     int contextId = atomicIncrement(&s_lastContextId);
     String16 debugData = String16::number(info.contextGroupId) + "," + String16::number(contextId) + "," + (info.isDefault ? "default" : "nondefault");
     v8::HandleScope scope(m_isolate);
     v8::Context::Scope contextScope(info.context);
     info.context->SetEmbedderData(static_cast<int>(v8::Context::kDebugIdIndex), toV8String(m_isolate, debugData));
 
-    if (!m_contexts.contains(info.contextGroupId))
-        m_contexts.set(info.contextGroupId, wrapUnique(new ContextByIdMap()));
-    DCHECK(!m_contexts.get(info.contextGroupId)->contains(contextId));
+    ContextsByGroupMap::iterator contextIt = m_contexts.find(info.contextGroupId);
+    if (contextIt == m_contexts.end())
+        contextIt = m_contexts.insert(std::make_pair(info.contextGroupId, wrapUnique(new ContextByIdMap()))).first;
 
-    std::unique_ptr<InspectedContext> contextOwner(new InspectedContext(this, info, contextId));
-    InspectedContext* inspectedContext = contextOwner.get();
-    m_contexts.get(info.contextGroupId)->set(contextId, std::move(contextOwner));
+    const auto& contextById = contextIt->second;
 
-    if (V8InspectorSessionImpl* session = m_sessions.get(info.contextGroupId))
-        session->runtimeAgent()->reportExecutionContextCreated(inspectedContext);
+    DCHECK(contextById->find(contextId) == contextById->cend());
+    InspectedContext* context = new InspectedContext(this, info, contextId);
+    (*contextById)[contextId] = wrapUnique(context);
+    SessionMap::iterator sessionIt = m_sessions.find(info.contextGroupId);
+    if (sessionIt != m_sessions.end())
+        sessionIt->second->runtimeAgent()->reportExecutionContextCreated(context);
 }
 
 void V8DebuggerImpl::contextDestroyed(v8::Local<v8::Context> context)
 {
     int contextId = V8Debugger::contextId(context);
     int contextGroupId = getGroupId(context);
-    if (!m_contexts.contains(contextGroupId) || !m_contexts.get(contextGroupId)->contains(contextId))
+    InspectedContext* inspectedContext = getContext(contextGroupId, contextId);
+    if (!inspectedContext)
         return;
 
-    InspectedContext* inspectedContext = m_contexts.get(contextGroupId)->get(contextId);
-    if (V8InspectorSessionImpl* session = m_sessions.get(contextGroupId))
-        session->runtimeAgent()->reportExecutionContextDestroyed(inspectedContext);
-
-    m_contexts.get(contextGroupId)->remove(contextId);
-    if (m_contexts.get(contextGroupId)->isEmpty())
-        m_contexts.remove(contextGroupId);
+    SessionMap::iterator iter = m_sessions.find(contextGroupId);
+    if (iter != m_sessions.end())
+        iter->second->runtimeAgent()->reportExecutionContextDestroyed(inspectedContext);
+    discardInspectedContext(contextGroupId, contextId);
 }
 
 void V8DebuggerImpl::resetContextGroup(int contextGroupId)
 {
-    if (V8InspectorSessionImpl* session = m_sessions.get(contextGroupId))
-        session->reset();
-    m_contexts.remove(contextGroupId);
+    SessionMap::iterator session = m_sessions.find(contextGroupId);
+    if (session != m_sessions.end())
+        session->second->reset();
+    m_contexts.erase(contextGroupId);
 }
 
 void V8DebuggerImpl::setAsyncCallStackDepth(V8DebuggerAgentImpl* agent, int depth)
 {
     if (depth <= 0)
-        m_maxAsyncCallStackDepthMap.remove(agent);
+        m_maxAsyncCallStackDepthMap.erase(agent);
     else
-        m_maxAsyncCallStackDepthMap.set(agent, depth);
+        m_maxAsyncCallStackDepthMap[agent] = depth;
 
     int maxAsyncCallStackDepth = 0;
     for (const auto& pair : m_maxAsyncCallStackDepthMap) {
-        if (*pair.second > maxAsyncCallStackDepth)
-            maxAsyncCallStackDepth = *pair.second;
+        if (pair.second > maxAsyncCallStackDepth)
+            maxAsyncCallStackDepth = pair.second;
     }
 
     if (m_maxAsyncCallStackDepth == maxAsyncCallStackDepth)
         return;
 
     if (maxAsyncCallStackDepth && !m_maxAsyncCallStackDepth)
         m_client->enableAsyncInstrumentation();
     else if (!maxAsyncCallStackDepth && m_maxAsyncCallStackDepth)
         m_client->disableAsyncInstrumentation();
 
     m_maxAsyncCallStackDepth = maxAsyncCallStackDepth;
     if (!maxAsyncCallStackDepth)
         allAsyncTasksCanceled();
 }
 
 void V8DebuggerImpl::asyncTaskScheduled(const String16& taskName, void* task, bool recurring)
 {
     if (!m_maxAsyncCallStackDepth)
         return;
     v8::HandleScope scope(m_isolate);
     int contextGroupId = m_isolate->InContext() ? getGroupId(m_isolate->GetCurrentContext()) : 0;
     std::unique_ptr<V8StackTraceImpl> chain = V8StackTraceImpl::capture(this, contextGroupId, V8StackTrace::maxCallStackSizeToCapture, taskName);
     if (chain) {
-        m_asyncTaskStacks.set(task, std::move(chain));
+        m_asyncTaskStacks[task] = std::move(chain);
         if (recurring)
-            m_recurringTasks.add(task);
+            m_recurringTasks.insert(task);
     }
 }
 
 void V8DebuggerImpl::asyncTaskCanceled(void* task)
 {
     if (!m_maxAsyncCallStackDepth)
         return;
-    m_asyncTaskStacks.remove(task);
-    m_recurringTasks.remove(task);
+    m_asyncTaskStacks.erase(task);
+    m_recurringTasks.erase(task);
 }
 
 void V8DebuggerImpl::asyncTaskStarted(void* task)
 {
     // Not enabled, return.
     if (!m_maxAsyncCallStackDepth)
         return;
 
-    m_currentTasks.append(task);
-    V8StackTraceImpl* stack = m_asyncTaskStacks.get(task);
+    m_currentTasks.push_back(task);
+    AsyncTaskToStackTrace::iterator stackIt = m_asyncTaskStacks.find(task);
     // Needs to support following order of events:
     // - asyncTaskScheduled
     //   <-- attached here -->
     // - asyncTaskStarted
     // - asyncTaskCanceled <-- canceled before finished
     //   <-- async stack requested here -->
     // - asyncTaskFinished
-    m_currentStacks.append(stack ? stack->cloneImpl() : nullptr);
+    std::unique_ptr<V8StackTraceImpl> stack;
+    if (stackIt != m_asyncTaskStacks.end() && stackIt->second)
+        stack = stackIt->second->cloneImpl();
+    m_currentStacks.push_back(std::move(stack));
 }
 
 void V8DebuggerImpl::asyncTaskFinished(void* task)
 {
     if (!m_maxAsyncCallStackDepth)
         return;
     // We could start instrumenting half way and the stack is empty.
     if (!m_currentStacks.size())
         return;
 
-    DCHECK(m_currentTasks.last() == task);
-    m_currentTasks.removeLast();
+    DCHECK(m_currentTasks.back() == task);
+    m_currentTasks.pop_back();
 
-    m_currentStacks.removeLast();
-    if (!m_recurringTasks.contains(task))
-        m_asyncTaskStacks.remove(task);
+    m_currentStacks.pop_back();
+    if (m_recurringTasks.find(task) == m_recurringTasks.end())
+        m_asyncTaskStacks.erase(task);
 }
 
 void V8DebuggerImpl::allAsyncTasksCanceled()
 {
     m_asyncTaskStacks.clear();
     m_recurringTasks.clear();
     m_currentStacks.clear();
     m_currentTasks.clear();
 }
 
@@ skipping 27 matching lines @@
 
 v8::Local<v8::Context> V8DebuggerImpl::regexContext()
 {
     if (m_regexContext.IsEmpty())
         m_regexContext.Reset(m_isolate, v8::Context::New(m_isolate));
     return m_regexContext.Get(m_isolate);
 }
 
 void V8DebuggerImpl::discardInspectedContext(int contextGroupId, int contextId)
 {
-    if (!m_contexts.contains(contextGroupId) || !m_contexts.get(contextGroupId)->contains(contextId))
+    if (!getContext(contextGroupId, contextId))
         return;
-    m_contexts.get(contextGroupId)->remove(contextId);
-    if (m_contexts.get(contextGroupId)->isEmpty())
-        m_contexts.remove(contextGroupId);
+    m_contexts[contextGroupId]->erase(contextId);
+    if (m_contexts[contextGroupId]->empty())
+        m_contexts.erase(contextGroupId);
 }
 
 const V8DebuggerImpl::ContextByIdMap* V8DebuggerImpl::contextGroup(int contextGroupId)
 {
-    if (!m_contexts.contains(contextGroupId))
-        return nullptr;
-    return m_contexts.get(contextGroupId);
+    ContextsByGroupMap::iterator iter = m_contexts.find(contextGroupId);
+    return iter == m_contexts.end() ? nullptr : iter->second.get();
 }
 
 V8InspectorSessionImpl* V8DebuggerImpl::sessionForContextGroup(int contextGroupId)
 {
-    return contextGroupId ? m_sessions.get(contextGroupId) : nullptr;
+    if (!contextGroupId)
+        return nullptr;
+    SessionMap::iterator iter = m_sessions.find(contextGroupId);
+    return iter == m_sessions.end() ? nullptr : iter->second;
 }
 
 } // namespace blink