InjectedScript InjectedScriptManager::injectedScriptFor(ScriptState* inspectedScriptState)
{
v8::HandleScope handleScope;
v8::Local<v8::Context> context = inspectedScriptState->context();
v8::Context::Scope contextScope(context);
v8::Local<v8::Object> global = context->Global();
// Skip proxy object. The proxy object will survive page navigation while we need
// an object whose lifetime consides with that of the inspected context.
global = v8::Local<v8::Object>::Cast(global->GetPrototype());
v8::Handle<v8::String> key = V8HiddenPropertyName::devtoolsInjectedScript();
v8::Local<v8::Value> val = global->GetHiddenValue(key);
if (!val.IsEmpty() && val->IsObject())
return InjectedScript(ScriptObject(inspectedScriptState, v8::Local<v8::Object>::Cast(val)));
if (!canAccessInspectedWindow(inspectedScriptState))
return InjectedScript();
pair<long, ScriptObject> injectedScript = injectScript(injectedScriptSource(), inspectedScriptState);
InjectedScript result(injectedScript.second);
m_idToInjectedScript.set(injectedScript.first, result);
global->SetHiddenValue(key, injectedScript.second.v8Object());
return result;
}
PassRefPtr<SerializedScriptValue> InjectedScript::wrapForConsole(ScriptValue value)
{
ASSERT(!hasNoValue());
ScriptFunctionCall wrapFunction(m_injectedScriptObject, "wrapObjectForConsole");
wrapFunction.appendArgument(value);
wrapFunction.appendArgument(canAccessInspectedWindow());
bool hadException = false;
ScriptValue r = wrapFunction.call(hadException);
if (hadException)
return SerializedScriptValue::create("<exception>");
return r.serialize(m_injectedScriptObject.scriptState());
}
Node* InjectedScript::nodeForObjectId(const String& objectId)
{
if (isEmpty() || !canAccessInspectedWindow())
return 0;
ScriptFunctionCall function(injectedScriptObject(), "nodeForObjectId");
function.appendArgument(objectId);
bool hadException = false;
ScriptValue resultValue = callFunctionWithEvalEnabled(function, hadException);
ASSERT(!hadException);
return InjectedScriptHost::scriptValueAsNode(scriptState(), resultValue);
}
Node* InjectedScript::nodeForObjectId(const String& objectId)
{
if (hasNoValue() || !canAccessInspectedWindow())
return 0;
ScriptFunctionCall function(m_injectedScriptObject, "nodeForObjectId");
function.appendArgument(objectId);
bool hadException = false;
ScriptValue resultValue = function.call(hadException);
ASSERT(!hadException);
return InjectedScriptHost::scriptValueAsNode(resultValue);
}
PassRefPtr<TypeBuilder::Runtime::RemoteObject> InjectedScript::wrapObject(const ScriptValue& value, const String& groupName, bool generatePreview) const
{
ASSERT(!isEmpty());
ScriptFunctionCall wrapFunction(injectedScriptObject(), "wrapObject");
wrapFunction.appendArgument(value);
wrapFunction.appendArgument(groupName);
wrapFunction.appendArgument(canAccessInspectedWindow());
wrapFunction.appendArgument(generatePreview);
bool hadException = false;
ScriptValue r = callFunctionWithEvalEnabled(wrapFunction, hadException);
if (hadException)
return nullptr;
RefPtr<JSONObject> rawResult = toJSONValue(r)->asObject();
return TypeBuilder::Runtime::RemoteObject::runtimeCast(rawResult);
}
PassRefPtr<TypeBuilder::Runtime::RemoteObject> InjectedScript::wrapObject(ScriptValue value, const String& groupName) const
{
ASSERT(!hasNoValue());
ScriptFunctionCall wrapFunction(m_injectedScriptObject, "wrapObject");
wrapFunction.appendArgument(value);
wrapFunction.appendArgument(groupName);
wrapFunction.appendArgument(canAccessInspectedWindow());
bool hadException = false;
ScriptValue r = callFunctionWithEvalEnabled(wrapFunction, hadException);
if (hadException) {
return 0;
}
RefPtr<InspectorObject> rawResult = r.toInspectorValue(m_injectedScriptObject.scriptState())->asObject();
return TypeBuilder::Runtime::RemoteObject::runtimeCast(rawResult);
}
PassRefPtr<InspectorObject> InjectedScript::wrapObject(ScriptValue value, const String& groupName) const
{
ASSERT(!hasNoValue());
ScriptFunctionCall wrapFunction(m_injectedScriptObject, "wrapObject");
wrapFunction.appendArgument(value);
wrapFunction.appendArgument(groupName);
wrapFunction.appendArgument(canAccessInspectedWindow());
bool hadException = false;
ScriptValue r = callFunctionWithEvalEnabled(wrapFunction, hadException);
if (hadException) {
RefPtr<InspectorObject> result = InspectorObject::create();
result->setString("description", "<exception>");
return result;
}
return r.toInspectorValue(m_injectedScriptObject.scriptState())->asObject();
}
void InjectedScript::dispatch(const String& methodName, const String& arguments, RefPtr<InspectorValue>* result, bool* hadException)
{
ASSERT(!hasNoValue());
if (!canAccessInspectedWindow()) {
*hadException = true;
return;
}
ScriptFunctionCall function(m_injectedScriptObject, "dispatch");
function.appendArgument(methodName);
function.appendArgument(arguments);
*hadException = false;
ScriptValue resultValue = function.call(*hadException);
if (!*hadException)
*result = resultValue.toInspectorValue(m_injectedScriptObject.scriptState());
}
void InjectedScript::makeCall(ScriptFunctionCall& function, RefPtr<InspectorValue>* result)
{
if (hasNoValue() || !canAccessInspectedWindow()) {
*result = InspectorValue::null();
return;
}
bool hadException = false;
ScriptValue resultValue = function.call(hadException);
ASSERT(!hadException);
if (!hadException)
*result = resultValue.toInspectorValue(m_injectedScriptObject.scriptState());
else
*result = InspectorString::create("Exception while making a call.");
}
PassRefPtr<TypeBuilder::Runtime::RemoteObject> InjectedScript::wrapTable(const ScriptValue& table, const ScriptValue& columns) const
{
ASSERT(!isEmpty());
ScriptFunctionCall wrapFunction(injectedScriptObject(), "wrapTable");
wrapFunction.appendArgument(canAccessInspectedWindow());
wrapFunction.appendArgument(table);
if (columns.isEmpty())
wrapFunction.appendArgument(false);
else
wrapFunction.appendArgument(columns);
bool hadException = false;
ScriptValue r = callFunctionWithEvalEnabled(wrapFunction, hadException);
if (hadException)
return nullptr;
RefPtr<JSONObject> rawResult = toJSONValue(r)->asObject();
return TypeBuilder::Runtime::RemoteObject::runtimeCast(rawResult);
}
void InjectedScript::makeCall(ScriptFunctionCall& function, RefPtr<InspectorValue>* result)
{
if (hasNoValue() || !canAccessInspectedWindow()) {
*result = InspectorValue::null();
return;
}
bool hadException = false;
ScriptValue resultValue = callFunctionWithEvalEnabled(function, hadException);
ASSERT(!hadException);
if (!hadException) {
*result = resultValue.toInspectorValue(m_injectedScriptObject.scriptState());
if (!*result)
*result = InspectorString::create(String::format("Object has too long reference chain(must not be longer than %d)", InspectorValue::maxDepth));
} else
*result = InspectorString::create("Exception while making a call.");
}
InjectedScript InjectedScriptHost::injectedScriptFor(ScriptState* scriptState)
{
JSLock lock(SilenceAssertionsOnly);
JSDOMGlobalObject* globalObject = static_cast<JSDOMGlobalObject*>(scriptState->lexicalGlobalObject());
JSObject* injectedScript = globalObject->injectedScript();
if (injectedScript)
return InjectedScript(ScriptObject(scriptState, injectedScript));
if (!canAccessInspectedWindow(scriptState))
return InjectedScript();
ASSERT(!m_injectedScriptSource.isEmpty());
pair<long, ScriptObject> injectedScriptObject = injectScript(m_injectedScriptSource, scriptState);
globalObject->setInjectedScript(injectedScriptObject.second.jsObject());
InjectedScript result(injectedScriptObject.second);
m_idToInjectedScript.set(injectedScriptObject.first, result);
return result;
}
void InjectedScript::makeCall(ScriptFunctionCall& function, RefPtr<JSONValue>* result)
{
if (isEmpty() || !canAccessInspectedWindow()) {
*result = JSONValue::null();
return;
}
bool hadException = false;
ScriptValue resultValue = callFunctionWithEvalEnabled(function, hadException);
ASSERT(!hadException);
if (!hadException) {
*result = toJSONValue(resultValue);
if (!*result)
*result = JSONString::create(String::format("Object has too long reference chain(must not be longer than %d)", JSONValue::maxDepth));
} else {
*result = JSONString::create("Exception while making a call.");
}
}
