blob: e660a61aebfa64622a280b95ca5c55db59b42b33 [file] [log] [blame]
/*
* Copyright (C) 2012 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:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY 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 "src/inspector/injected-script.h"
#include <cmath>
#include <unordered_set>
#include "src/inspector/custom-preview.h"
#include "src/inspector/inspected-context.h"
#include "src/inspector/protocol/Protocol.h"
#include "src/inspector/remote-object-id.h"
#include "src/inspector/string-util.h"
#include "src/inspector/v8-console.h"
#include "src/inspector/v8-inspector-impl.h"
#include "src/inspector/v8-inspector-session-impl.h"
#include "src/inspector/v8-stack-trace-impl.h"
#include "src/inspector/v8-value-utils.h"
#include "src/inspector/value-mirror.h"
#include "include/v8-inspector.h"
namespace v8_inspector {
namespace {
static const char kGlobalHandleLabel[] = "DevTools console";
static bool isResolvableNumberLike(String16 query) {
return query == "Infinity" || query == "-Infinity" || query == "NaN";
}
} // namespace
using protocol::Array;
using protocol::Maybe;
using protocol::Runtime::InternalPropertyDescriptor;
using protocol::Runtime::PrivatePropertyDescriptor;
using protocol::Runtime::PropertyDescriptor;
using protocol::Runtime::RemoteObject;
class InjectedScript::ProtocolPromiseHandler {
public:
static bool add(V8InspectorSessionImpl* session,
v8::Local<v8::Context> context, v8::Local<v8::Value> value,
int executionContextId, const String16& objectGroup,
WrapMode wrapMode, EvaluateCallback* callback) {
v8::Local<v8::Promise::Resolver> resolver;
if (!v8::Promise::Resolver::New(context).ToLocal(&resolver)) {
callback->sendFailure(Response::InternalError());
return false;
}
if (!resolver->Resolve(context, value).FromMaybe(false)) {
callback->sendFailure(Response::InternalError());
return false;
}
v8::Local<v8::Promise> promise = resolver->GetPromise();
V8InspectorImpl* inspector = session->inspector();
ProtocolPromiseHandler* handler = new ProtocolPromiseHandler(
session, executionContextId, objectGroup, wrapMode, callback);
v8::Local<v8::Value> wrapper = handler->m_wrapper.Get(inspector->isolate());
v8::Local<v8::Function> thenCallbackFunction =
v8::Function::New(context, thenCallback, wrapper, 0,
v8::ConstructorBehavior::kThrow)
.ToLocalChecked();
if (promise->Then(context, thenCallbackFunction).IsEmpty()) {
callback->sendFailure(Response::InternalError());
return false;
}
v8::Local<v8::Function> catchCallbackFunction =
v8::Function::New(context, catchCallback, wrapper, 0,
v8::ConstructorBehavior::kThrow)
.ToLocalChecked();
if (promise->Catch(context, catchCallbackFunction).IsEmpty()) {
callback->sendFailure(Response::InternalError());
return false;
}
return true;
}
private:
static void thenCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
ProtocolPromiseHandler* handler = static_cast<ProtocolPromiseHandler*>(
info.Data().As<v8::External>()->Value());
DCHECK(handler);
v8::Local<v8::Value> value =
info.Length() > 0
? info[0]
: v8::Local<v8::Value>::Cast(v8::Undefined(info.GetIsolate()));
handler->thenCallback(value);
delete handler;
}
static void catchCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
ProtocolPromiseHandler* handler = static_cast<ProtocolPromiseHandler*>(
info.Data().As<v8::External>()->Value());
DCHECK(handler);
v8::Local<v8::Value> value =
info.Length() > 0
? info[0]
: v8::Local<v8::Value>::Cast(v8::Undefined(info.GetIsolate()));
handler->catchCallback(value);
delete handler;
}
ProtocolPromiseHandler(V8InspectorSessionImpl* session,
int executionContextId, const String16& objectGroup,
WrapMode wrapMode, EvaluateCallback* callback)
: m_inspector(session->inspector()),
m_sessionId(session->sessionId()),
m_contextGroupId(session->contextGroupId()),
m_executionContextId(executionContextId),
m_objectGroup(objectGroup),
m_wrapMode(wrapMode),
m_callback(std::move(callback)),
m_wrapper(m_inspector->isolate(),
v8::External::New(m_inspector->isolate(), this)) {
m_wrapper.SetWeak(this, cleanup, v8::WeakCallbackType::kParameter);
}
static void cleanup(
const v8::WeakCallbackInfo<ProtocolPromiseHandler>& data) {
if (!data.GetParameter()->m_wrapper.IsEmpty()) {
data.GetParameter()->m_wrapper.Reset();
data.SetSecondPassCallback(cleanup);
} else {
data.GetParameter()->sendPromiseCollected();
delete data.GetParameter();
}
}
void thenCallback(v8::Local<v8::Value> result) {
V8InspectorSessionImpl* session =
m_inspector->sessionById(m_contextGroupId, m_sessionId);
if (!session) return;
InjectedScript::ContextScope scope(session, m_executionContextId);
Response response = scope.initialize();
if (!response.isSuccess()) return;
if (m_objectGroup == "console") {
scope.injectedScript()->setLastEvaluationResult(result);
}
std::unique_ptr<EvaluateCallback> callback =
scope.injectedScript()->takeEvaluateCallback(m_callback);
if (!callback) return;
std::unique_ptr<protocol::Runtime::RemoteObject> wrappedValue;
response = scope.injectedScript()->wrapObject(result, m_objectGroup,
m_wrapMode, &wrappedValue);
if (!response.isSuccess()) {
callback->sendFailure(response);
return;
}
callback->sendSuccess(std::move(wrappedValue),
Maybe<protocol::Runtime::ExceptionDetails>());
}
void catchCallback(v8::Local<v8::Value> result) {
V8InspectorSessionImpl* session =
m_inspector->sessionById(m_contextGroupId, m_sessionId);
if (!session) return;
InjectedScript::ContextScope scope(session, m_executionContextId);
Response response = scope.initialize();
if (!response.isSuccess()) return;
std::unique_ptr<EvaluateCallback> callback =
scope.injectedScript()->takeEvaluateCallback(m_callback);
if (!callback) return;
std::unique_ptr<protocol::Runtime::RemoteObject> wrappedValue;
response = scope.injectedScript()->wrapObject(result, m_objectGroup,
m_wrapMode, &wrappedValue);
if (!response.isSuccess()) {
callback->sendFailure(response);
return;
}
String16 message;
std::unique_ptr<V8StackTraceImpl> stack;
v8::Isolate* isolate = session->inspector()->isolate();
if (result->IsNativeError()) {
message = " " + toProtocolString(
isolate,
result->ToDetailString(isolate->GetCurrentContext())
.ToLocalChecked());
v8::Local<v8::StackTrace> stackTrace = v8::debug::GetDetailedStackTrace(
isolate, v8::Local<v8::Object>::Cast(result));
if (!stackTrace.IsEmpty()) {
stack = m_inspector->debugger()->createStackTrace(stackTrace);
}
}
if (!stack) {
stack = m_inspector->debugger()->captureStackTrace(true);
}
std::unique_ptr<protocol::Runtime::ExceptionDetails> exceptionDetails =
protocol::Runtime::ExceptionDetails::create()
.setExceptionId(m_inspector->nextExceptionId())
.setText("Uncaught (in promise)" + message)
.setLineNumber(stack && !stack->isEmpty() ? stack->topLineNumber()
: 0)
.setColumnNumber(
stack && !stack->isEmpty() ? stack->topColumnNumber() : 0)
.setException(wrappedValue->clone())
.build();
if (stack)
exceptionDetails->setStackTrace(
stack->buildInspectorObjectImpl(m_inspector->debugger()));
if (stack && !stack->isEmpty())
exceptionDetails->setScriptId(toString16(stack->topScriptId()));
callback->sendSuccess(std::move(wrappedValue), std::move(exceptionDetails));
}
void sendPromiseCollected() {
V8InspectorSessionImpl* session =
m_inspector->sessionById(m_contextGroupId, m_sessionId);
if (!session) return;
InjectedScript::ContextScope scope(session, m_executionContextId);
Response response = scope.initialize();
if (!response.isSuccess()) return;
std::unique_ptr<EvaluateCallback> callback =
scope.injectedScript()->takeEvaluateCallback(m_callback);
if (!callback) return;
callback->sendFailure(Response::Error("Promise was collected"));
}
V8InspectorImpl* m_inspector;
int m_sessionId;
int m_contextGroupId;
int m_executionContextId;
String16 m_objectGroup;
WrapMode m_wrapMode;
EvaluateCallback* m_callback;
v8::Global<v8::External> m_wrapper;
};
InjectedScript::InjectedScript(InspectedContext* context, int sessionId)
: m_context(context), m_sessionId(sessionId) {}
InjectedScript::~InjectedScript() { discardEvaluateCallbacks(); }
namespace {
class PropertyAccumulator : public ValueMirror::PropertyAccumulator {
public:
explicit PropertyAccumulator(std::vector<PropertyMirror>* mirrors)
: m_mirrors(mirrors) {}
bool Add(PropertyMirror mirror) override {
m_mirrors->push_back(std::move(mirror));
return true;
}
private:
std::vector<PropertyMirror>* m_mirrors;
};
} // anonymous namespace
Response InjectedScript::getProperties(
v8::Local<v8::Object> object, const String16& groupName, bool ownProperties,
bool accessorPropertiesOnly, WrapMode wrapMode,
std::unique_ptr<Array<PropertyDescriptor>>* properties,
Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails) {
v8::HandleScope handles(m_context->isolate());
v8::Local<v8::Context> context = m_context->context();
v8::Isolate* isolate = m_context->isolate();
int sessionId = m_sessionId;
v8::TryCatch tryCatch(isolate);
*properties = Array<PropertyDescriptor>::create();
std::vector<PropertyMirror> mirrors;
PropertyAccumulator accumulator(&mirrors);
if (!ValueMirror::getProperties(context, object, ownProperties,
accessorPropertiesOnly, &accumulator)) {
return createExceptionDetails(tryCatch, groupName, wrapMode,
exceptionDetails);
}
for (const PropertyMirror& mirror : mirrors) {
std::unique_ptr<PropertyDescriptor> descriptor =
PropertyDescriptor::create()
.setName(mirror.name)
.setConfigurable(mirror.configurable)
.setEnumerable(mirror.enumerable)
.setIsOwn(mirror.isOwn)
.build();
Response response;
std::unique_ptr<RemoteObject> remoteObject;
if (mirror.value) {
response = wrapObjectMirror(*mirror.value, groupName, wrapMode,
v8::MaybeLocal<v8::Value>(),
kMaxCustomPreviewDepth, &remoteObject);
if (!response.isSuccess()) return response;
descriptor->setValue(std::move(remoteObject));
descriptor->setWritable(mirror.writable);
}
if (mirror.getter) {
response =
mirror.getter->buildRemoteObject(context, wrapMode, &remoteObject);
if (!response.isSuccess()) return response;
response =
bindRemoteObjectIfNeeded(sessionId, context, mirror.getter->v8Value(),
groupName, remoteObject.get());
if (!response.isSuccess()) return response;
descriptor->setGet(std::move(remoteObject));
}
if (mirror.setter) {
response =
mirror.setter->buildRemoteObject(context, wrapMode, &remoteObject);
if (!response.isSuccess()) return response;
response =
bindRemoteObjectIfNeeded(sessionId, context, mirror.setter->v8Value(),
groupName, remoteObject.get());
if (!response.isSuccess()) return response;
descriptor->setSet(std::move(remoteObject));
}
if (mirror.symbol) {
response =
mirror.symbol->buildRemoteObject(context, wrapMode, &remoteObject);
if (!response.isSuccess()) return response;
response =
bindRemoteObjectIfNeeded(sessionId, context, mirror.symbol->v8Value(),
groupName, remoteObject.get());
if (!response.isSuccess()) return response;
descriptor->setSymbol(std::move(remoteObject));
}
if (mirror.exception) {
response =
mirror.exception->buildRemoteObject(context, wrapMode, &remoteObject);
if (!response.isSuccess()) return response;
response = bindRemoteObjectIfNeeded(sessionId, context,
mirror.exception->v8Value(),
groupName, remoteObject.get());
if (!response.isSuccess()) return response;
descriptor->setValue(std::move(remoteObject));
descriptor->setWasThrown(true);
}
(*properties)->addItem(std::move(descriptor));
}
return Response::OK();
}
Response InjectedScript::getInternalAndPrivateProperties(
v8::Local<v8::Value> value, const String16& groupName,
std::unique_ptr<protocol::Array<InternalPropertyDescriptor>>*
internalProperties,
std::unique_ptr<protocol::Array<PrivatePropertyDescriptor>>*
privateProperties) {
*internalProperties = protocol::Array<InternalPropertyDescriptor>::create();
*privateProperties = protocol::Array<PrivatePropertyDescriptor>::create();
if (!value->IsObject()) return Response::OK();
v8::Local<v8::Object> value_obj = value.As<v8::Object>();
v8::Local<v8::Context> context = m_context->context();
int sessionId = m_sessionId;
std::vector<InternalPropertyMirror> internalPropertiesWrappers;
ValueMirror::getInternalProperties(m_context->context(), value_obj,
&internalPropertiesWrappers);
for (const auto& internalProperty : internalPropertiesWrappers) {
std::unique_ptr<RemoteObject> remoteObject;
Response response = internalProperty.value->buildRemoteObject(
m_context->context(), WrapMode::kNoPreview, &remoteObject);
if (!response.isSuccess()) return response;
response = bindRemoteObjectIfNeeded(sessionId, context,
internalProperty.value->v8Value(),
groupName, remoteObject.get());
if (!response.isSuccess()) return response;
(*internalProperties)
->addItem(InternalPropertyDescriptor::create()
.setName(internalProperty.name)
.setValue(std::move(remoteObject))
.build());
}
std::vector<PrivatePropertyMirror> privatePropertyWrappers =
ValueMirror::getPrivateProperties(m_context->context(), value_obj);
for (const auto& privateProperty : privatePropertyWrappers) {
std::unique_ptr<RemoteObject> remoteObject;
Response response = privateProperty.value->buildRemoteObject(
m_context->context(), WrapMode::kNoPreview, &remoteObject);
if (!response.isSuccess()) return response;
response = bindRemoteObjectIfNeeded(sessionId, context,
privateProperty.value->v8Value(),
groupName, remoteObject.get());
if (!response.isSuccess()) return response;
(*privateProperties)
->addItem(PrivatePropertyDescriptor::create()
.setName(privateProperty.name)
.setValue(std::move(remoteObject))
.build());
}
return Response::OK();
}
void InjectedScript::releaseObject(const String16& objectId) {
std::unique_ptr<protocol::Value> parsedObjectId =
protocol::StringUtil::parseJSON(objectId);
if (!parsedObjectId) return;
protocol::DictionaryValue* object =
protocol::DictionaryValue::cast(parsedObjectId.get());
if (!object) return;
int boundId = 0;
if (!object->getInteger("id", &boundId)) return;
unbindObject(boundId);
}
Response InjectedScript::wrapObject(
v8::Local<v8::Value> value, const String16& groupName, WrapMode wrapMode,
std::unique_ptr<protocol::Runtime::RemoteObject>* result) {
return wrapObject(value, groupName, wrapMode, v8::MaybeLocal<v8::Value>(),
kMaxCustomPreviewDepth, result);
}
Response InjectedScript::wrapObject(
v8::Local<v8::Value> value, const String16& groupName, WrapMode wrapMode,
v8::MaybeLocal<v8::Value> customPreviewConfig, int maxCustomPreviewDepth,
std::unique_ptr<protocol::Runtime::RemoteObject>* result) {
v8::Local<v8::Context> context = m_context->context();
v8::Context::Scope contextScope(context);
std::unique_ptr<ValueMirror> mirror = ValueMirror::create(context, value);
if (!mirror) return Response::InternalError();
return wrapObjectMirror(*mirror, groupName, wrapMode, customPreviewConfig,
maxCustomPreviewDepth, result);
}
Response InjectedScript::wrapObjectMirror(
const ValueMirror& mirror, const String16& groupName, WrapMode wrapMode,
v8::MaybeLocal<v8::Value> customPreviewConfig, int maxCustomPreviewDepth,
std::unique_ptr<protocol::Runtime::RemoteObject>* result) {
int customPreviewEnabled = m_customPreviewEnabled;
int sessionId = m_sessionId;
v8::Local<v8::Context> context = m_context->context();
v8::Context::Scope contextScope(context);
Response response = mirror.buildRemoteObject(context, wrapMode, result);
if (!response.isSuccess()) return response;
v8::Local<v8::Value> value = mirror.v8Value();
response = bindRemoteObjectIfNeeded(sessionId, context, value, groupName,
result->get());
if (!response.isSuccess()) return response;
if (customPreviewEnabled && value->IsObject()) {
std::unique_ptr<protocol::Runtime::CustomPreview> customPreview;
generateCustomPreview(sessionId, groupName, context, value.As<v8::Object>(),
customPreviewConfig, maxCustomPreviewDepth,
&customPreview);
if (customPreview) (*result)->setCustomPreview(std::move(customPreview));
}
return Response::OK();
}
std::unique_ptr<protocol::Runtime::RemoteObject> InjectedScript::wrapTable(
v8::Local<v8::Object> table, v8::MaybeLocal<v8::Array> maybeColumns) {
using protocol::Runtime::RemoteObject;
using protocol::Runtime::ObjectPreview;
using protocol::Runtime::PropertyPreview;
using protocol::Array;
v8::Isolate* isolate = m_context->isolate();
v8::HandleScope handles(isolate);
v8::Local<v8::Context> context = m_context->context();
std::unique_ptr<RemoteObject> remoteObject;
Response response =
wrapObject(table, "console", WrapMode::kNoPreview, &remoteObject);
if (!remoteObject || !response.isSuccess()) return nullptr;
auto mirror = ValueMirror::create(context, table);
std::unique_ptr<ObjectPreview> preview;
int limit = 1000;
mirror->buildObjectPreview(context, true /* generatePreviewForTable */,
&limit, &limit, &preview);
if (!preview) return nullptr;
Array<PropertyPreview>* columns = preview->getProperties();
std::unordered_set<String16> selectedColumns;
v8::Local<v8::Array> v8Columns;
if (maybeColumns.ToLocal(&v8Columns)) {
for (uint32_t i = 0; i < v8Columns->Length(); ++i) {
v8::Local<v8::Value> column;
if (v8Columns->Get(context, i).ToLocal(&column) && column->IsString()) {
selectedColumns.insert(
toProtocolString(isolate, column.As<v8::String>()));
}
}
}
if (!selectedColumns.empty()) {
for (size_t i = 0; i < columns->length(); ++i) {
ObjectPreview* columnPreview = columns->get(i)->getValuePreview(nullptr);
if (!columnPreview) continue;
std::unique_ptr<Array<PropertyPreview>> filtered =
Array<PropertyPreview>::create();
Array<PropertyPreview>* columns = columnPreview->getProperties();
for (size_t j = 0; j < columns->length(); ++j) {
PropertyPreview* property = columns->get(j);
if (selectedColumns.find(property->getName()) !=
selectedColumns.end()) {
filtered->addItem(property->clone());
}
}
columnPreview->setProperties(std::move(filtered));
}
}
remoteObject->setPreview(std::move(preview));
return remoteObject;
}
void InjectedScript::addPromiseCallback(
V8InspectorSessionImpl* session, v8::MaybeLocal<v8::Value> value,
const String16& objectGroup, WrapMode wrapMode,
std::unique_ptr<EvaluateCallback> callback) {
if (value.IsEmpty()) {
callback->sendFailure(Response::InternalError());
return;
}
v8::MicrotasksScope microtasksScope(m_context->isolate(),
v8::MicrotasksScope::kRunMicrotasks);
if (ProtocolPromiseHandler::add(
session, m_context->context(), value.ToLocalChecked(),
m_context->contextId(), objectGroup, wrapMode, callback.get())) {
m_evaluateCallbacks.insert(callback.release());
}
}
void InjectedScript::discardEvaluateCallbacks() {
for (auto& callback : m_evaluateCallbacks) {
callback->sendFailure(Response::Error("Execution context was destroyed."));
delete callback;
}
m_evaluateCallbacks.clear();
}
std::unique_ptr<EvaluateCallback> InjectedScript::takeEvaluateCallback(
EvaluateCallback* callback) {
auto it = m_evaluateCallbacks.find(callback);
if (it == m_evaluateCallbacks.end()) return nullptr;
std::unique_ptr<EvaluateCallback> value(*it);
m_evaluateCallbacks.erase(it);
return value;
}
Response InjectedScript::findObject(const RemoteObjectId& objectId,
v8::Local<v8::Value>* outObject) const {
auto it = m_idToWrappedObject.find(objectId.id());
if (it == m_idToWrappedObject.end())
return Response::Error("Could not find object with given id");
*outObject = it->second.Get(m_context->isolate());
return Response::OK();
}
String16 InjectedScript::objectGroupName(const RemoteObjectId& objectId) const {
if (objectId.id() <= 0) return String16();
auto it = m_idToObjectGroupName.find(objectId.id());
return it != m_idToObjectGroupName.end() ? it->second : String16();
}
void InjectedScript::releaseObjectGroup(const String16& objectGroup) {
if (objectGroup == "console") m_lastEvaluationResult.Reset();
if (objectGroup.isEmpty()) return;
auto it = m_nameToObjectGroup.find(objectGroup);
if (it == m_nameToObjectGroup.end()) return;
for (int id : it->second) unbindObject(id);
m_nameToObjectGroup.erase(it);
}
void InjectedScript::setCustomObjectFormatterEnabled(bool enabled) {
m_customPreviewEnabled = enabled;
}
v8::Local<v8::Value> InjectedScript::lastEvaluationResult() const {
if (m_lastEvaluationResult.IsEmpty())
return v8::Undefined(m_context->isolate());
return m_lastEvaluationResult.Get(m_context->isolate());
}
void InjectedScript::setLastEvaluationResult(v8::Local<v8::Value> result) {
m_lastEvaluationResult.Reset(m_context->isolate(), result);
m_lastEvaluationResult.AnnotateStrongRetainer(kGlobalHandleLabel);
}
Response InjectedScript::resolveCallArgument(
protocol::Runtime::CallArgument* callArgument,
v8::Local<v8::Value>* result) {
if (callArgument->hasObjectId()) {
std::unique_ptr<RemoteObjectId> remoteObjectId;
Response response =
RemoteObjectId::parse(callArgument->getObjectId(""), &remoteObjectId);
if (!response.isSuccess()) return response;
if (remoteObjectId->contextId() != m_context->contextId())
return Response::Error(
"Argument should belong to the same JavaScript world as target "
"object");
return findObject(*remoteObjectId, result);
}
if (callArgument->hasValue() || callArgument->hasUnserializableValue()) {
String16 value;
if (callArgument->hasValue()) {
value = "(" + callArgument->getValue(nullptr)->toJSONString() + ")";
} else {
String16 unserializableValue = callArgument->getUnserializableValue("");
// Protect against potential identifier resolution for NaN and Infinity.
if (isResolvableNumberLike(unserializableValue))
value = "Number(\"" + unserializableValue + "\")";
else
value = unserializableValue;
}
if (!m_context->inspector()
->compileAndRunInternalScript(
m_context->context(), toV8String(m_context->isolate(), value))
.ToLocal(result)) {
return Response::Error("Couldn't parse value object in call argument");
}
return Response::OK();
}
*result = v8::Undefined(m_context->isolate());
return Response::OK();
}
Response InjectedScript::createExceptionDetails(
const v8::TryCatch& tryCatch, const String16& objectGroup,
WrapMode wrapMode, Maybe<protocol::Runtime::ExceptionDetails>* result) {
if (!tryCatch.HasCaught()) return Response::InternalError();
v8::Local<v8::Message> message = tryCatch.Message();
v8::Local<v8::Value> exception = tryCatch.Exception();
String16 messageText =
message.IsEmpty()
? String16()
: toProtocolString(m_context->isolate(), message->Get());
std::unique_ptr<protocol::Runtime::ExceptionDetails> exceptionDetails =
protocol::Runtime::ExceptionDetails::create()
.setExceptionId(m_context->inspector()->nextExceptionId())
.setText(exception.IsEmpty() ? messageText : String16("Uncaught"))
.setLineNumber(
message.IsEmpty()
? 0
: message->GetLineNumber(m_context->context()).FromMaybe(1) -
1)
.setColumnNumber(
message.IsEmpty()
? 0
: message->GetStartColumn(m_context->context()).FromMaybe(0))
.build();
if (!message.IsEmpty()) {
exceptionDetails->setScriptId(String16::fromInteger(
static_cast<int>(message->GetScriptOrigin().ScriptID()->Value())));
v8::Local<v8::StackTrace> stackTrace = message->GetStackTrace();
if (!stackTrace.IsEmpty() && stackTrace->GetFrameCount() > 0)
exceptionDetails->setStackTrace(
m_context->inspector()
->debugger()
->createStackTrace(stackTrace)
->buildInspectorObjectImpl(m_context->inspector()->debugger()));
}
if (!exception.IsEmpty()) {
std::unique_ptr<protocol::Runtime::RemoteObject> wrapped;
Response response =
wrapObject(exception, objectGroup,
exception->IsNativeError() ? WrapMode::kNoPreview
: WrapMode::kWithPreview,
&wrapped);
if (!response.isSuccess()) return response;
exceptionDetails->setException(std::move(wrapped));
}
*result = std::move(exceptionDetails);
return Response::OK();
}
Response InjectedScript::wrapEvaluateResult(
v8::MaybeLocal<v8::Value> maybeResultValue, const v8::TryCatch& tryCatch,
const String16& objectGroup, WrapMode wrapMode,
std::unique_ptr<protocol::Runtime::RemoteObject>* result,
Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails) {
v8::Local<v8::Value> resultValue;
if (!tryCatch.HasCaught()) {
if (!maybeResultValue.ToLocal(&resultValue))
return Response::InternalError();
Response response = wrapObject(resultValue, objectGroup, wrapMode, result);
if (!response.isSuccess()) return response;
if (objectGroup == "console") {
m_lastEvaluationResult.Reset(m_context->isolate(), resultValue);
m_lastEvaluationResult.AnnotateStrongRetainer(kGlobalHandleLabel);
}
} else {
if (tryCatch.HasTerminated() || !tryCatch.CanContinue()) {
return Response::Error("Execution was terminated");
}
v8::Local<v8::Value> exception = tryCatch.Exception();
Response response =
wrapObject(exception, objectGroup,
exception->IsNativeError() ? WrapMode::kNoPreview
: WrapMode::kWithPreview,
result);
if (!response.isSuccess()) return response;
// We send exception in result for compatibility reasons, even though it's
// accessible through exceptionDetails.exception.
response = createExceptionDetails(tryCatch, objectGroup, wrapMode,
exceptionDetails);
if (!response.isSuccess()) return response;
}
return Response::OK();
}
v8::Local<v8::Object> InjectedScript::commandLineAPI() {
if (m_commandLineAPI.IsEmpty()) {
m_commandLineAPI.Reset(
m_context->isolate(),
m_context->inspector()->console()->createCommandLineAPI(
m_context->context(), m_sessionId));
m_commandLineAPI.AnnotateStrongRetainer(kGlobalHandleLabel);
}
return m_commandLineAPI.Get(m_context->isolate());
}
InjectedScript::Scope::Scope(V8InspectorSessionImpl* session)
: m_inspector(session->inspector()),
m_injectedScript(nullptr),
m_handleScope(m_inspector->isolate()),
m_tryCatch(m_inspector->isolate()),
m_ignoreExceptionsAndMuteConsole(false),
m_previousPauseOnExceptionsState(v8::debug::NoBreakOnException),
m_userGesture(false),
m_allowEval(false),
m_contextGroupId(session->contextGroupId()),
m_sessionId(session->sessionId()) {}
Response InjectedScript::Scope::initialize() {
cleanup();
V8InspectorSessionImpl* session =
m_inspector->sessionById(m_contextGroupId, m_sessionId);
if (!session) return Response::InternalError();
Response response = findInjectedScript(session);
if (!response.isSuccess()) return response;
m_context = m_injectedScript->context()->context();
m_context->Enter();
if (m_allowEval) m_context->AllowCodeGenerationFromStrings(true);
return Response::OK();
}
void InjectedScript::Scope::installCommandLineAPI() {
DCHECK(m_injectedScript && !m_context.IsEmpty() &&
!m_commandLineAPIScope.get());
m_commandLineAPIScope.reset(new V8Console::CommandLineAPIScope(
m_context, m_injectedScript->commandLineAPI(), m_context->Global()));
}
void InjectedScript::Scope::ignoreExceptionsAndMuteConsole() {
DCHECK(!m_ignoreExceptionsAndMuteConsole);
m_ignoreExceptionsAndMuteConsole = true;
m_inspector->client()->muteMetrics(m_contextGroupId);
m_inspector->muteExceptions(m_contextGroupId);
m_previousPauseOnExceptionsState =
setPauseOnExceptionsState(v8::debug::NoBreakOnException);
}
v8::debug::ExceptionBreakState InjectedScript::Scope::setPauseOnExceptionsState(
v8::debug::ExceptionBreakState newState) {
if (!m_inspector->debugger()->enabled()) return newState;
v8::debug::ExceptionBreakState presentState =
m_inspector->debugger()->getPauseOnExceptionsState();
if (presentState != newState)
m_inspector->debugger()->setPauseOnExceptionsState(newState);
return presentState;
}
void InjectedScript::Scope::pretendUserGesture() {
DCHECK(!m_userGesture);
m_userGesture = true;
m_inspector->client()->beginUserGesture();
}
void InjectedScript::Scope::allowCodeGenerationFromStrings() {
DCHECK(!m_allowEval);
if (m_context->IsCodeGenerationFromStringsAllowed()) return;
m_allowEval = true;
m_context->AllowCodeGenerationFromStrings(true);
}
void InjectedScript::Scope::cleanup() {
m_commandLineAPIScope.reset();
if (!m_context.IsEmpty()) {
if (m_allowEval) m_context->AllowCodeGenerationFromStrings(false);
m_context->Exit();
m_context.Clear();
}
}
InjectedScript::Scope::~Scope() {
if (m_ignoreExceptionsAndMuteConsole) {
setPauseOnExceptionsState(m_previousPauseOnExceptionsState);
m_inspector->client()->unmuteMetrics(m_contextGroupId);
m_inspector->unmuteExceptions(m_contextGroupId);
}
if (m_userGesture) m_inspector->client()->endUserGesture();
cleanup();
}
InjectedScript::ContextScope::ContextScope(V8InspectorSessionImpl* session,
int executionContextId)
: InjectedScript::Scope(session),
m_executionContextId(executionContextId) {}
InjectedScript::ContextScope::~ContextScope() = default;
Response InjectedScript::ContextScope::findInjectedScript(
V8InspectorSessionImpl* session) {
return session->findInjectedScript(m_executionContextId, m_injectedScript);
}
InjectedScript::ObjectScope::ObjectScope(V8InspectorSessionImpl* session,
const String16& remoteObjectId)
: InjectedScript::Scope(session), m_remoteObjectId(remoteObjectId) {}
InjectedScript::ObjectScope::~ObjectScope() = default;
Response InjectedScript::ObjectScope::findInjectedScript(
V8InspectorSessionImpl* session) {
std::unique_ptr<RemoteObjectId> remoteId;
Response response = RemoteObjectId::parse(m_remoteObjectId, &remoteId);
if (!response.isSuccess()) return response;
InjectedScript* injectedScript = nullptr;
response = session->findInjectedScript(remoteId.get(), injectedScript);
if (!response.isSuccess()) return response;
m_objectGroupName = injectedScript->objectGroupName(*remoteId);
response = injectedScript->findObject(*remoteId, &m_object);
if (!response.isSuccess()) return response;
m_injectedScript = injectedScript;
return Response::OK();
}
InjectedScript::CallFrameScope::CallFrameScope(V8InspectorSessionImpl* session,
const String16& remoteObjectId)
: InjectedScript::Scope(session), m_remoteCallFrameId(remoteObjectId) {}
InjectedScript::CallFrameScope::~CallFrameScope() = default;
Response InjectedScript::CallFrameScope::findInjectedScript(
V8InspectorSessionImpl* session) {
std::unique_ptr<RemoteCallFrameId> remoteId;
Response response = RemoteCallFrameId::parse(m_remoteCallFrameId, &remoteId);
if (!response.isSuccess()) return response;
m_frameOrdinal = static_cast<size_t>(remoteId->frameOrdinal());
return session->findInjectedScript(remoteId.get(), m_injectedScript);
}
String16 InjectedScript::bindObject(v8::Local<v8::Value> value,
const String16& groupName) {
if (m_lastBoundObjectId <= 0) m_lastBoundObjectId = 1;
int id = m_lastBoundObjectId++;
m_idToWrappedObject[id].Reset(m_context->isolate(), value);
m_idToWrappedObject[id].AnnotateStrongRetainer(kGlobalHandleLabel);
if (!groupName.isEmpty() && id > 0) {
m_idToObjectGroupName[id] = groupName;
m_nameToObjectGroup[groupName].push_back(id);
}
// TODO(dgozman): get rid of "injectedScript" notion.
return String16::concat(
"{\"injectedScriptId\":", String16::fromInteger(m_context->contextId()),
",\"id\":", String16::fromInteger(id), "}");
}
// static
Response InjectedScript::bindRemoteObjectIfNeeded(
int sessionId, v8::Local<v8::Context> context, v8::Local<v8::Value> value,
const String16& groupName, protocol::Runtime::RemoteObject* remoteObject) {
if (!remoteObject) return Response::OK();
if (remoteObject->hasValue()) return Response::OK();
if (remoteObject->hasUnserializableValue()) return Response::OK();
if (remoteObject->getType() != RemoteObject::TypeEnum::Undefined) {
v8::Isolate* isolate = context->GetIsolate();
V8InspectorImpl* inspector =
static_cast<V8InspectorImpl*>(v8::debug::GetInspector(isolate));
InspectedContext* inspectedContext =
inspector->getContext(InspectedContext::contextId(context));
InjectedScript* injectedScript =
inspectedContext ? inspectedContext->getInjectedScript(sessionId)
: nullptr;
if (!injectedScript) {
return Response::Error("Cannot find context with specified id");
}
remoteObject->setObjectId(injectedScript->bindObject(value, groupName));
}
return Response::OK();
}
void InjectedScript::unbindObject(int id) {
m_idToWrappedObject.erase(id);
m_idToObjectGroupName.erase(id);
}
} // namespace v8_inspector