[DevTools] Debugger::currentCallFrames returns array instead linked list

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"
@@ skipping 225 matching lines @@
 {
     if (!enabled())
         return;
 
     m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, protocol::DictionaryValue::create());
     m_state->setNumber(DebuggerAgentState::pauseOnExceptionsState, V8DebuggerImpl::DontPauseOnExceptions);
     m_state->setNumber(DebuggerAgentState::asyncCallStackDepth, 0);
 
     debugger().removeDebuggerAgent(m_contextGroupId);
     m_pausedContext.Reset();
-    m_currentCallStack.clear();
+    JavaScriptCallFrames emptyCallFrames;
+    m_pausedCallFrames.swap(emptyCallFrames);
     m_scripts.clear();
     m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     internalSetAsyncCallStackDepth(0);
     m_continueToLocationBreakpointId = String16();
     clearBreakDetails();
     m_scheduledDebuggerStep = NoStep;
     m_skipNextDebuggerStepOut = false;
     m_javaScriptPauseScheduled = false;
     m_steppingFromFramework = false;
@@ skipping 220 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 = debugger().currentCallFrames();
+    m_pausedCallFrames = debugger().currentCallFrames();
     *callFrames = currentCallFrames(errorString);
     if (!*callFrames)
         return;
     *asyncStackTrace = currentAsyncStackTrace();
 }
 
-bool V8DebuggerAgentImpl::isCallStackEmptyOrBlackboxed()
+bool V8DebuggerAgentImpl::isCurrentCallStackEmptyOrBlackboxed()
 {
     ASSERT(enabled());
-    for (int index = 0; ; ++index) {
-        OwnPtr<JavaScriptCallFrame> frame = debugger().callFrame(index);
-        if (!frame)
-            break;
-        if (!isCallFrameWithUnknownScriptOrBlackboxed(frame.get()))
+    JavaScriptCallFrames callFrames = debugger().currentCallFrames();
+    for (size_t index = 0; index < callFrames.size(); ++index) {
+        if (!isCallFrameWithUnknownScriptOrBlackboxed(callFrames[index].get()))
             return false;
     }
     return true;
 }
 
-bool V8DebuggerAgentImpl::isTopCallFrameBlackboxed()
+bool V8DebuggerAgentImpl::isTopPausedCallFrameBlackboxed()
 {
     ASSERT(enabled());
-    return isCallFrameWithUnknownScriptOrBlackboxed(debugger().callFrame(0).get());
+    return isCallFrameWithUnknownScriptOrBlackboxed(m_pausedCallFrames.size() ? m_pausedCallFrames[0].get() : nullptr);
 }
 
 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;
     }
     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);
     // 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;
 }
 
-V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::shouldSkipExceptionPause()
+V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::shouldSkipExceptionPause(JavaScriptCallFrame* topCallFrame)
 {
     if (m_steppingFromFramework)
         return RequestNoSkip;
-    if (isTopCallFrameBlackboxed())
+    if (isCallFrameWithUnknownScriptOrBlackboxed(topCallFrame))
         return RequestContinue;
     return RequestNoSkip;
 }
 
-V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::shouldSkipStepPause()
+V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::shouldSkipStepPause(JavaScriptCallFrame* topCallFrame)
 {
     if (m_steppingFromFramework)
         return RequestNoSkip;
 
     if (m_skipNextDebuggerStepOut) {
         m_skipNextDebuggerStepOut = false;
         if (m_scheduledDebuggerStep == StepOut)
             return RequestStepOut;
     }
 
-    if (!isTopCallFrameBlackboxed())
+    if (!isCallFrameWithUnknownScriptOrBlackboxed(topCallFrame))
         return RequestNoSkip;
 
     if (m_skippedStepFrameCount >= maxSkipStepFrameCount)
         return RequestStepOut;
 
     if (!m_skippedStepFrameCount)
         m_recursionLevelForStepFrame = 1;
 
     ++m_skippedStepFrameCount;
     return RequestStepFrame;
@@ skipping 45 matching lines @@
     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_currentCallStack, stackChanged))
+    if (!debugger().setScriptSource(scriptId, newContent, preview.fromMaybe(false), errorString, optOutCompileError, &m_pausedCallFrames, stackChanged))
         return;
 
     OwnPtr<Array<CallFrame>> callFrames = currentCallFrames(errorString);
     if (!callFrames)
         return;
     *newCallFrames = callFrames.release();
     *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) {
-        *errorString = "Attempt to access call frame when debugger is not on pause";
+    if (!assertPaused(errorString))
         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) {
+    size_t frameOrdinal = static_cast<size_t>(remoteId->frameOrdinal());
+    if (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 (!javaScriptCallFrame->restart().ToLocal(&resultValue) || tryCatch.HasCaught() || !resultValue->ToBoolean(localContext).ToLocal(&result) || !result->Value()) {
+    if (!m_pausedCallFrames[frameOrdinal].get()->restart().ToLocal(&resultValue) || tryCatch.HasCaught() || !resultValue->ToBoolean(localContext).ToLocal(&result) || !result->Value()) {
         *errorString = "Internal error";
         return;
     }
 
-    m_currentCallStack = debugger().currentCallFrames();
+    m_pausedCallFrames = debugger().currentCallFrames();
 
     *newCallFrames = currentCallFrames(errorString);
     if (!*newCallFrames)
         return;
     *asyncStackTrace = currentAsyncStackTrace();
 }
 
 void V8DebuggerAgentImpl::getScriptSource(ErrorString* error, const String16& scriptId, String16* scriptSource)
 {
     if (!checkEnabled(error))
@@ skipping 207 matching lines @@
     m_steppingFromFramework = false;
     m_injectedScriptManager->releaseObjectGroup(V8DebuggerAgentImpl::backtraceObjectGroup);
     debugger().continueProgram();
 }
 
 void V8DebuggerAgentImpl::stepOver(ErrorString* errorString)
 {
     if (!assertPaused(errorString))
         return;
     // StepOver at function return point should fallback to StepInto.
-    OwnPtr<JavaScriptCallFrame> frame = debugger().callFrame(0);
+    JavaScriptCallFrame* frame = m_pausedCallFrames.size() ? m_pausedCallFrames[0].get() : nullptr;
     if (frame && frame->isAtReturn()) {
         stepInto(errorString);
         return;
     }
     m_scheduledDebuggerStep = StepOver;
-    m_steppingFromFramework = isTopCallFrameBlackboxed();
+    m_steppingFromFramework = isTopPausedCallFrameBlackboxed();
     m_injectedScriptManager->releaseObjectGroup(V8DebuggerAgentImpl::backtraceObjectGroup);
     debugger().stepOverStatement();
 }
 
 void V8DebuggerAgentImpl::stepInto(ErrorString* errorString)
 {
     if (!assertPaused(errorString))
         return;
     m_scheduledDebuggerStep = StepInto;
-    m_steppingFromFramework = isTopCallFrameBlackboxed();
+    m_steppingFromFramework = isTopPausedCallFrameBlackboxed();
     m_injectedScriptManager->releaseObjectGroup(V8DebuggerAgentImpl::backtraceObjectGroup);
     debugger().stepIntoStatement();
 }
 
 void V8DebuggerAgentImpl::stepOut(ErrorString* errorString)
 {
     if (!assertPaused(errorString))
         return;
     m_scheduledDebuggerStep = StepOut;
     m_skipNextDebuggerStepOut = false;
     m_recursionLevelForStepOut = 1;
-    m_steppingFromFramework = isTopCallFrameBlackboxed();
+    m_steppingFromFramework = isTopPausedCallFrameBlackboxed();
     m_injectedScriptManager->releaseObjectGroup(V8DebuggerAgentImpl::backtraceObjectGroup);
     debugger().stepOutOfFunction();
 }
 
 void V8DebuggerAgentImpl::stepIntoAsync(ErrorString* errorString)
 {
     if (!assertPaused(errorString))
         return;
     if (!trackingAsyncCalls()) {
         *errorString = "Can only perform operation if async call stacks are enabled.";
@@ skipping 36 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) {
-        *errorString = "Attempt to access callframe when debugger is not on pause";
+    if (!assertPaused(errorString))
         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(injectedScript->isolate());
 
     if (!injectedScript->canAccessInspectedWindow()) {
         *errorString = "Can not access given context";
         return;
     }
 
-    OwnPtr<JavaScriptCallFrame> javaScriptCallFrame = debugger().callFrame(remoteId->frameOrdinal());
-    if (!javaScriptCallFrame) {
+    size_t frameOrdinal = static_cast<size_t>(remoteId->frameOrdinal());
+    if (frameOrdinal >= m_pausedCallFrames.size()) {
         *errorString = "Could not find call frame with given id";
         return;
     }
 
     v8::MaybeLocal<v8::Object> commandLineAPI = includeCommandLineAPI.fromMaybe(false) ? injectedScript->commandLineAPI(errorString) : v8::MaybeLocal<v8::Object>();
     if (includeCommandLineAPI.fromMaybe(false) && commandLineAPI.IsEmpty())
         return;
 
     InjectedScriptManager::ScopedGlobalObjectExtension scopeExtension(injectedScript, m_injectedScriptManager, commandLineAPI);
 
     v8::TryCatch tryCatch(injectedScript->isolate());
 
-    v8::MaybeLocal<v8::Value> maybeResultValue = javaScriptCallFrame->evaluate(toV8String(injectedScript->isolate(), expression));
+    v8::MaybeLocal<v8::Value> maybeResultValue = m_pausedCallFrames[frameOrdinal].get()->evaluate(toV8String(injectedScript->isolate(), expression));
 
     // InjectedScript may be gone after any evaluate call - find it again.
     injectedScript = m_injectedScriptManager->findInjectedScript(errorString, remoteId.get());
     if (!injectedScript)
         return;
 
     injectedScript->wrapEvaluateResult(errorString,
         maybeResultValue,
         tryCatch,
         objectGroup.fromMaybe(""),
         returnByValue.fromMaybe(false),
         generatePreview.fromMaybe(false),
         result,
         wasThrown,
         exceptionDetails);
 }
 
 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) {
-        *errorString = "Attempt to access callframe when debugger is not on pause";
+    if (!assertPaused(errorString))
         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::TryCatch tryCatch(m_isolate);
 
     v8::Local<v8::Value> newValue;
     if (!injectedScript->resolveCallArgument(errorString, newValueArgument.get()).ToLocal(&newValue))
         return;
 
-    OwnPtr<JavaScriptCallFrame> javaScriptCallFrame = debugger().callFrame(remoteId->frameOrdinal());
-    if (!javaScriptCallFrame) {
+    size_t frameOrdinal = static_cast<size_t>(remoteId->frameOrdinal());
+    if (frameOrdinal >= m_pausedCallFrames.size()) {
         *errorString = "Could not find call frame with given id";
         return;
     }
-    v8::MaybeLocal<v8::Value> result = javaScriptCallFrame->setVariableValue(scopeNumber, toV8String(m_isolate, variableName), newValue);
+    v8::MaybeLocal<v8::Value> result = m_pausedCallFrames[frameOrdinal].get()->setVariableValue(scopeNumber, toV8String(m_isolate, variableName), newValue);
     if (tryCatch.HasCaught() || result.IsEmpty()) {
         *errorString = "Internal error";
         return;
     }
 }
 
 void V8DebuggerAgentImpl::setAsyncCallStackDepth(ErrorString* errorString, int depth)
 {
     if (!checkEnabled(errorString))
         return;
@@ skipping 272 matching lines @@
             if (m_scheduledDebuggerStep == NoStep)
                 debugger().clearStepping();
             else if (m_scheduledDebuggerStep == StepOut)
                 m_skipNextDebuggerStepOut = true;
         }
     }
 }
 
 PassOwnPtr<Array<CallFrame>> V8DebuggerAgentImpl::currentCallFrames(ErrorString* errorString)
 {
-    if (m_pausedContext.IsEmpty() || !m_currentCallStack)
+    if (m_pausedContext.IsEmpty() || !m_pausedCallFrames.size())
         return Array<CallFrame>::create();
     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::Isolate* isolate = injectedScript->isolate();
     v8::HandleScope handles(isolate);
     v8::Local<v8::Context> context = injectedScript->context();
     v8::Context::Scope contextScope(context);
 
-    JavaScriptCallFrame* currentCallFrame = m_currentCallStack.get();
-    int callFrameIndex = 0;
-    OwnPtr<JavaScriptCallFrame> currentCallFrameOwner;
     v8::Local<v8::Array> objects = v8::Array::New(isolate);
-    while (currentCallFrame) {
+    for (size_t frameOrdinal = 0; frameOrdinal < m_pausedCallFrames.size(); ++frameOrdinal) {
+        JavaScriptCallFrame* currentCallFrame = m_pausedCallFrames[frameOrdinal].get();
+
         v8::Local<v8::Object> details = currentCallFrame->details();
         if (hasInternalError(errorString, details.IsEmpty()))
             return Array<CallFrame>::create();
 
-        String16 callFrameId = RemoteCallFrameId::serialize(injectedScript->contextId(), callFrameIndex);
+        String16 callFrameId = RemoteCallFrameId::serialize(injectedScript->contextId(), frameOrdinal);
         if (hasInternalError(errorString, !details->Set(context, toV8StringInternalized(isolate, "callFrameId"), toV8String(isolate, callFrameId)).FromMaybe(false)))
             return Array<CallFrame>::create();
 
         v8::Local<v8::Value> scopeChain;
         if (hasInternalError(errorString, !details->Get(context, toV8StringInternalized(isolate, "scopeChain")).ToLocal(&scopeChain) || !scopeChain->IsArray()))
             return Array<CallFrame>::create();
         v8::Local<v8::Array> scopeChainArray = scopeChain.As<v8::Array>();
         if (!injectedScript->wrapPropertyInArray(errorString, scopeChainArray, toV8StringInternalized(isolate, "object"), V8DebuggerAgentImpl::backtraceObjectGroup))
             return Array<CallFrame>::create();
 
         if (!injectedScript->wrapObjectProperty(errorString, details, toV8StringInternalized(isolate, "this"), V8DebuggerAgentImpl::backtraceObjectGroup))
             return Array<CallFrame>::create();
 
         if (details->Has(context, toV8StringInternalized(isolate, "returnValue")).FromMaybe(false)) {
             if (!injectedScript->wrapObjectProperty(errorString, details, toV8StringInternalized(isolate, "returnValue"), V8DebuggerAgentImpl::backtraceObjectGroup))
                 return Array<CallFrame>::create();
         }
 
-        if (hasInternalError(errorString, !objects->Set(context, callFrameIndex, details).FromMaybe(false)))
+        if (hasInternalError(errorString, !objects->Set(context, frameOrdinal, details).FromMaybe(false)))
             return Array<CallFrame>::create();
-
-        currentCallFrameOwner = currentCallFrame->caller();
-        currentCallFrame = currentCallFrameOwner.get();
-        ++callFrameIndex;
     }
 
     protocol::ErrorSupport errorSupport;
     OwnPtr<Array<CallFrame>> callFrames = Array<CallFrame>::parse(toProtocolValue(context, objects).get(), &errorSupport);
     if (hasInternalError(errorString, !callFrames))
         return Array<CallFrame>::create();
     return callFrames.release();
 }
 
 PassOwnPtr<StackTrace> V8DebuggerAgentImpl::currentAsyncStackTrace()
@@ skipping 68 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, PassOwnPtr<JavaScriptCallFrame> callFrames, 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 protocol::Vector<String16>& hitBreakpoints, bool isPromiseRejection)
 {
+    JavaScriptCallFrames callFrames = debugger().currentCallFrames(1);
+    JavaScriptCallFrame* topCallFrame = callFrames.size() > 0 ? callFrames[0].get() : nullptr;
+
     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();
+        result = shouldSkipExceptionPause(topCallFrame);
     else if (m_scheduledDebuggerStep != NoStep || m_javaScriptPauseScheduled || m_pausingOnNativeEvent)
-        result = shouldSkipStepPause();
+        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 (!callFrames)
+    if (!topCallFrame)
         return RequestContinue;
 
     ASSERT(m_pausedContext.IsEmpty());
+    callFrames = debugger().currentCallFrames();
+    m_pausedCallFrames.swap(callFrames);
     m_pausedContext.Reset(m_isolate, context);
-    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 34 matching lines @@
     if (!m_continueToLocationBreakpointId.isEmpty()) {
         debugger().removeBreakpoint(m_continueToLocationBreakpointId);
         m_continueToLocationBreakpointId = "";
     }
     return result;
 }
 
 void V8DebuggerAgentImpl::didContinue()
 {
     m_pausedContext.Reset();
-    m_currentCallStack.clear();
+    JavaScriptCallFrames emptyCallFrames;
+    m_pausedCallFrames.swap(emptyCallFrames);
     clearBreakDetails();
     m_frontend->resumed();
 }
 
 bool V8DebuggerAgentImpl::canBreakProgram()
 {
     return debugger().canBreakProgram();
 }
 
 void V8DebuggerAgentImpl::breakProgram(const String16& breakReason, PassOwnPtr<protocol::DictionaryValue> data)
 {
     ASSERT(enabled());
-    if (m_skipAllPauses || !m_pausedContext.IsEmpty() || isCallStackEmptyOrBlackboxed() || !debugger().breakpointsActivated())
+    if (m_skipAllPauses || !m_pausedContext.IsEmpty() || isCurrentCallStackEmptyOrBlackboxed() || !debugger().breakpointsActivated())
         return;
     m_breakReason = breakReason;
     m_breakAuxData = data;
     m_scheduledDebuggerStep = NoStep;
     m_steppingFromFramework = false;
     m_pausingOnNativeEvent = false;
     clearStepIntoAsync();
     debugger().breakProgram();
 }
 
@@ skipping 43 matching lines @@
     if (!enabled())
         return;
     m_scheduledDebuggerStep = NoStep;
     m_scripts.clear();
     m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     resetAsyncCallTracker();
 }
 
 } // namespace blink