void InjectedScriptModule::ensureInjected(InjectedScriptManager* injectedScriptManager, InjectedScript injectedScript)
{
ASSERT(!injectedScript.hasNoValue());
if (injectedScript.hasNoValue())
return;
// FIXME: Make the InjectedScript a module itself.
JSC::APIEntryShim entryShim(injectedScript.scriptState());
Deprecated::ScriptFunctionCall function(injectedScript.injectedScriptObject(), ASCIILiteral("module"), injectedScriptManager->inspectorEnvironment().functionCallHandler());
function.appendArgument(name());
bool hadException = false;
Deprecated::ScriptValue resultValue = injectedScript.callFunctionWithEvalEnabled(function, hadException);
ASSERT(!hadException);
if (hadException || resultValue.hasNoValue() || !resultValue.isObject()) {
Deprecated::ScriptFunctionCall function(injectedScript.injectedScriptObject(), ASCIILiteral("injectModule"), injectedScriptManager->inspectorEnvironment().functionCallHandler());
function.appendArgument(name());
function.appendArgument(source());
function.appendArgument(host(injectedScriptManager, injectedScript.scriptState()));
resultValue = injectedScript.callFunctionWithEvalEnabled(function, hadException);
if (hadException || (returnsObject() && (resultValue.hasNoValue() || !resultValue.isObject()))) {
ASSERT_NOT_REACHED();
return;
}
}
if (returnsObject()) {
Deprecated::ScriptObject moduleObject(injectedScript.scriptState(), resultValue);
initialize(moduleObject, &injectedScriptManager->inspectorEnvironment());
}
}
void InjectedScriptModule::ensureInjected(InjectedScriptManager* injectedScriptManager, InjectedScript injectedScript)
{
ASSERT(!injectedScript.hasNoValue());
if (injectedScript.hasNoValue())
return;
// FIXME: Make the InjectedScript a module itself.
Deprecated::ScriptFunctionCall function(injectedScript.injectedScriptObject(), "module", WebCore::functionCallHandlerFromAnyThread);
function.appendArgument(name());
bool hadException = false;
Deprecated::ScriptValue resultValue = injectedScript.callFunctionWithEvalEnabled(function, hadException);
ASSERT(!hadException);
if (hadException || resultValue.hasNoValue() || !resultValue.isObject()) {
Deprecated::ScriptFunctionCall function(injectedScript.injectedScriptObject(), "injectModule", WebCore::functionCallHandlerFromAnyThread);
function.appendArgument(name());
function.appendArgument(source());
function.appendArgument(host(injectedScriptManager, injectedScript.scriptState()));
resultValue = injectedScript.callFunctionWithEvalEnabled(function, hadException);
if (hadException || (returnsObject() && (resultValue.hasNoValue() || !resultValue.isObject()))) {
ASSERT_NOT_REACHED();
return;
}
}
if (returnsObject()) {
Deprecated::ScriptObject moduleObject(injectedScript.scriptState(), resultValue);
initialize(moduleObject, injectedScriptManager->inspectedStateAccessCheck());
}
}
RefPtr<InspectorObject> InspectorDebuggerAgent::buildExceptionPauseReason(const Deprecated::ScriptValue& exception, const InjectedScript& injectedScript)
{
ASSERT(!exception.hasNoValue());
if (exception.hasNoValue())
return nullptr;
ASSERT(!injectedScript.hasNoValue());
if (injectedScript.hasNoValue())
return nullptr;
return injectedScript.wrapObject(exception, InspectorDebuggerAgent::backtraceObjectGroup)->openAccessors();
}
void InspectorDebuggerAgent::didPause(JSC::ExecState* scriptState, const Deprecated::ScriptValue& callFrames, const Deprecated::ScriptValue& exception)
{
ASSERT(scriptState && !m_pausedScriptState);
m_pausedScriptState = scriptState;
m_currentCallStack = callFrames;
if (!exception.hasNoValue()) {
InjectedScript injectedScript = m_injectedScriptManager->injectedScriptFor(scriptState);
if (!injectedScript.hasNoValue()) {
m_breakReason = InspectorDebuggerFrontendDispatcher::Reason::Exception;
m_breakAuxData = injectedScript.wrapObject(exception, InspectorDebuggerAgent::backtraceObjectGroup)->openAccessors();
// m_breakAuxData might be null after this.
}
}
m_frontendDispatcher->paused(currentCallFrames(), m_breakReason, m_breakAuxData);
m_javaScriptPauseScheduled = false;
if (m_continueToLocationBreakpointID != JSC::noBreakpointID) {
scriptDebugServer().removeBreakpoint(m_continueToLocationBreakpointID);
m_continueToLocationBreakpointID = JSC::noBreakpointID;
}
if (m_listener)
m_listener->didPause();
}
Deprecated::ScriptObject InjectedScriptCanvasModule::callWrapContextFunction(const String& functionName, const Deprecated::ScriptObject& context)
{
Deprecated::ScriptFunctionCall function(injectedScriptObject(), functionName, WebCore::functionCallHandlerFromAnyThread);
function.appendArgument(context);
bool hadException = false;
Deprecated::ScriptValue resultValue = callFunctionWithEvalEnabled(function, hadException);
if (hadException || resultValue.hasNoValue() || !resultValue.isObject()) {
ASSERT_NOT_REACHED();
return Deprecated::ScriptObject();
}
return Deprecated::ScriptObject(context.scriptState(), resultValue);
}
JSValue JSCommandLineAPIHost::inspectedObject(ExecState* exec)
{
CommandLineAPIHost::InspectableObject* object = impl().inspectedObject();
if (!object)
return jsUndefined();
JSLockHolder lock(exec);
Deprecated::ScriptValue scriptValue = object->get(exec);
if (scriptValue.hasNoValue())
return jsUndefined();
return scriptValue.jsValue();
}
void InspectorHeapProfilerAgent::getHeapObjectId(ErrorString* errorString, const String& objectId, String* heapSnapshotObjectId)
{
InjectedScript injectedScript = m_injectedScriptManager->injectedScriptForObjectId(objectId);
if (injectedScript.hasNoValue()) {
*errorString = "Inspected context has gone";
return;
}
Deprecated::ScriptValue value = injectedScript.findObjectById(objectId);
if (value.hasNoValue() || value.isUndefined()) {
*errorString = "Object with given id not found";
return;
}
unsigned id = ScriptProfiler::getHeapObjectId(value);
*heapSnapshotObjectId = String::number(id);
}
JSValue JSCommandLineAPIHost::inspectedObject(ExecState* exec)
{
if (exec->argumentCount() < 1)
return jsUndefined();
CommandLineAPIHost::InspectableObject* object = impl().inspectedObject(exec->uncheckedArgument(0).toInt32(exec));
if (!object)
return jsUndefined();
JSLockHolder lock(exec);
Deprecated::ScriptValue scriptValue = object->get(exec);
if (scriptValue.hasNoValue())
return jsUndefined();
return scriptValue.jsValue();
}
PassRefPtr<Inspector::TypeBuilder::Runtime::RemoteObject> InjectedScript::wrapTable(const Deprecated::ScriptValue& table, const Deprecated::ScriptValue& columns) const
{
ASSERT(!hasNoValue());
Deprecated::ScriptFunctionCall wrapFunction(injectedScriptObject(), ASCIILiteral("wrapTable"), inspectorEnvironment()->functionCallHandler());
wrapFunction.appendArgument(hasAccessToInspectedScriptState());
wrapFunction.appendArgument(table);
if (columns.hasNoValue())
wrapFunction.appendArgument(false);
else
wrapFunction.appendArgument(columns);
bool hadException = false;
Deprecated::ScriptValue r = callFunctionWithEvalEnabled(wrapFunction, hadException);
if (hadException)
return nullptr;
RefPtr<InspectorObject> rawResult = r.toInspectorValue(scriptState())->asObject();
return Inspector::TypeBuilder::Runtime::RemoteObject::runtimeCast(rawResult);
}
JSValue JSMessageEvent::data(ExecState* exec) const
{
if (JSValue cachedValue = m_data.get())
return cachedValue;
MessageEvent& event = impl();
JSValue result;
switch (event.dataType()) {
case MessageEvent::DataTypeScriptValue: {
Deprecated::ScriptValue scriptValue = event.dataAsScriptValue();
if (scriptValue.hasNoValue())
result = jsNull();
else
result = scriptValue.jsValue();
break;
}
case MessageEvent::DataTypeSerializedScriptValue:
if (RefPtr<SerializedScriptValue> serializedValue = event.dataAsSerializedScriptValue()) {
MessagePortArray ports = impl().ports();
// FIXME: Why does this suppress exceptions?
result = serializedValue->deserialize(exec, globalObject(), &ports, NonThrowing);
} else
result = jsNull();
break;
case MessageEvent::DataTypeString:
result = jsStringWithCache(exec, event.dataAsString());
break;
case MessageEvent::DataTypeBlob:
result = toJS(exec, globalObject(), event.dataAsBlob());
break;
case MessageEvent::DataTypeArrayBuffer:
result = toJS(exec, globalObject(), event.dataAsArrayBuffer());
break;
}
// Save the result so we don't have to deserialize the value again.
const_cast<JSMessageEvent*>(this)->m_data.set(exec->vm(), this, result);
return result;
}
void WorkerGlobalScope::importScripts(const Vector<String>& urls, ExceptionCode& ec)
{
ASSERT(contentSecurityPolicy());
ec = 0;
Vector<String>::const_iterator urlsEnd = urls.end();
Vector<URL> completedURLs;
for (Vector<String>::const_iterator it = urls.begin(); it != urlsEnd; ++it) {
const URL& url = scriptExecutionContext()->completeURL(*it);
if (!url.isValid()) {
ec = SYNTAX_ERR;
return;
}
completedURLs.append(url);
}
Vector<URL>::const_iterator end = completedURLs.end();
for (Vector<URL>::const_iterator it = completedURLs.begin(); it != end; ++it) {
Ref<WorkerScriptLoader> scriptLoader = WorkerScriptLoader::create();
scriptLoader->loadSynchronously(scriptExecutionContext(), *it, AllowCrossOriginRequests);
// If the fetching attempt failed, throw a NETWORK_ERR exception and abort all these steps.
if (scriptLoader->failed()) {
ec = XMLHttpRequestException::NETWORK_ERR;
return;
}
InspectorInstrumentation::scriptImported(scriptExecutionContext(), scriptLoader->identifier(), scriptLoader->script());
Deprecated::ScriptValue exception;
m_script->evaluate(ScriptSourceCode(scriptLoader->script(), scriptLoader->responseURL()), &exception);
if (!exception.hasNoValue()) {
m_script->setException(exception);
return;
}
}
}
void InspectorDebuggerAgent::didPause(JSC::ExecState* scriptState, const Deprecated::ScriptValue& callFrames, const Deprecated::ScriptValue& exceptionOrCaughtValue)
{
ASSERT(scriptState && !m_pausedScriptState);
m_pausedScriptState = scriptState;
m_currentCallStack = callFrames;
InjectedScript injectedScript = m_injectedScriptManager->injectedScriptFor(scriptState);
// If a high level pause pause reason is not already set, try to infer a reason from the debugger.
if (m_breakReason == DebuggerFrontendDispatcher::Reason::Other) {
switch (scriptDebugServer().reasonForPause()) {
case JSC::Debugger::PausedForBreakpoint: {
JSC::BreakpointID debuggerBreakpointId = scriptDebugServer().pausingBreakpointID();
if (debuggerBreakpointId != m_continueToLocationBreakpointID) {
m_breakReason = DebuggerFrontendDispatcher::Reason::Breakpoint;
m_breakAuxData = buildBreakpointPauseReason(debuggerBreakpointId);
}
break;
}
case JSC::Debugger::PausedForDebuggerStatement:
m_breakReason = DebuggerFrontendDispatcher::Reason::DebuggerStatement;
m_breakAuxData = nullptr;
break;
case JSC::Debugger::PausedForException:
m_breakReason = DebuggerFrontendDispatcher::Reason::Exception;
m_breakAuxData = buildExceptionPauseReason(exceptionOrCaughtValue, injectedScript);
break;
case JSC::Debugger::PausedAtStatement:
case JSC::Debugger::PausedAfterCall:
case JSC::Debugger::PausedBeforeReturn:
case JSC::Debugger::PausedAtStartOfProgram:
case JSC::Debugger::PausedAtEndOfProgram:
// Pause was just stepping. Nothing to report.
break;
case JSC::Debugger::NotPaused:
ASSERT_NOT_REACHED();
break;
}
}
// Set $exception to the exception or caught value.
if (!exceptionOrCaughtValue.hasNoValue() && !injectedScript.hasNoValue()) {
injectedScript.setExceptionValue(exceptionOrCaughtValue);
m_hasExceptionValue = true;
}
m_frontendDispatcher->paused(currentCallFrames(injectedScript), m_breakReason, m_breakAuxData);
m_javaScriptPauseScheduled = false;
if (m_continueToLocationBreakpointID != JSC::noBreakpointID) {
scriptDebugServer().removeBreakpoint(m_continueToLocationBreakpointID);
m_continueToLocationBreakpointID = JSC::noBreakpointID;
}
if (m_listener)
m_listener->didPause();
RefPtr<Stopwatch> stopwatch = m_injectedScriptManager->inspectorEnvironment().executionStopwatch();
if (stopwatch && stopwatch->isActive()) {
stopwatch->stop();
m_didPauseStopwatch = true;
}
}
