Switch v8 inspector to stl collections

third_party/WebKit/Source/platform/v8_inspector/V8DebuggerAgentImpl.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/V8DebuggerAgentImpl.h"
 
 #include "platform/inspector_protocol/String16.h"
 #include "platform/inspector_protocol/Values.h"
 #include "platform/v8_inspector/InjectedScript.h"
 #include "platform/v8_inspector/InspectedContext.h"
@@ skipping 172 matching lines @@
 }
 
 void V8DebuggerAgentImpl::enable()
 {
     // debugger().addListener may result in reporting all parsed scripts to
     // the agent so it should already be in enabled state by then.
     m_enabled = true;
     m_state->setBoolean(DebuggerAgentState::debuggerEnabled, true);
     debugger().debuggerAgentEnabled();
 
-    protocol::Vector<V8DebuggerParsedScript> compiledScripts;
+    std::vector<V8DebuggerParsedScript> compiledScripts;
     debugger().getCompiledScripts(m_session->contextGroupId(), compiledScripts);
     for (size_t i = 0; i < compiledScripts.size(); i++)
         didParseSource(compiledScripts[i]);
 
     // FIXME(WK44513): breakpoints activated flag should be synchronized between all front-ends
     debugger().setBreakpointsActivated(true);
     m_session->changeInstrumentationCounter(+1);
 }
 
 bool V8DebuggerAgentImpl::enabled()
@@ skipping 147 matching lines @@
         m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, std::move(newValue));
     }
     if (breakpointsCookie->get(breakpointId)) {
         *errorString = "Breakpoint at specified location already exists.";
         return;
     }
 
     breakpointsCookie->setObject(breakpointId, buildObjectForBreakpointCookie(url, lineNumber, columnNumber, condition, isRegex));
 
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, condition);
-    for (auto& script : m_scripts) {
-        if (!matches(m_debugger, script.second->sourceURL(), url, isRegex))
+    for (const auto& script : m_scripts) {
+        if (!matches(m_debugger, script.second.sourceURL(), url, isRegex))
             continue;
         std::unique_ptr<protocol::Debugger::Location> location = resolveBreakpoint(breakpointId, script.first, breakpoint, UserBreakpointSource);
         if (location)
             (*locations)->addItem(std::move(location));
     }
 
     *outBreakpointId = breakpointId;
 }
 
 static bool parseLocation(ErrorString* errorString, std::unique_ptr<protocol::Debugger::Location> location, String16* scriptId, int* lineNumber, int* columnNumber)
@@ skipping 13 matching lines @@
     String16 scriptId;
     int lineNumber;
     int columnNumber;
 
     if (!parseLocation(errorString, std::move(location), &scriptId, &lineNumber, &columnNumber))
         return;
 
     String16 condition = optionalCondition.fromMaybe("");
 
     String16 breakpointId = generateBreakpointId(scriptId, lineNumber, columnNumber, UserBreakpointSource);
-    if (m_breakpointIdToDebuggerBreakpointIds.contains(breakpointId)) {
+    if (m_breakpointIdToDebuggerBreakpointIds.find(breakpointId) != m_breakpointIdToDebuggerBreakpointIds.end()) {
         *errorString = "Breakpoint at specified location already exists.";
         return;
     }
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, condition);
     *actualLocation = resolveBreakpoint(breakpointId, scriptId, breakpoint, UserBreakpointSource);
     if (*actualLocation)
         *outBreakpointId = breakpointId;
     else
         *errorString = "Could not resolve breakpoint";
 }
 
 void V8DebuggerAgentImpl::removeBreakpoint(ErrorString* errorString, const String16& breakpointId)
 {
     if (!checkEnabled(errorString))
         return;
     protocol::DictionaryValue* breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
     if (breakpointsCookie)
         breakpointsCookie->remove(breakpointId);
     removeBreakpoint(breakpointId);
 }
 
 void V8DebuggerAgentImpl::removeBreakpoint(const String16& breakpointId)
 {
     DCHECK(enabled());
     BreakpointIdToDebuggerBreakpointIdsMap::iterator debuggerBreakpointIdsIterator = m_breakpointIdToDebuggerBreakpointIds.find(breakpointId);
     if (debuggerBreakpointIdsIterator == m_breakpointIdToDebuggerBreakpointIds.end())
         return;
-    protocol::Vector<String16>* ids = debuggerBreakpointIdsIterator->second;
-    for (size_t i = 0; i < ids->size(); ++i) {
-        const String16& debuggerBreakpointId = ids->at(i);
+    const std::vector<String16>& ids = debuggerBreakpointIdsIterator->second;
+    for (size_t i = 0; i < ids.size(); ++i) {
+        const String16& debuggerBreakpointId = ids[i];
 
         debugger().removeBreakpoint(debuggerBreakpointId);
-        m_serverBreakpoints.remove(debuggerBreakpointId);
+        m_serverBreakpoints.erase(debuggerBreakpointId);
     }
-    m_breakpointIdToDebuggerBreakpointIds.remove(breakpointId);
+    m_breakpointIdToDebuggerBreakpointIds.erase(breakpointId);
 }
 
 void V8DebuggerAgentImpl::continueToLocation(ErrorString* errorString,
     std::unique_ptr<protocol::Debugger::Location> location,
     const protocol::Maybe<bool>& interstateLocationOpt)
 {
     if (!checkEnabled(errorString))
         return;
     if (!m_continueToLocationBreakpointId.isEmpty()) {
         debugger().removeBreakpoint(m_continueToLocationBreakpointId);
         m_continueToLocationBreakpointId = "";
     }
 
     String16 scriptId;
     int lineNumber;
     int columnNumber;
 
     if (!parseLocation(errorString, std::move(location), &scriptId, &lineNumber, &columnNumber))
         return;
 
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, "");
     m_continueToLocationBreakpointId = debugger().setBreakpoint(scriptId, breakpoint, &lineNumber, &columnNumber, interstateLocationOpt.fromMaybe(false));
     resume(errorString);
 }
 
 void V8DebuggerAgentImpl::getBacktrace(ErrorString* errorString, std::unique_ptr<Array<CallFrame>>* callFrames, Maybe<StackTrace>* asyncStackTrace)
 {
     if (!assertPaused(errorString))
         return;
-    m_pausedCallFrames.swap(debugger().currentCallFrames());
+    JavaScriptCallFrames frames = debugger().currentCallFrames();
+    m_pausedCallFrames.swap(frames);
     *callFrames = currentCallFrames(errorString);
     if (!*callFrames)
         return;
     *asyncStackTrace = currentAsyncStackTrace();
 }
 
 bool V8DebuggerAgentImpl::isCurrentCallStackEmptyOrBlackboxed()
 {
     DCHECK(enabled());
     JavaScriptCallFrames callFrames = debugger().currentCallFrames();
     for (size_t index = 0; index < callFrames.size(); ++index) {
-        if (!isCallFrameWithUnknownScriptOrBlackboxed(callFrames[index]))
+        if (!isCallFrameWithUnknownScriptOrBlackboxed(callFrames[index].get()))
             return false;
     }
     return true;
 }
 
 bool V8DebuggerAgentImpl::isTopPausedCallFrameBlackboxed()
 {
     DCHECK(enabled());
-    return isCallFrameWithUnknownScriptOrBlackboxed(m_pausedCallFrames.size() ? m_pausedCallFrames[0] : nullptr);
+    JavaScriptCallFrame* frame = m_pausedCallFrames.size() ? m_pausedCallFrames[0].get() : nullptr;
+    return isCallFrameWithUnknownScriptOrBlackboxed(frame);
 }
 
 bool V8DebuggerAgentImpl::isCallFrameWithUnknownScriptOrBlackboxed(JavaScriptCallFrame* frame)
 {
     if (!frame)
         return true;
     ScriptsMap::iterator it = m_scripts.find(String16::number(frame->sourceID()));
     if (it == m_scripts.end()) {
         // Unknown scripts are blackboxed.
         return true;
     }
     if (m_blackboxPattern) {
-        String16 scriptSourceURL = it->second->sourceURL();
+        const String16& scriptSourceURL = it->second.sourceURL();
         if (!scriptSourceURL.isEmpty() && m_blackboxPattern->match(scriptSourceURL) != -1)
             return true;
     }
     auto itBlackboxedPositions = m_blackboxedPositions.find(String16::number(frame->sourceID()));
     if (itBlackboxedPositions == m_blackboxedPositions.end())
         return false;
 
-    protocol::Vector<std::pair<int, int>>* ranges = itBlackboxedPositions->second;
-    auto itRange = std::lower_bound(ranges->begin(), ranges->end(), std::make_pair(frame->line(), frame->column()), positionComparator);
+    const std::vector<std::pair<int, int>>& ranges = itBlackboxedPositions->second;
+    auto itRange = std::lower_bound(ranges.cbegin(), ranges.cend(),
+        std::make_pair(frame->line(), frame->column()), positionComparator);
     // Ranges array contains positions in script where blackbox state is changed.
     // [(0,0) ... ranges[0]) isn't blackboxed, [ranges[0] ... ranges[1]) is blackboxed...
-    return std::distance(ranges->begin(), itRange) % 2;
+    return std::distance(ranges.begin(), itRange) % 2;
 }
 
 V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::shouldSkipExceptionPause(JavaScriptCallFrame* topCallFrame)
 {
     if (m_steppingFromFramework)
         return RequestNoSkip;
     if (isCallFrameWithUnknownScriptOrBlackboxed(topCallFrame))
         return RequestContinue;
     return RequestNoSkip;
 }
@@ skipping 24 matching lines @@
 
 std::unique_ptr<protocol::Debugger::Location> V8DebuggerAgentImpl::resolveBreakpoint(const String16& breakpointId, const String16& scriptId, const ScriptBreakpoint& breakpoint, BreakpointSource source)
 {
     DCHECK(enabled());
     // FIXME: remove these checks once crbug.com/520702 is resolved.
     CHECK(!breakpointId.isEmpty());
     CHECK(!scriptId.isEmpty());
     ScriptsMap::iterator scriptIterator = m_scripts.find(scriptId);
     if (scriptIterator == m_scripts.end())
         return nullptr;
-    V8DebuggerScript* script = scriptIterator->second;
-    if (breakpoint.lineNumber < script->startLine() || script->endLine() < breakpoint.lineNumber)
+    const V8DebuggerScript& script = scriptIterator->second;
+    if (breakpoint.lineNumber < script.startLine() || script.endLine() < breakpoint.lineNumber)
         return nullptr;
 
     int actualLineNumber;
     int actualColumnNumber;
     String16 debuggerBreakpointId = debugger().setBreakpoint(scriptId, breakpoint, &actualLineNumber, &actualColumnNumber, false);
     if (debuggerBreakpointId.isEmpty())
         return nullptr;
 
-    m_serverBreakpoints.set(debuggerBreakpointId, std::make_pair(breakpointId, source));
+    m_serverBreakpoints[debuggerBreakpointId] = std::make_pair(breakpointId, source);
     CHECK(!breakpointId.isEmpty());
-    if (!m_breakpointIdToDebuggerBreakpointIds.contains(breakpointId))
-        m_breakpointIdToDebuggerBreakpointIds.set(breakpointId, protocol::Vector<String16>());
 
-    BreakpointIdToDebuggerBreakpointIdsMap::iterator debuggerBreakpointIdsIterator = m_breakpointIdToDebuggerBreakpointIds.find(breakpointId);
-    debuggerBreakpointIdsIterator->second->append(debuggerBreakpointId);
-
+    m_breakpointIdToDebuggerBreakpointIds[breakpointId].push_back(debuggerBreakpointId);
     return buildProtocolLocation(scriptId, actualLineNumber, actualColumnNumber);
 }
 
 void V8DebuggerAgentImpl::searchInContent(ErrorString* error, const String16& scriptId, const String16& query,
     const Maybe<bool>& optionalCaseSensitive,
     const Maybe<bool>& optionalIsRegex,
     std::unique_ptr<Array<protocol::Debugger::SearchMatch>>* results)
 {
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it != m_scripts.end())
-        *results = V8ContentSearchUtil::searchInTextByLines(m_session, it->second->source(), query, optionalCaseSensitive.fromMaybe(false), optionalIsRegex.fromMaybe(false));
+        *results = V8ContentSearchUtil::searchInTextByLines(m_session, it->second.source(), query, optionalCaseSensitive.fromMaybe(false), optionalIsRegex.fromMaybe(false));
     else
         *error = String16("No script for id: " + scriptId);
 }
 
 void V8DebuggerAgentImpl::setScriptSource(ErrorString* errorString,
     const String16& scriptId,
     const String16& newContent,
     const Maybe<bool>& preview,
     Maybe<protocol::Array<protocol::Debugger::CallFrame>>* newCallFrames,
     Maybe<bool>* stackChanged,
     Maybe<StackTrace>* asyncStackTrace,
     Maybe<protocol::Debugger::SetScriptSourceError>* optOutCompileError)
 {
     if (!checkEnabled(errorString))
         return;
     if (!debugger().setScriptSource(scriptId, newContent, preview.fromMaybe(false), errorString, optOutCompileError, &m_pausedCallFrames, stackChanged))
         return;
 
     std::unique_ptr<Array<CallFrame>> callFrames = currentCallFrames(errorString);
     if (!callFrames)
         return;
     *newCallFrames = std::move(callFrames);
     *asyncStackTrace = currentAsyncStackTrace();
 
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it == m_scripts.end())
         return;
-    it->second->setSource(newContent);
+    it->second.setSource(newContent);
 }
 
 void V8DebuggerAgentImpl::restartFrame(ErrorString* errorString,
     const String16& callFrameId,
     std::unique_ptr<Array<CallFrame>>* newCallFrames,
     Maybe<StackTrace>* asyncStackTrace)
 {
     if (!assertPaused(errorString))
         return;
     InjectedScript::CallFrameScope scope(errorString, m_debugger, m_session->contextGroupId(), callFrameId);
     if (!scope.initialize())
         return;
     if (scope.frameOrdinal() >= m_pausedCallFrames.size()) {
         *errorString = "Could not find call frame with given id";
         return;
     }
 
     v8::Local<v8::Value> resultValue;
     v8::Local<v8::Boolean> result;
     if (!m_pausedCallFrames[scope.frameOrdinal()]->restart().ToLocal(&resultValue) || scope.tryCatch().HasCaught() || !resultValue->ToBoolean(scope.context()).ToLocal(&result) || !result->Value()) {
         *errorString = "Internal error";
         return;
     }
-    m_pausedCallFrames.swap(debugger().currentCallFrames());
+    JavaScriptCallFrames frames = debugger().currentCallFrames();
+    m_pausedCallFrames.swap(frames);
 
     *newCallFrames = currentCallFrames(errorString);
     if (!*newCallFrames)
         return;
     *asyncStackTrace = currentAsyncStackTrace();
 }
 
 void V8DebuggerAgentImpl::getScriptSource(ErrorString* error, const String16& scriptId, String16* scriptSource)
 {
     if (!checkEnabled(error))
         return;
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it == m_scripts.end()) {
         *error = "No script for id: " + scriptId;
         return;
     }
-    *scriptSource = it->second->source();
+    *scriptSource = it->second.source();
 }
 
 void V8DebuggerAgentImpl::getFunctionDetails(ErrorString* errorString, const String16& functionId, std::unique_ptr<FunctionDetails>* details)
 {
     if (!checkEnabled(errorString))
         return;
     InjectedScript::ObjectScope scope(errorString, m_debugger, m_session->contextGroupId(), functionId);
     if (!scope.initialize())
         return;
     if (!scope.object()->IsFunction()) {
@@ skipping 142 matching lines @@
     m_steppingFromFramework = false;
     m_session->releaseObjectGroup(V8InspectorSession::backtraceObjectGroup);
     debugger().continueProgram();
 }
 
 void V8DebuggerAgentImpl::stepOver(ErrorString* errorString)
 {
     if (!assertPaused(errorString))
         return;
     // StepOver at function return point should fallback to StepInto.
-    JavaScriptCallFrame* frame = m_pausedCallFrames.size() ? m_pausedCallFrames[0] : nullptr;
+    JavaScriptCallFrame* frame = !m_pausedCallFrames.empty() ? m_pausedCallFrames[0].get() : nullptr;
     if (frame && frame->isAtReturn()) {
         stepInto(errorString);
         return;
     }
     m_scheduledDebuggerStep = StepOver;
     m_steppingFromFramework = isTopPausedCallFrameBlackboxed();
     m_session->releaseObjectGroup(V8InspectorSession::backtraceObjectGroup);
     debugger().stepOverStatement();
 }
 
@@ skipping 149 matching lines @@
 {
     std::unique_ptr<V8Regex> regex(new V8Regex(m_debugger, pattern, true /** caseSensitive */, false /** multiline */));
     if (!regex->isValid()) {
         *errorString = "Pattern parser error: " + regex->errorMessage();
         return false;
     }
     m_blackboxPattern = std::move(regex);
     return true;
 }
 
-void V8DebuggerAgentImpl::setBlackboxedRanges(ErrorString* error, const String16& scriptId, std::unique_ptr<protocol::Array<protocol::Debugger::ScriptPosition>> inPositions)
+void V8DebuggerAgentImpl::setBlackboxedRanges(ErrorString* error, const String16& scriptId,
+    std::unique_ptr<protocol::Array<protocol::Debugger::ScriptPosition>> inPositions)
 {
-    if (!m_scripts.contains(scriptId)) {
+    if (m_scripts.find(scriptId) == m_scripts.end()) {
         *error = "No script with passed id.";
         return;
     }
 
     if (!inPositions->length()) {
-        m_blackboxedPositions.remove(scriptId);
+        m_blackboxedPositions.erase(scriptId);
         return;
     }
 
-    protocol::Vector<std::pair<int, int>> positions(inPositions->length());
-    for (size_t i = 0; i < positions.size(); ++i) {
+    std::vector<std::pair<int, int>> positions;
+    positions.reserve(inPositions->length());
+    for (size_t i = 0; i < inPositions->length(); ++i) {
         protocol::Debugger::ScriptPosition* position = inPositions->get(i);
         if (position->getLine() < 0) {
             *error = "Position missing 'line' or 'line' < 0.";
             return;
         }
         if (position->getColumn() < 0) {
             *error = "Position missing 'column' or 'column' < 0.";
             return;
         }
-        positions[i] = std::make_pair(position->getLine(), position->getColumn());
+        positions.push_back(std::make_pair(position->getLine(), position->getColumn()));
     }
 
     for (size_t i = 1; i < positions.size(); ++i) {
         if (positions[i - 1].first < positions[i].first)
             continue;
         if (positions[i - 1].first == positions[i].first && positions[i - 1].second < positions[i].second)
             continue;
         *error = "Input positions array is not sorted or contains duplicate values.";
         return;
     }
 
-    m_blackboxedPositions.set(scriptId, positions);
+    m_blackboxedPositions[scriptId] = positions;
 }
 
 void V8DebuggerAgentImpl::willExecuteScript(int scriptId)
 {
     changeJavaScriptRecursionLevel(+1);
     // Fast return.
     if (m_scheduledDebuggerStep != StepInto)
         return;
     // Skip unknown scripts (e.g. InjectedScript).
-    if (!m_scripts.contains(String16::number(scriptId)))
+    if (m_scripts.find(String16::number(scriptId)) == m_scripts.end())
         return;
     schedulePauseOnNextStatementIfSteppingInto();
 }
 
 void V8DebuggerAgentImpl::didExecuteScript()
 {
     changeJavaScriptRecursionLevel(-1);
 }
 
 void V8DebuggerAgentImpl::changeJavaScriptRecursionLevel(int step)
@@ skipping 39 matching lines @@
         // Context has been reported as removed while on pause.
         return Array<CallFrame>::create();
     }
 
     v8::HandleScope handles(m_isolate);
     v8::Local<v8::Context> context = topFrameInjectedScript->context()->context();
     v8::Context::Scope contextScope(context);
 
     v8::Local<v8::Array> objects = v8::Array::New(m_isolate);
     for (size_t frameOrdinal = 0; frameOrdinal < m_pausedCallFrames.size(); ++frameOrdinal) {
-        JavaScriptCallFrame* currentCallFrame = m_pausedCallFrames[frameOrdinal];
+        const std::unique_ptr<JavaScriptCallFrame>& currentCallFrame = m_pausedCallFrames[frameOrdinal];
 
         v8::Local<v8::Object> details = currentCallFrame->details();
         if (hasInternalError(errorString, details.IsEmpty()))
             return Array<CallFrame>::create();
 
         int contextId = currentCallFrame->contextId();
         InjectedScript* injectedScript = contextId ? m_session->findInjectedScript(&ignored, contextId) : nullptr;
         if (!injectedScript)
             injectedScript = topFrameInjectedScript;
 
@@ skipping 66 matching lines @@
     const bool* isContentScriptParam = isContentScript ? &isContentScript : nullptr;
     const bool* isInternalScriptParam = isInternalScript ? &isInternalScript : nullptr;
     const bool* isLiveEditParam = isLiveEdit ? &isLiveEdit : nullptr;
     const bool* hasSourceURLParam = hasSourceURL ? &hasSourceURL : nullptr;
     const bool* deprecatedCommentWasUsedParam = deprecatedCommentWasUsed ? &deprecatedCommentWasUsed : nullptr;
     if (parsedScript.success)
         m_frontend.scriptParsed(parsedScript.scriptId, scriptURL, script.startLine(), script.startColumn(), script.endLine(), script.endColumn(), executionContextId, script.hash(), isContentScriptParam, isInternalScriptParam, isLiveEditParam, sourceMapURLParam, hasSourceURLParam, deprecatedCommentWasUsedParam);
     else
         m_frontend.scriptFailedToParse(parsedScript.scriptId, scriptURL, script.startLine(), script.startColumn(), script.endLine(), script.endColumn(), executionContextId, script.hash(), isContentScriptParam, isInternalScriptParam, sourceMapURLParam, hasSourceURLParam, deprecatedCommentWasUsedParam);
 
-    m_scripts.set(parsedScript.scriptId, script);
+    m_scripts[parsedScript.scriptId] = script;
 
     if (scriptURL.isEmpty() || !parsedScript.success)
         return;
 
     protocol::DictionaryValue* breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
     if (!breakpointsCookie)
         return;
 
     for (size_t i = 0; i < breakpointsCookie->size(); ++i) {
         auto cookie = breakpointsCookie->at(i);
         protocol::DictionaryValue* breakpointObject = protocol::DictionaryValue::cast(cookie.second);
         bool isRegex;
         breakpointObject->getBoolean(DebuggerAgentState::isRegex, &isRegex);
         String16 url;
         breakpointObject->getString(DebuggerAgentState::url, &url);
         if (!matches(m_debugger, scriptURL, url, isRegex))
             continue;
         ScriptBreakpoint breakpoint;
         breakpointObject->getNumber(DebuggerAgentState::lineNumber, &breakpoint.lineNumber);
         breakpointObject->getNumber(DebuggerAgentState::columnNumber, &breakpoint.columnNumber);
         breakpointObject->getString(DebuggerAgentState::condition, &breakpoint.condition);
         std::unique_ptr<protocol::Debugger::Location> location = resolveBreakpoint(cookie.first, parsedScript.scriptId, breakpoint, UserBreakpointSource);
         if (location)
             m_frontend.breakpointResolved(cookie.first, std::move(location));
     }
 }
 
-V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::didPause(v8::Local<v8::Context> context, v8::Local<v8::Value> exception, const protocol::Vector<String16>& hitBreakpoints, bool isPromiseRejection)
+V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::didPause(v8::Local<v8::Context> context, v8::Local<v8::Value> exception, const std::vector<String16>& hitBreakpoints, bool isPromiseRejection)
 {
     JavaScriptCallFrames callFrames = debugger().currentCallFrames(1);
-    JavaScriptCallFrame* topCallFrame = callFrames.size() > 0 ? callFrames[0] : nullptr;
+    JavaScriptCallFrame* topCallFrame = !callFrames.empty() ? callFrames.begin()->get() : nullptr;
 
     V8DebuggerAgentImpl::SkipPauseRequest result;
     if (m_skipAllPauses)
         result = RequestContinue;
-    else if (!hitBreakpoints.isEmpty())
+    else if (!hitBreakpoints.empty())
         result = RequestNoSkip; // Don't skip explicit breakpoints even if set in frameworks.
     else if (!exception.IsEmpty())
         result = shouldSkipExceptionPause(topCallFrame);
     else if (m_scheduledDebuggerStep != NoStep || m_javaScriptPauseScheduled || m_pausingOnNativeEvent)
         result = shouldSkipStepPause(topCallFrame);
     else
         result = RequestNoSkip;
 
     m_skipNextDebuggerStepOut = false;
     if (result != RequestNoSkip)
         return result;
     // Skip pauses inside V8 internal scripts and on syntax errors.
     if (!topCallFrame)
         return RequestContinue;
 
     DCHECK(m_pausedContext.IsEmpty());
-    m_pausedCallFrames.swap(debugger().currentCallFrames());
+    JavaScriptCallFrames frames = debugger().currentCallFrames();
+    m_pausedCallFrames.swap(frames);
     m_pausedContext.Reset(m_isolate, context);
     v8::HandleScope handles(m_isolate);
 
     if (!exception.IsEmpty()) {
         ErrorString ignored;
         InjectedScript* injectedScript = m_session->findInjectedScript(&ignored, V8Debugger::contextId(context));
         if (injectedScript) {
             m_breakReason = isPromiseRejection ? protocol::Debugger::Paused::ReasonEnum::PromiseRejection : protocol::Debugger::Paused::ReasonEnum::Exception;
             ErrorString errorString;
             auto obj = injectedScript->wrapObject(&errorString, exception, V8InspectorSession::backtraceObjectGroup);
             m_breakAuxData = obj ? obj->serialize() : nullptr;
             // m_breakAuxData might be null after this.
         }
     }
 
     std::unique_ptr<Array<String16>> hitBreakpointIds = Array<String16>::create();
 
     for (const auto& point : hitBreakpoints) {
         DebugServerBreakpointToBreakpointIdAndSourceMap::iterator breakpointIterator = m_serverBreakpoints.find(point);
         if (breakpointIterator != m_serverBreakpoints.end()) {
-            const String16& localId = breakpointIterator->second->first;
+            const String16& localId = breakpointIterator->second.first;
             hitBreakpointIds->addItem(localId);
 
-            BreakpointSource source = breakpointIterator->second->second;
+            BreakpointSource source = breakpointIterator->second.second;
             if (m_breakReason == protocol::Debugger::Paused::ReasonEnum::Other && source == DebugCommandBreakpointSource)
                 m_breakReason = protocol::Debugger::Paused::ReasonEnum::DebugCommand;
         }
     }
 
     ErrorString errorString;
     m_frontend.paused(currentCallFrames(&errorString), m_breakReason, std::move(m_breakAuxData), std::move(hitBreakpointIds), currentAsyncStackTrace());
     m_scheduledDebuggerStep = NoStep;
     m_javaScriptPauseScheduled = false;
     m_steppingFromFramework = false;
@@ skipping 67 matching lines @@
 {
     if (!enabled())
         return;
     m_scheduledDebuggerStep = NoStep;
     m_scripts.clear();
     m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
 }
 
 } // namespace blink