Merge DevTools Refactor CL to Blink36

Source/core/inspector/InspectorDebuggerAgent.cpp

 /*
  * Copyright (C) 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 11 matching lines @@
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/inspector/InspectorDebuggerAgent.h"
-#include "core/inspector/JavaScriptCallFrame.h"
 
+#include "InspectorFrontend.h"
+#include "bindings/dart/DartScriptDebugServer.h"
 #include "bindings/v8/ScriptDebugServer.h"
 #include "bindings/v8/ScriptObject.h"
 #include "bindings/v8/ScriptRegexp.h"
 #include "bindings/v8/ScriptSourceCode.h"
 #include "core/dom/Document.h"
 #include "core/fetch/Resource.h"
 #include "core/inspector/ContentSearchUtils.h"
 #include "core/inspector/InjectedScriptManager.h"
 #include "core/inspector/InspectorPageAgent.h"
 #include "core/inspector/InspectorState.h"
 #include "core/inspector/InstrumentingAgents.h"
 #include "core/inspector/ScriptArguments.h"
+#include "core/inspector/ScriptCallFrame.h"
 #include "core/inspector/ScriptCallStack.h"
 #include "platform/JSONValues.h"
 #include "wtf/text/WTFString.h"
 
 using WebCore::TypeBuilder::Array;
 using WebCore::TypeBuilder::Debugger::BreakpointId;
 using WebCore::TypeBuilder::Debugger::CallFrame;
 using WebCore::TypeBuilder::Debugger::FunctionDetails;
 using WebCore::TypeBuilder::Debugger::ScriptId;
 using WebCore::TypeBuilder::Debugger::StackTrace;
@@ skipping 375 matching lines @@
     if (!parseLocation(errorString, location, &scriptId, &lineNumber, &columnNumber))
         return;
 
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, "");
     m_continueToLocationBreakpointId = scriptDebugServer().setBreakpoint(scriptId, breakpoint, &lineNumber, &columnNumber, interstateLocation);
     resume(errorString);
 }
 
 void InspectorDebuggerAgent::getStepInPositions(ErrorString* errorString, const String& callFrameId, RefPtr<Array<TypeBuilder::Debugger::Location> >& positions)
 {
-    if (!isPaused() || m_currentCallStack.isEmpty()) {
+    if (!isPaused() || m_currentCallStack.isNull()) {
         *errorString = "Attempt to access callframe when debugger is not on pause";
         return;
     }
-    InjectedScript injectedScript = m_injectedScriptManager->injectedScriptForObjectId(callFrameId);
+    InjectedScript& injectedScript = m_injectedScriptManager->injectedScriptForObjectId(callFrameId);
     if (injectedScript.isEmpty()) {
         *errorString = "Inspected frame has gone";
         return;
     }
 
     injectedScript.getStepInPositions(errorString, m_currentCallStack, callFrameId, positions);
 }
 
-void InspectorDebuggerAgent::getBacktrace(ErrorString* errorString, RefPtr<Array<CallFrame> >& callFrames, RefPtr<StackTrace>& asyncStackTrace)
+void InspectorDebuggerAgent::getBacktrace(ErrorString* errorString, RefPtr<Array<CallFrame> >& callFrames, WTF::RefPtr<WebCore::TypeBuilder::Debugger::StackTrace>& asyncStackTrace)
 {
     if (!assertPaused(errorString))
         return;
     m_currentCallStack = scriptDebugServer().currentCallFrames();
     callFrames = currentCallFrames();
     asyncStackTrace = currentAsyncStackTrace();
 }
 
-String InspectorDebuggerAgent::scriptURL(JavaScriptCallFrame* frame)
-{
-    String scriptIdString = String::number(frame->sourceID());
-    ScriptsMap::iterator it = m_scripts.find(scriptIdString);
-    if (it == m_scripts.end())
-        return String();
-    return it->value.url;
-}
-
-ScriptDebugListener::SkipPauseRequest InspectorDebuggerAgent::shouldSkipExceptionPause(RefPtr<JavaScriptCallFrame>& topFrame)
+ScriptDebugListener::SkipPauseRequest InspectorDebuggerAgent::shouldSkipExceptionPause(const ScriptCallFrame& topFrame)
 {
     if (m_skipAllPauses)
         return ScriptDebugListener::Continue;
-    if (!topFrame)
-        return ScriptDebugListener::NoSkip;
 
-    String topFrameScriptUrl = scriptURL(topFrame.get());
+    String topFrameScriptUrl = topFrame.sourceURL();
     if (m_cachedSkipStackRegExp && !topFrameScriptUrl.isEmpty() && m_cachedSkipStackRegExp->match(topFrameScriptUrl) != -1)
         return ScriptDebugListener::Continue;
 
     // Match against breakpoints.
     if (topFrameScriptUrl.isEmpty())
         return ScriptDebugListener::NoSkip;
 
     // Prepare top frame parameters.
-    int topFrameLineNumber = topFrame->line();
-    int topFrameColumnNumber = topFrame->column();
+    int topFrameLineNumber = topFrame.lineNumber();
+    int topFrameColumnNumber = topFrame.columnNumber();
 
     RefPtr<JSONObject> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
     for (JSONObject::iterator it = breakpointsCookie->begin(); it != breakpointsCookie->end(); ++it) {
         RefPtr<JSONObject> breakpointObject = it->value->asObject();
         bool isAntibreakpoint;
         breakpointObject->getBoolean(DebuggerAgentState::isAnti, &isAntibreakpoint);
         if (!isAntibreakpoint)
             continue;
 
         int breakLineNumber;
@@ skipping 13 matching lines @@
         breakpointObject->getString(DebuggerAgentState::url, &url);
         if (!matches(topFrameScriptUrl, url, isRegex))
             continue;
 
         return ScriptDebugListener::Continue;
     }
 
     return ScriptDebugListener::NoSkip;
 }
 
-ScriptDebugListener::SkipPauseRequest InspectorDebuggerAgent::shouldSkipBreakpointPause(RefPtr<JavaScriptCallFrame>& topFrame)
+ScriptDebugListener::SkipPauseRequest InspectorDebuggerAgent::shouldSkipBreakpointPause(const ScriptCallFrame& topFrame)
 {
     if (m_skipAllPauses)
         return ScriptDebugListener::Continue;
-    if (!topFrame)
-        return ScriptDebugListener::NoSkip;
     return ScriptDebugListener::NoSkip;
 }
 
-ScriptDebugListener::SkipPauseRequest InspectorDebuggerAgent::shouldSkipStepPause(RefPtr<JavaScriptCallFrame>& topFrame)
+ScriptDebugListener::SkipPauseRequest InspectorDebuggerAgent::shouldSkipStepPause(const ScriptCallFrame& topFrame)
 {
     if (m_skipAllPauses)
         return ScriptDebugListener::Continue;
-    if (!topFrame)
-        return ScriptDebugListener::NoSkip;
 
     if (m_cachedSkipStackRegExp) {
-        String scriptUrl = scriptURL(topFrame.get());
+        String scriptUrl = topFrame.sourceURL();
         if (!scriptUrl.isEmpty() && m_cachedSkipStackRegExp->match(scriptUrl) != -1) {
             if (m_skipStepInCount > 0) {
                 --m_skipStepInCount;
                 return ScriptDebugListener::StepInto;
             }
             return ScriptDebugListener::StepOut;
         }
     }
     return ScriptDebugListener::NoSkip;
 }
@@ skipping 33 matching lines @@
     bool isRegex = optionalIsRegex ? *optionalIsRegex : false;
     bool caseSensitive = optionalCaseSensitive ? *optionalCaseSensitive : false;
 
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it != m_scripts.end())
         results = ContentSearchUtils::searchInTextByLines(it->value.source, query, caseSensitive, isRegex);
     else
         *error = "No script for id: " + scriptId;
 }
 
-void InspectorDebuggerAgent::setScriptSource(ErrorString* error, RefPtr<TypeBuilder::Debugger::SetScriptSourceError>& errorData, const String& scriptId, const String& newContent, const bool* const preview, RefPtr<Array<CallFrame> >& newCallFrames, RefPtr<JSONObject>& result, RefPtr<StackTrace>& asyncStackTrace)
+void InspectorDebuggerAgent::setScriptSource(ErrorString* error, RefPtr<TypeBuilder::Debugger::SetScriptSourceError>& errorData, const String& scriptId, const String& newContent, const bool* const preview, RefPtr<Array<CallFrame> >& newCallFrames, RefPtr<JSONObject>& result, WTF::RefPtr<WebCore::TypeBuilder::Debugger::StackTrace>& asyncStackTrace)
 {
     bool previewOnly = preview && *preview;
-    if (!scriptDebugServer().setScriptSource(scriptId, newContent, previewOnly, error, errorData, &m_currentCallStack, &result))
+    if (!scriptDebugServer().setScriptSource(scriptId, newContent, previewOnly, error, errorData, &m_currentCallStack, result))
         return;
     newCallFrames = currentCallFrames();
     asyncStackTrace = currentAsyncStackTrace();
 }
 
-void InspectorDebuggerAgent::restartFrame(ErrorString* errorString, const String& callFrameId, RefPtr<Array<CallFrame> >& newCallFrames, RefPtr<JSONObject>& result, RefPtr<StackTrace>& asyncStackTrace)
+void InspectorDebuggerAgent::restartFrame(ErrorString* errorString, const String& callFrameId, RefPtr<Array<CallFrame> >& newCallFrames, RefPtr<JSONObject>& result, WTF::RefPtr<WebCore::TypeBuilder::Debugger::StackTrace>& asyncStackTrace)
 {
-    if (!isPaused() || m_currentCallStack.isEmpty()) {
+    if (!isPaused() || m_currentCallStack.isNull()) {
         *errorString = "Attempt to access callframe when debugger is not on pause";
         return;
     }
-    InjectedScript injectedScript = m_injectedScriptManager->injectedScriptForObjectId(callFrameId);
+    InjectedScript& injectedScript = m_injectedScriptManager->injectedScriptForObjectId(callFrameId);
     if (injectedScript.isEmpty()) {
         *errorString = "Inspected frame has gone";
         return;
     }
 
     injectedScript.restartFrame(errorString, m_currentCallStack, callFrameId, &result);
     m_currentCallStack = scriptDebugServer().currentCallFrames();
     newCallFrames = currentCallFrames();
     asyncStackTrace = currentAsyncStackTrace();
 }
 
 void InspectorDebuggerAgent::getScriptSource(ErrorString* error, const String& scriptId, String* scriptSource)
 {
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it != m_scripts.end())
         *scriptSource = it->value.source;
     else
         *error = "No script for id: " + scriptId;
 }
 
 void InspectorDebuggerAgent::getFunctionDetails(ErrorString* errorString, const String& functionId, RefPtr<FunctionDetails>& details)
 {
-    InjectedScript injectedScript = m_injectedScriptManager->injectedScriptForObjectId(functionId);
+    InjectedScript& injectedScript = m_injectedScriptManager->injectedScriptForObjectId(functionId);
     if (injectedScript.isEmpty()) {
         *errorString = "Function object id is obsolete";
         return;
     }
     injectedScript.getFunctionDetails(errorString, functionId, &details);
 }
 
 void InspectorDebuggerAgent::schedulePauseOnNextStatement(InspectorFrontend::Debugger::Reason::Enum breakReason, PassRefPtr<JSONObject> data)
 {
     if (m_javaScriptPauseScheduled)
@@ skipping 174 matching lines @@
 }
 
 void InspectorDebuggerAgent::resume(ErrorString* errorString)
 {
     if (!assertPaused(errorString))
         return;
     m_injectedScriptManager->releaseObjectGroup(InspectorDebuggerAgent::backtraceObjectGroup);
     scriptDebugServer().continueProgram();
 }
 
-ScriptValue InspectorDebuggerAgent::resolveCallFrame(ErrorString* errorString, const String* callFrameId)
+ActivationFrame InspectorDebuggerAgent::resolveCallFrame(ErrorString* errorString, const String* callFrameId)
 {
     if (!callFrameId)
-        return ScriptValue();
-    if (!isPaused() || m_currentCallStack.isEmpty()) {
+        return ActivationFrame();
+    if (!isPaused() || m_currentCallStack.isNull()) {
         *errorString = "Attempt to access callframe when debugger is not on pause";
-        return ScriptValue();
+        return ActivationFrame();
     }
-    InjectedScript injectedScript = m_injectedScriptManager->injectedScriptForObjectId(*callFrameId);
+    InjectedScript& injectedScript = m_injectedScriptManager->injectedScriptForObjectId(*callFrameId);
     if (injectedScript.isEmpty()) {
         *errorString = "Inspected frame has gone";
-        return ScriptValue();
+        return ActivationFrame();
     }
     return injectedScript.findCallFrameById(errorString, m_currentCallStack, *callFrameId);
 }
 
 void InspectorDebuggerAgent::stepOver(ErrorString* errorString, const String* callFrameId)
 {
     if (!assertPaused(errorString))
         return;
-    ScriptValue frame = resolveCallFrame(errorString, callFrameId);
+    ActivationFrame frame = resolveCallFrame(errorString, callFrameId);
     if (!errorString->isEmpty())
         return;
     m_injectedScriptManager->releaseObjectGroup(InspectorDebuggerAgent::backtraceObjectGroup);
     scriptDebugServer().stepOverStatement(frame);
 }
 
 void InspectorDebuggerAgent::stepInto(ErrorString* errorString)
 {
     if (!assertPaused(errorString))
         return;
     m_injectedScriptManager->releaseObjectGroup(InspectorDebuggerAgent::backtraceObjectGroup);
     scriptDebugServer().stepIntoStatement();
     if (m_listener)
         m_listener->stepInto();
 }
 
 void InspectorDebuggerAgent::stepOut(ErrorString* errorString, const String* callFrameId)
 {
     if (!assertPaused(errorString))
         return;
-    ScriptValue frame = resolveCallFrame(errorString, callFrameId);
+    ActivationFrame frame = resolveCallFrame(errorString, callFrameId);
     if (!errorString->isEmpty())
         return;
     m_injectedScriptManager->releaseObjectGroup(InspectorDebuggerAgent::backtraceObjectGroup);
     scriptDebugServer().stepOutOfFunction(frame);
 }
 
 void InspectorDebuggerAgent::setPauseOnExceptions(ErrorString* errorString, const String& stringPauseState)
 {
     ScriptDebugServer::PauseOnExceptionsState pauseState;
     if (stringPauseState == "none")
@@ skipping 11 matching lines @@
 
 void InspectorDebuggerAgent::setPauseOnExceptionsImpl(ErrorString* errorString, int pauseState)
 {
     scriptDebugServer().setPauseOnExceptionsState(static_cast<ScriptDebugServer::PauseOnExceptionsState>(pauseState));
     if (scriptDebugServer().pauseOnExceptionsState() != pauseState)
         *errorString = "Internal error. Could not change pause on exceptions state";
     else
         m_state->setLong(DebuggerAgentState::pauseOnExceptionsState, pauseState);
 }
 
+void InspectorDebuggerAgent::collectAsyncCallStacks(Vector<StackTrace>& asyncCallStacks)
+{
+    const AsyncCallStackTracker::AsyncCallChain* asyncChain = m_asyncCallStackTracker.isEnabled() ? m_asyncCallStackTracker.currentAsyncCallChain() : 0;
+    if (asyncChain) {
+        const AsyncCallStackTracker::AsyncCallStackVector& callStacks = asyncChain->callStacks();
+        asyncCallStacks.resize(callStacks.size());
+        AsyncCallStackTracker::AsyncCallStackVector::const_iterator it = callStacks.begin();
+        for (size_t i = 0; it != callStacks.end(); ++it, ++i)
+            asyncCallStacks[i] = (*it)->callFrames();
+    }
+}
+
 void InspectorDebuggerAgent::evaluateOnCallFrame(ErrorString* errorString, const String& callFrameId, const String& expression, const String* const objectGroup, const bool* const includeCommandLineAPI, const bool* const doNotPauseOnExceptionsAndMuteConsole, const bool* const returnByValue, const bool* generatePreview, RefPtr<RemoteObject>& result, TypeBuilder::OptOutput<bool>* wasThrown)
 {
-    if (!isPaused() || m_currentCallStack.isEmpty()) {
+    if (!isPaused() || m_currentCallStack.isNull()) {
         *errorString = "Attempt to access callframe when debugger is not on pause";
         return;
     }
-    InjectedScript injectedScript = m_injectedScriptManager->injectedScriptForObjectId(callFrameId);
+    InjectedScript& injectedScript = m_injectedScriptManager->injectedScriptForObjectId(callFrameId);
     if (injectedScript.isEmpty()) {
         *errorString = "Inspected frame has gone";
         return;
     }
 
     ScriptDebugServer::PauseOnExceptionsState previousPauseOnExceptionsState = scriptDebugServer().pauseOnExceptionsState();
     if (doNotPauseOnExceptionsAndMuteConsole ? *doNotPauseOnExceptionsAndMuteConsole : false) {
         if (previousPauseOnExceptionsState != ScriptDebugServer::DontPauseOnExceptions)
             scriptDebugServer().setPauseOnExceptionsState(ScriptDebugServer::DontPauseOnExceptions);
         muteConsole();
     }
 
-    Vector<ScriptValue> asyncCallStacks;
-    const AsyncCallStackTracker::AsyncCallChain* asyncChain = m_asyncCallStackTracker.isEnabled() ? m_asyncCallStackTracker.currentAsyncCallChain() : 0;
-    if (asyncChain) {
-        const AsyncCallStackTracker::AsyncCallStackVector& callStacks = asyncChain->callStacks();
-        asyncCallStacks.resize(callStacks.size());
-        AsyncCallStackTracker::AsyncCallStackVector::const_iterator it = callStacks.begin();
-        for (size_t i = 0; it != callStacks.end(); ++it, ++i)
-            asyncCallStacks[i] = (*it)->callFrames();
-    }
-
+    Vector<StackTrace> asyncCallStacks;
+    collectAsyncCallStacks(asyncCallStacks);
     injectedScript.evaluateOnCallFrame(errorString, m_currentCallStack, asyncCallStacks, callFrameId, expression, objectGroup ? *objectGroup : "", includeCommandLineAPI ? *includeCommandLineAPI : false, returnByValue ? *returnByValue : false, generatePreview ? *generatePreview : false, &result, wasThrown);
 
     if (doNotPauseOnExceptionsAndMuteConsole ? *doNotPauseOnExceptionsAndMuteConsole : false) {
         unmuteConsole();
         if (scriptDebugServer().pauseOnExceptionsState() != previousPauseOnExceptionsState)
             scriptDebugServer().setPauseOnExceptionsState(previousPauseOnExceptionsState);
     }
 }
 
+void InspectorDebuggerAgent::getCompletionsOnCallFrame(ErrorString* errorString, const String& callFrameId, const String& expression, RefPtr<TypeBuilder::Array<String> >& result)
+{
+    if (!isPaused() || m_currentCallStack.isNull()) {
+        *errorString = "Attempt to access callframe when debugger is not on pause";
+        return;
+    }
+    InjectedScript& injectedScript = m_injectedScriptManager->injectedScriptForObjectId(callFrameId);
+    if (injectedScript.isEmpty()) {
+        *errorString = "Inspected frame has gone";
+        return;
+    }
+
+    ScriptDebugServer::PauseOnExceptionsState previousPauseOnExceptionsState = scriptDebugServer().pauseOnExceptionsState();
+    if (previousPauseOnExceptionsState != ScriptDebugServer::DontPauseOnExceptions)
+        scriptDebugServer().setPauseOnExceptionsState(ScriptDebugServer::DontPauseOnExceptions);
+    muteConsole();
+
+    Vector<StackTrace> asyncCallStacks;
+    collectAsyncCallStacks(asyncCallStacks);
+    injectedScript.getCompletionsOnCallFrame(errorString, m_currentCallStack, asyncCallStacks, callFrameId, expression, &result);
+
+    unmuteConsole();
+    if (scriptDebugServer().pauseOnExceptionsState() != previousPauseOnExceptionsState)
+        scriptDebugServer().setPauseOnExceptionsState(previousPauseOnExceptionsState);
+}
+
 void InspectorDebuggerAgent::compileScript(ErrorString* errorString, const String& expression, const String& sourceURL, const int* executionContextId, TypeBuilder::OptOutput<ScriptId>* scriptId, TypeBuilder::OptOutput<String>* syntaxErrorMessage)
 {
-    InjectedScript injectedScript = injectedScriptForEval(errorString, executionContextId);
+    InjectedScript& injectedScript = injectedScriptForEval(errorString, executionContextId);
     if (injectedScript.isEmpty()) {
         *errorString = "Inspected frame has gone";
         return;
     }
 
     String scriptIdValue;
     String exceptionMessage;
     scriptDebugServer().compileScript(injectedScript.scriptState(), expression, sourceURL, &scriptIdValue, &exceptionMessage);
     if (!scriptIdValue && !exceptionMessage) {
         *errorString = "Script compilation failed";
         return;
     }
     *syntaxErrorMessage = exceptionMessage;
     *scriptId = scriptIdValue;
 }
 
 void InspectorDebuggerAgent::runScript(ErrorString* errorString, const ScriptId& scriptId, const int* executionContextId, const String* const objectGroup, const bool* const doNotPauseOnExceptionsAndMuteConsole, RefPtr<RemoteObject>& result, TypeBuilder::OptOutput<bool>* wasThrown)
 {
-    InjectedScript injectedScript = injectedScriptForEval(errorString, executionContextId);
+    InjectedScript& injectedScript = injectedScriptForEval(errorString, executionContextId);
     if (injectedScript.isEmpty()) {
         *errorString = "Inspected frame has gone";
         return;
     }
 
     ScriptDebugServer::PauseOnExceptionsState previousPauseOnExceptionsState = scriptDebugServer().pauseOnExceptionsState();
     if (doNotPauseOnExceptionsAndMuteConsole && *doNotPauseOnExceptionsAndMuteConsole) {
         if (previousPauseOnExceptionsState != ScriptDebugServer::DontPauseOnExceptions)
             scriptDebugServer().setPauseOnExceptionsState(ScriptDebugServer::DontPauseOnExceptions);
         muteConsole();
@@ skipping 18 matching lines @@
             scriptDebugServer().setPauseOnExceptionsState(previousPauseOnExceptionsState);
     }
 }
 
 void InspectorDebuggerAgent::setOverlayMessage(ErrorString*, const String*)
 {
 }
 
 void InspectorDebuggerAgent::setVariableValue(ErrorString* errorString, int scopeNumber, const String& variableName, const RefPtr<JSONObject>& newValue, const String* callFrameId, const String* functionObjectId)
 {
-    InjectedScript injectedScript;
+    InjectedScript* injectedScript = 0;
     if (callFrameId) {
-        if (!isPaused() || m_currentCallStack.isEmpty()) {
+        if (!isPaused() || m_currentCallStack.isNull()) {
             *errorString = "Attempt to access callframe when debugger is not on pause";
             return;
         }
-        injectedScript = m_injectedScriptManager->injectedScriptForObjectId(*callFrameId);
-        if (injectedScript.isEmpty()) {
+        injectedScript = &m_injectedScriptManager->injectedScriptForObjectId(*callFrameId);
+        if (injectedScript->isEmpty()) {
             *errorString = "Inspected frame has gone";
             return;
         }
     } else if (functionObjectId) {
-        injectedScript = m_injectedScriptManager->injectedScriptForObjectId(*functionObjectId);
-        if (injectedScript.isEmpty()) {
+        injectedScript = &m_injectedScriptManager->injectedScriptForObjectId(*functionObjectId);
+        if (injectedScript->isEmpty()) {
             *errorString = "Function object id cannot be resolved";
             return;
         }
     } else {
         *errorString = "Either call frame or function object must be specified";
         return;
     }
     String newValueString = newValue->toJSONString();
-
-    injectedScript.setVariableValue(errorString, m_currentCallStack, callFrameId, functionObjectId, scopeNumber, variableName, newValueString);
+    ASSERT(injectedScript);
+    injectedScript->setVariableValue(errorString, m_currentCallStack, callFrameId, functionObjectId, scopeNumber, variableName, newValueString);
 }
 
 void InspectorDebuggerAgent::skipStackFrames(ErrorString* errorString, const String* pattern)
 {
     OwnPtr<ScriptRegexp> compiled;
     String patternValue = pattern ? *pattern : "";
     if (!patternValue.isEmpty()) {
         compiled = compileSkipCallFramePattern(patternValue);
         if (!compiled) {
             *errorString = "Invalid regular expression";
@@ skipping 14 matching lines @@
 {
     if (scriptDebugServer().pauseOnExceptionsState() != ScriptDebugServer::DontPauseOnExceptions) {
         RefPtr<JSONObject> directive = JSONObject::create();
         directive->setString("directiveText", directiveText);
         breakProgram(InspectorFrontend::Debugger::Reason::CSPViolation, directive.release());
     }
 }
 
 PassRefPtr<Array<CallFrame> > InspectorDebuggerAgent::currentCallFrames()
 {
-    if (!m_pausedScriptState || m_currentCallStack.isEmpty())
-        return Array<CallFrame>::create();
-    InjectedScript injectedScript = m_injectedScriptManager->injectedScriptFor(m_pausedScriptState.get());
+    if (!m_pausedScriptState || m_currentCallStack.isNull())
+        return Array<TypeBuilder::Debugger::CallFrame>::create();
+    InjectedScript& injectedScript = m_injectedScriptManager->injectedScriptFor(m_pausedScriptState.get());
     if (injectedScript.isEmpty()) {
         ASSERT_NOT_REACHED();
         return Array<CallFrame>::create();
     }
     return injectedScript.wrapCallFrames(m_currentCallStack, 0);
 }
 
-PassRefPtr<StackTrace> InspectorDebuggerAgent::currentAsyncStackTrace()
+PassRefPtr<WebCore::TypeBuilder::Debugger::StackTrace> InspectorDebuggerAgent::currentAsyncStackTrace()
 {
     if (!m_pausedScriptState || !m_asyncCallStackTracker.isEnabled())
         return nullptr;
-    InjectedScript injectedScript = m_injectedScriptManager->injectedScriptFor(m_pausedScriptState.get());
+    InjectedScript& injectedScript = m_injectedScriptManager->injectedScriptFor(m_pausedScriptState.get());
     if (injectedScript.isEmpty()) {
         ASSERT_NOT_REACHED();
         return nullptr;
     }
     const AsyncCallStackTracker::AsyncCallChain* chain = m_asyncCallStackTracker.currentAsyncCallChain();
     if (!chain)
         return nullptr;
     const AsyncCallStackTracker::AsyncCallStackVector& callStacks = chain->callStacks();
     if (callStacks.isEmpty())
         return nullptr;
-    RefPtr<StackTrace> result;
+    RefPtr<WebCore::TypeBuilder::Debugger::StackTrace> result;
     int asyncOrdinal = callStacks.size();
     for (AsyncCallStackTracker::AsyncCallStackVector::const_reverse_iterator it = callStacks.rbegin(); it != callStacks.rend(); ++it) {
-        RefPtr<StackTrace> next = StackTrace::create()
+        RefPtr<WebCore::TypeBuilder::Debugger::StackTrace> next = WebCore::TypeBuilder::Debugger::StackTrace::create()
             .setCallFrames(injectedScript.wrapCallFrames((*it)->callFrames(), asyncOrdinal--))
             .release();
         next->setDescription((*it)->description());
         if (result)
             next->setAsyncStackTrace(result.release());
         result.swap(next);
     }
     return result.release();
 }
 
@@ skipping 62 matching lines @@
         if (location)
             m_frontend->breakpointResolved(it->key, location);
     }
 }
 
 void InspectorDebuggerAgent::failedToParseSource(const String& url, const String& data, int firstLine, int errorLine, const String& errorMessage)
 {
     m_frontend->scriptFailedToParse(url, data, firstLine, errorLine, errorMessage);
 }
 
-void InspectorDebuggerAgent::didPause(ScriptState* scriptState, const ScriptValue& callFrames, const ScriptValue& exception, const Vector<String>& hitBreakpoints)
+void InspectorDebuggerAgent::didPause(ScriptState* scriptState, const StackTrace& callFrames, const ScriptValue& exception, const Vector<String>& hitBreakpoints)
 {
     ASSERT(scriptState && !m_pausedScriptState);
     m_pausedScriptState = scriptState;
     m_currentCallStack = callFrames;
 
     m_skipStepInCount = numberOfStepsBeforeStepOut;
 
     if (!exception.isEmpty()) {
-        InjectedScript injectedScript = m_injectedScriptManager->injectedScriptFor(scriptState);
+        InjectedScript& injectedScript = m_injectedScriptManager->injectedScriptFor(scriptState);
         if (!injectedScript.isEmpty()) {
             m_breakReason = InspectorFrontend::Debugger::Reason::Exception;
             m_breakAuxData = injectedScript.wrapObject(exception, InspectorDebuggerAgent::backtraceObjectGroup)->openAccessors();
             // m_breakAuxData might be null after this.
         }
     }
 
     RefPtr<Array<String> > hitBreakpointIds = Array<String>::create();
 
     for (Vector<String>::const_iterator i = hitBreakpoints.begin(); i != hitBreakpoints.end(); ++i) {
@@ skipping 15 matching lines @@
         scriptDebugServer().removeBreakpoint(m_continueToLocationBreakpointId);
         m_continueToLocationBreakpointId = "";
     }
     if (m_listener)
         m_listener->didPause();
 }
 
 void InspectorDebuggerAgent::didContinue()
 {
     m_pausedScriptState = nullptr;
-    m_currentCallStack = ScriptValue();
+    m_currentCallStack = StackTrace();
     clearBreakDetails();
     m_frontend->resumed();
 }
 
 bool InspectorDebuggerAgent::canBreakProgram()
 {
     return scriptDebugServer().canBreakProgram();
 }
 
 void InspectorDebuggerAgent::breakProgram(InspectorFrontend::Debugger::Reason::Enum breakReason, PassRefPtr<JSONObject> data)
 {
     if (m_skipAllPauses)
         return;
     m_breakReason = breakReason;
     m_breakAuxData = data;
     scriptDebugServer().breakProgram();
 }
 
 void InspectorDebuggerAgent::clear()
 {
     m_pausedScriptState = nullptr;
-    m_currentCallStack = ScriptValue();
+    m_currentCallStack = StackTrace();
     m_scripts.clear();
     m_breakpointIdToDebugServerBreakpointIds.clear();
     m_asyncCallStackTracker.clear();
     m_promiseTracker.clear();
     m_continueToLocationBreakpointId = String();
     clearBreakDetails();
     m_javaScriptPauseScheduled = false;
     ErrorString error;
     setOverlayMessage(&error, 0);
 }
@@ skipping 30 matching lines @@
     m_scripts.clear();
     m_breakpointIdToDebugServerBreakpointIds.clear();
     m_asyncCallStackTracker.clear();
     m_promiseTracker.clear();
     if (m_frontend)
         m_frontend->globalObjectCleared();
 }
 
 } // namespace WebCore