[DevTools] Move wrapCallFrames from InjectedScriptSource.js to native

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/IgnoreExceptionsScope.h"
 #include "platform/v8_inspector/InjectedScript.h"
 #include "platform/v8_inspector/InjectedScriptHost.h"
 #include "platform/v8_inspector/InjectedScriptManager.h"
 #include "platform/v8_inspector/JavaScriptCallFrame.h"
 #include "platform/v8_inspector/PromiseTracker.h"
 #include "platform/v8_inspector/RemoteObjectId.h"
 #include "platform/v8_inspector/V8AsyncCallTracker.h"
-#include "platform/v8_inspector/V8JavaScriptCallFrame.h"
 #include "platform/v8_inspector/V8Regex.h"
 #include "platform/v8_inspector/V8RuntimeAgentImpl.h"
 #include "platform/v8_inspector/V8StackTraceImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
 #include "platform/v8_inspector/public/V8ContentSearchUtil.h"
 #include "platform/v8_inspector/public/V8Debugger.h"
 #include "platform/v8_inspector/public/V8DebuggerClient.h"
 #include "platform/v8_inspector/public/V8ToProtocolValue.h"
 
 using blink::protocol::Array;
@@ skipping 115 matching lines @@
     return hash.toString();
 }
 
 static bool hasInternalError(ErrorString* errorString, bool hasError)
 {
     if (hasError)
         *errorString = "Internal error";
     return hasError;
 }
 
+static PassOwnPtr<protocol::Debugger::Location> createProtocolLocation(const String16& scriptId, int lineNumber, int columnNumber)
+{
+    return protocol::Debugger::Location::create()
+        .setScriptId(scriptId)
+        .setLineNumber(lineNumber)
+        .setColumnNumber(columnNumber).build();
+}
+
+static PassOwnPtr<Array<protocol::Debugger::Scope>> toProtocolScopeChain(ErrorString* errorString, InjectedScript* injectedScript, JavaScriptCallFrame* callFrame)
+{
+    v8::Local<v8::Value> scopeChainValue = callFrame->scopeChain();
+    if (hasInternalError(errorString, scopeChainValue.IsEmpty() || !scopeChainValue->IsArray()))
+        return nullptr;
+    v8::Local<v8::Array> scopeChainArray = scopeChainValue.As<v8::Array>();
+    if (!injectedScript->wrapObjectsInArray(errorString, scopeChainArray, V8DebuggerAgent::backtraceObjectGroup))
+        return nullptr;
+    OwnPtr<Array<protocol::Debugger::Scope>> outScopeChain = Array<protocol::Debugger::Scope>::create();
+    for (size_t i = 0; i < scopeChainArray->Length(); ++i) {
+        v8::Local<v8::Value> scopeValue;
+        if (hasInternalError(errorString, !scopeChainArray->Get(injectedScript->context(), i).ToLocal(&scopeValue)))
+            return nullptr;
+        protocol::ErrorSupport errorSupport;
+        OwnPtr<RemoteObject> scopeRemoteObject = RemoteObject::parse(toProtocolValue(injectedScript->context(), scopeValue).get(), &errorSupport);
+        if (hasInternalError(errorString, !scopeRemoteObject))
+            return nullptr;
+
+        OwnPtr<protocol::Debugger::Scope> protocolScope = protocol::Debugger::Scope::create()
+            .setType(toProtocolStringWithTypeCheck(callFrame->scopeType(i)))
+            .setObject(scopeRemoteObject.release())
+            .setName(toProtocolStringWithTypeCheck(callFrame->scopeName(i)))
+            .build();
+
+        v8::Local<v8::Value> startLocationValue = callFrame->scopeStartLocation(i);
+        if (hasInternalError(errorString, startLocationValue.IsEmpty()))
+            return nullptr;
+
+        if (!startLocationValue->IsUndefined() && !startLocationValue->IsNull()) {
+            OwnPtr<protocol::Debugger::Location> startLocation = protocol::Debugger::Location::parse(toProtocolValue(injectedScript->context(), startLocationValue).get(), &errorSupport);
+            if (hasInternalError(errorString, !startLocation))
+                return nullptr;
+            protocolScope->setStartLocation(startLocation.release());
+        }
+
+        v8::Local<v8::Value> endLocationValue = callFrame->scopeEndLocation(i);
+        if (hasInternalError(errorString, endLocationValue.IsEmpty()))
+            return nullptr;
+
+        if (!endLocationValue->IsUndefined() && !endLocationValue->IsNull()) {
+            OwnPtr<protocol::Debugger::Location> endLocation = protocol::Debugger::Location::parse(toProtocolValue(injectedScript->context(), endLocationValue).get(), &errorSupport);
+            if (hasInternalError(errorString, !endLocation))
+                return nullptr;
+            protocolScope->setEndLocation(endLocation.release());
+        }
+
+        outScopeChain->addItem(protocolScope.release());
+    }
+    return outScopeChain.release();
+}
+
+static PassOwnPtr<CallFrame> toProtocolCallFrame(ErrorString* errorString, InjectedScript* injectedScript, int callFrameIndex, JavaScriptCallFrame* callFrame)
+{
+    String16 callFrameId = "{\"ordinal\":" + String16::number(callFrameIndex) + ",\"injectedScriptId\":" + String16::number(injectedScript->contextId()) + "}";
+    String16 scriptId = String16::number(callFrame->sourceID());
+    OwnPtr<Array<protocol::Debugger::Scope>> scopeChainArray = toProtocolScopeChain(errorString, injectedScript, callFrame);
+    if (hasInternalError(errorString, !scopeChainArray))
+        return nullptr;
+    OwnPtr<RemoteObject> thisRemoteObject = injectedScript->wrapObject(errorString, callFrame->thisObject(), V8DebuggerAgent::backtraceObjectGroup);
+    if (hasInternalError(errorString, !thisRemoteObject))
+        return nullptr;
+    OwnPtr<CallFrame> outCallFrame = CallFrame::create()
+        .setCallFrameId(callFrameId)
+        .setFunctionName(callFrame->functionName())
+        .setFunctionLocation(createProtocolLocation(scriptId, callFrame->functionLine(), callFrame->functionColumn()))
+        .setLocation(createProtocolLocation(scriptId, callFrame->line(), callFrame->column()))
+        .setScopeChain(scopeChainArray.release())
+        .setThis(thisRemoteObject.release())
+        .build();
+
+    v8::Local<v8::Value> returnValue = callFrame->returnValue();
+    if (hasInternalError(errorString, returnValue.IsEmpty()))
+        return nullptr;
+    if (!returnValue->IsUndefined()) {
+        OwnPtr<RemoteObject> returnRemoteValue = injectedScript->wrapObject(errorString, returnValue, V8DebuggerAgent::backtraceObjectGroup);
+        if (hasInternalError(errorString, !returnRemoteValue))
+            return nullptr;
+        outCallFrame->setReturnValue(returnRemoteValue.release());
+    }
+    return outCallFrame.release();
+}
+
 PassOwnPtr<V8DebuggerAgent> V8DebuggerAgent::create(V8RuntimeAgent* runtimeAgent)
 {
     V8RuntimeAgentImpl* runtimeAgentImpl = static_cast<V8RuntimeAgentImpl*>(runtimeAgent);
     return adoptPtr(new V8DebuggerAgentImpl(runtimeAgentImpl->getInjectedScriptManager(), runtimeAgentImpl->debugger(), runtimeAgentImpl->contextGroupId()));
 }
 
 V8DebuggerAgentImpl::V8DebuggerAgentImpl(InjectedScriptManager* injectedScriptManager, V8DebuggerImpl* debugger, int contextGroupId)
     : m_injectedScriptManager(injectedScriptManager)
     , m_debugger(debugger)
     , m_contextGroupId(contextGroupId)
@@ skipping 72 matching lines @@
         return;
 
     m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, protocol::DictionaryValue::create());
     m_state->setNumber(DebuggerAgentState::pauseOnExceptionsState, V8DebuggerImpl::DontPauseOnExceptions);
     m_state->setNumber(DebuggerAgentState::asyncCallStackDepth, 0);
     m_state->setBoolean(DebuggerAgentState::promiseTrackerEnabled, false);
     m_state->setBoolean(DebuggerAgentState::promiseTrackerCaptureStacks, false);
 
     debugger().removeDebuggerAgent(m_contextGroupId);
     m_pausedContext.Reset();
-    m_currentCallStack.Reset();
+    m_currentCallStack.clear();
     m_scripts.clear();
     m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     internalSetAsyncCallStackDepth(0);
     m_promiseTracker->setEnabled(false, false);
     m_continueToLocationBreakpointId = String16();
     clearBreakDetails();
     m_scheduledDebuggerStep = NoStep;
     m_skipNextDebuggerStepOut = false;
     m_javaScriptPauseScheduled = false;
@@ skipping 223 matching lines @@
 
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, "");
     m_continueToLocationBreakpointId = debugger().setBreakpoint(scriptId, breakpoint, &lineNumber, &columnNumber, interstateLocationOpt.fromMaybe(false));
     resume(errorString);
 }
 
 void V8DebuggerAgentImpl::getBacktrace(ErrorString* errorString, OwnPtr<Array<CallFrame>>* callFrames, Maybe<StackTrace>* asyncStackTrace)
 {
     if (!assertPaused(errorString))
         return;
-    m_currentCallStack.Reset(m_isolate, debugger().currentCallFrames());
-    *callFrames = currentCallFrames();
+    m_currentCallStack = debugger().currentCallFrames();
+    *callFrames = currentCallFrames(errorString);

[dgozman, 2016/03/23 00:12:35]

if error - return nothing?

[kozy, 2016/03/23 02:13:10]

Done.

     *asyncStackTrace = currentAsyncStackTrace();
 }
 
 bool V8DebuggerAgentImpl::isCallStackEmptyOrBlackboxed()
 {
     ASSERT(enabled());
     for (int index = 0; ; ++index) {
         OwnPtr<JavaScriptCallFrame> frame = debugger().callFrame(index);
         if (!frame)
             break;
@@ skipping 82 matching lines @@
         return nullptr;
 
     m_serverBreakpoints.set(debuggerBreakpointId, std::make_pair(breakpointId, source));
     RELEASE_ASSERT(!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);
 
-    OwnPtr<protocol::Debugger::Location> location = protocol::Debugger::Location::create()
-        .setScriptId(scriptId)
-        .setLineNumber(actualLineNumber)
-        .setColumnNumber(actualColumnNumber).build();
-    return location.release();
+    return createProtocolLocation(scriptId, actualLineNumber, actualColumnNumber);

[dgozman, 2016/03/23 00:12:35]

buildLocation

[kozy, 2016/03/23 02:13:10]

Done.

 }
 
 void V8DebuggerAgentImpl::searchInContent(ErrorString* error, const String16& scriptId, const String16& query,
     const Maybe<bool>& optionalCaseSensitive,
     const Maybe<bool>& optionalIsRegex,
     OwnPtr<Array<protocol::Debugger::SearchMatch>>* results)
 {
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it != m_scripts.end())
         *results = V8ContentSearchUtil::searchInTextByLines(m_debugger, it->second->source(), query, optionalCaseSensitive.fromMaybe(false), optionalIsRegex.fromMaybe(false));
     else
         *error = String16("No script for id: " + scriptId);
 }
 
-void V8DebuggerAgentImpl::setScriptSource(ErrorString* error,
+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(error))
+    if (!checkEnabled(errorString))
         return;
-    if (!debugger().setScriptSource(scriptId, newContent, preview.fromMaybe(false), error, optOutCompileError, &m_currentCallStack, stackChanged))
+    if (!debugger().setScriptSource(scriptId, newContent, preview.fromMaybe(false), errorString, optOutCompileError, &m_currentCallStack, stackChanged))
         return;
 
-    *newCallFrames = currentCallFrames();
+    *newCallFrames = currentCallFrames(errorString);
+    if (!errorString->isEmpty())
+        return;
     *asyncStackTrace = currentAsyncStackTrace();
 
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it == m_scripts.end())
         return;
     it->second->setSource(newContent);
 }
 
 void V8DebuggerAgentImpl::restartFrame(ErrorString* errorString,
     const String16& callFrameId,
     OwnPtr<Array<CallFrame>>* newCallFrames,
     Maybe<StackTrace>* asyncStackTrace)
 {
-    if (!isPaused() || m_currentCallStack.IsEmpty()) {
+    if (!isPaused() || !m_currentCallStack) {
         *errorString = "Attempt to access call frame when debugger is not on pause";
         return;
     }
     OwnPtr<RemoteCallFrameId> remoteId = RemoteCallFrameId::parse(errorString, callFrameId);
     if (!remoteId)
         return;
     InjectedScript* injectedScript = m_injectedScriptManager->findInjectedScript(errorString, remoteId.get());
     if (!injectedScript)
         return;
 
     v8::HandleScope scope(m_isolate);
     v8::Local<v8::Context> localContext = injectedScript->context();
 
     v8::TryCatch tryCatch(m_isolate);
 
     OwnPtr<JavaScriptCallFrame> javaScriptCallFrame = debugger().callFrame(remoteId->frameOrdinal());
     if (!javaScriptCallFrame) {
         *errorString = "Could not find call frame with given id";
         return;
     }
     v8::Local<v8::Value> resultValue;
     v8::Local<v8::Boolean> result;
     if (!javaScriptCallFrame->restart().ToLocal(&resultValue) || tryCatch.HasCaught() || !resultValue->ToBoolean(localContext).ToLocal(&result) || !result->Value()) {
         *errorString = "Internal error";
         return;
     }
 
-    m_currentCallStack.Reset(m_isolate, debugger().currentCallFrames());
+    m_currentCallStack = debugger().currentCallFrames();
 
-    *newCallFrames = currentCallFrames();
+    *newCallFrames = currentCallFrames(errorString);
+    if (!errorString->isEmpty())

[dgozman, 2016/03/23 00:12:35]

should we check newCallFrames instead?

[kozy, 2016/03/23 02:13:10]

Done.

+        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;
@@ skipping 28 matching lines @@
 
     v8::Local<v8::Value> scopesValue;
     v8::Local<v8::Array> scopes;
     String16 groupName = injectedScript->objectGroupName(*remoteId);
     if (m_debugger->functionScopes(function).ToLocal(&scopesValue) && scopesValue->IsArray()) {
         scopes = scopesValue.As<v8::Array>();
         if (!injectedScript->wrapPropertyInArray(errorString, scopes, toV8StringInternalized(injectedScript->isolate(), "object"), groupName))
             return;
     }
 
-    OwnPtr<protocol::Debugger::Location> location = protocol::Debugger::Location::create()
-        .setScriptId(String16::number(function->ScriptId()))
-        .setLineNumber(function->GetScriptLineNumber())
-        .setColumnNumber(function->GetScriptColumnNumber()).build();
-
     OwnPtr<FunctionDetails> functionDetails = FunctionDetails::create()
-        .setLocation(location.release())
+        .setLocation(createProtocolLocation(String16::number(function->ScriptId()), function->GetScriptLineNumber(), function->GetScriptColumnNumber()))
         .setFunctionName(toProtocolStringWithTypeCheck(function->GetDebugName()))
         .setIsGenerator(function->IsGeneratorFunction()).build();
 
     if (!scopes.IsEmpty()) {
         protocol::ErrorSupport errorSupport;
         OwnPtr<protocol::Array<protocol::Debugger::Scope>> scopeChain = protocol::Array<protocol::Debugger::Scope>::parse(toProtocolValue(injectedScript->context(), scopes).get(), &errorSupport);
         if (hasInternalError(errorString, errorSupport.hasErrors()))
             return;
         functionDetails->setScopeChain(scopeChain.release());
     }
@@ skipping 249 matching lines @@
     const String16& expression,
     const Maybe<String16>& objectGroup,
     const Maybe<bool>& includeCommandLineAPI,
     const Maybe<bool>& doNotPauseOnExceptionsAndMuteConsole,
     const Maybe<bool>& returnByValue,
     const Maybe<bool>& generatePreview,
     OwnPtr<RemoteObject>* result,
     Maybe<bool>* wasThrown,
     Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
 {
-    if (!isPaused() || m_currentCallStack.IsEmpty()) {
+    if (!isPaused() || !m_currentCallStack) {
         *errorString = "Attempt to access callframe when debugger is not on pause";
         return;
     }
     OwnPtr<RemoteCallFrameId> remoteId = RemoteCallFrameId::parse(errorString, callFrameId);
     if (!remoteId)
         return;
     InjectedScript* injectedScript = m_injectedScriptManager->findInjectedScript(errorString, remoteId.get());
     if (!injectedScript)
         return;
 
@@ skipping 37 matching lines @@
 }
 
 void V8DebuggerAgentImpl::setVariableValue(ErrorString* errorString,
     int scopeNumber,
     const String16& variableName,
     PassOwnPtr<protocol::Runtime::CallArgument> newValueArgument,
     const String16& callFrameId)
 {
     if (!checkEnabled(errorString))
         return;
-    if (!isPaused() || m_currentCallStack.IsEmpty()) {
+    if (!isPaused() || !m_currentCallStack) {
         *errorString = "Attempt to access callframe when debugger is not on pause";
         return;
     }
     OwnPtr<RemoteCallFrameId> remoteId = RemoteCallFrameId::parse(errorString, callFrameId);
     if (!remoteId)
         return;
     InjectedScript* injectedScript = m_injectedScriptManager->findInjectedScript(errorString, remoteId.get());
     if (!injectedScript)
         return;
 
@@ skipping 335 matching lines @@
             // from the old StepFrame.
             m_skippedStepFrameCount = 0;
             if (m_scheduledDebuggerStep == NoStep)
                 debugger().clearStepping();
             else if (m_scheduledDebuggerStep == StepOut)
                 m_skipNextDebuggerStepOut = true;
         }
     }
 }
 
-PassOwnPtr<Array<CallFrame>> V8DebuggerAgentImpl::currentCallFrames()
+PassOwnPtr<Array<CallFrame>> V8DebuggerAgentImpl::currentCallFrames(ErrorString* errorString)
 {
-    if (m_pausedContext.IsEmpty() || m_currentCallStack.IsEmpty())
+    if (m_pausedContext.IsEmpty() || !m_currentCallStack)
         return Array<CallFrame>::create();
-    v8::HandleScope handles(m_isolate);
     InjectedScript* injectedScript = m_injectedScriptManager->injectedScriptFor(m_pausedContext.Get(m_isolate));
     if (!injectedScript) {
         // Context has been reported as removed while on pause.
         return Array<CallFrame>::create();
     }
 
-    v8::Local<v8::Object> currentCallStack = m_currentCallStack.Get(m_isolate);
-    return injectedScript->wrapCallFrames(currentCallStack);
+    v8::HandleScope handles(injectedScript->isolate());
+    v8::Local<v8::Context> context = injectedScript->context();
+    v8::Context::Scope contextScope(context);
+
+    OwnPtr<Array<CallFrame>> callFrames = Array<CallFrame>::create();
+
+    JavaScriptCallFrame* currentCallFrame = m_currentCallStack.get();
+    int callFrameIndex = 0;
+    OwnPtr<JavaScriptCallFrame> currentCallFrameOwner;
+    while (currentCallFrame) {
+        OwnPtr<CallFrame> callFrame = toProtocolCallFrame(errorString, injectedScript, callFrameIndex, currentCallFrame);
+        if (!callFrame)
+            return Array<CallFrame>::create();
+        callFrames->addItem(callFrame.release());
+
+        currentCallFrameOwner = currentCallFrame->caller();
+        currentCallFrame = currentCallFrameOwner.get();
+        ++callFrameIndex;
+    }
+    return callFrames.release();
 }
 
 PassOwnPtr<StackTrace> V8DebuggerAgentImpl::currentAsyncStackTrace()
 {
     if (m_pausedContext.IsEmpty() || !trackingAsyncCalls() || !m_currentAsyncCallChain)
         return nullptr;
 
     return m_currentAsyncCallChain->buildInspectorObjectForTail(this);
 }
 
@@ skipping 61 matching lines @@
         ScriptBreakpoint breakpoint;
         breakpointObject->getNumber(DebuggerAgentState::lineNumber, &breakpoint.lineNumber);
         breakpointObject->getNumber(DebuggerAgentState::columnNumber, &breakpoint.columnNumber);
         breakpointObject->getString(DebuggerAgentState::condition, &breakpoint.condition);
         OwnPtr<protocol::Debugger::Location> location = resolveBreakpoint(cookie.first, parsedScript.scriptId, breakpoint, UserBreakpointSource);
         if (location)
             m_frontend->breakpointResolved(cookie.first, location.release());
     }
 }
 
-V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::didPause(v8::Local<v8::Context> context, v8::Local<v8::Object> callFrames, v8::Local<v8::Value> exception, const protocol::Vector<String16>& hitBreakpoints, bool isPromiseRejection)
+V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::didPause(v8::Local<v8::Context> context, PassOwnPtr<JavaScriptCallFrame> callFrames, v8::Local<v8::Value> exception, const protocol::Vector<String16>& hitBreakpoints, bool isPromiseRejection)
 {
     V8DebuggerAgentImpl::SkipPauseRequest result;
     if (m_skipAllPauses)
         result = RequestContinue;
     else if (!hitBreakpoints.isEmpty())
         result = RequestNoSkip; // Don't skip explicit breakpoints even if set in frameworks.
     else if (!exception.IsEmpty())
         result = shouldSkipExceptionPause();
     else if (m_scheduledDebuggerStep != NoStep || m_javaScriptPauseScheduled || m_pausingOnNativeEvent)
         result = shouldSkipStepPause();
     else
         result = RequestNoSkip;
 
     m_skipNextDebuggerStepOut = false;
     if (result != RequestNoSkip)
         return result;
 
     // Skip pauses inside V8 internal scripts and on syntax errors.
-    if (callFrames.IsEmpty())
+    if (!callFrames)
         return RequestContinue;
 
     ASSERT(m_pausedContext.IsEmpty());
     m_pausedContext.Reset(m_isolate, context);
-    m_currentCallStack.Reset(m_isolate, callFrames);
+

[dgozman, 2016/03/23 00:12:35]

nit: extra blank line

[kozy, 2016/03/23 02:13:10]

Done.

+    m_currentCallStack = callFrames;
     v8::HandleScope handles(m_isolate);
 
     if (!exception.IsEmpty()) {
         InjectedScript* injectedScript = m_injectedScriptManager->injectedScriptFor(context);
         if (injectedScript) {
             m_breakReason = isPromiseRejection ? protocol::Debugger::Paused::ReasonEnum::PromiseRejection : protocol::Debugger::Paused::ReasonEnum::Exception;
             ErrorString errorString;
             auto obj = injectedScript->wrapObject(&errorString, exception, V8DebuggerAgentImpl::backtraceObjectGroup);
             m_breakAuxData = obj ? obj->serialize() : nullptr;
             // m_breakAuxData might be null after this.
@@ skipping 14 matching lines @@
 
             BreakpointSource source = breakpointIterator->second->second;
             if (m_breakReason == protocol::Debugger::Paused::ReasonEnum::Other && source == DebugCommandBreakpointSource)
                 m_breakReason = protocol::Debugger::Paused::ReasonEnum::DebugCommand;
         }
     }
 
     if (!m_asyncOperationNotifications.isEmpty())
         flushAsyncOperationEvents(nullptr);
 
-    m_frontend->paused(currentCallFrames(), m_breakReason, m_breakAuxData.release(), hitBreakpointIds.release(), currentAsyncStackTrace());
+    ErrorString errorString;
+    m_frontend->paused(currentCallFrames(&errorString), m_breakReason, m_breakAuxData.release(), hitBreakpointIds.release(), currentAsyncStackTrace());
     m_scheduledDebuggerStep = NoStep;
     m_javaScriptPauseScheduled = false;
     m_steppingFromFramework = false;
     m_pausingOnNativeEvent = false;
     m_skippedStepFrameCount = 0;
     m_recursionLevelForStepFrame = 0;
     clearStepIntoAsync();
 
     if (!m_continueToLocationBreakpointId.isEmpty()) {
         debugger().removeBreakpoint(m_continueToLocationBreakpointId);
         m_continueToLocationBreakpointId = "";
     }
     return result;
 }
 
 void V8DebuggerAgentImpl::didContinue()
 {
     m_pausedContext.Reset();
-    m_currentCallStack.Reset();
+    m_currentCallStack.clear();
     clearBreakDetails();
     m_frontend->resumed();
 }
 
 bool V8DebuggerAgentImpl::canBreakProgram()
 {
     return debugger().canBreakProgram();
 }
 
 void V8DebuggerAgentImpl::breakProgram(const String16& breakReason, PassOwnPtr<protocol::DictionaryValue> data)
@@ skipping 57 matching lines @@
         return;
     m_scheduledDebuggerStep = NoStep;
     m_scripts.clear();
     m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     resetAsyncCallTracker();
     m_promiseTracker->clear();
 }
 
 } // namespace blink