blob: 992ff50fe7da6a143fbe308a4a26fdc9602073df [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 "../../third_party/inspector_protocol/crdtp/json.h"
#include "include/v8-inspector.h"
#include "src/debug/debug-interface.h"
#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"
namespace v8_inspector {
namespace {
const char kGlobalHandleLabel[] = "DevTools console";
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, bool replMode,
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::MaybeLocal<v8::Promise> originalPromise =
value->IsPromise() ? value.As<v8::Promise>()
: v8::MaybeLocal<v8::Promise>();
V8InspectorImpl* inspector = session->inspector();
ProtocolPromiseHandler* handler = new ProtocolPromiseHandler(
session, executionContextId, objectGroup, wrapMode, replMode, callback,
originalPromise);
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();
v8::Local<v8::Function> catchCallbackFunction =
v8::Function::New(context, catchCallback, wrapper, 0,
v8::ConstructorBehavior::kThrow)
.ToLocalChecked();
v8::Local<v8::Promise> promise = resolver->GetPromise();
if (promise->Then(context, thenCallbackFunction, catchCallbackFunction)
.IsEmpty()) {
callback->sendFailure(Response::InternalError());
return false;
}
return true;
}
private:
static v8::Local<v8::String> GetDotReplResultString(v8::Isolate* isolate) {
// TODO(szuend): Cache the string in a v8::Persistent handle.
return v8::String::NewFromOneByte(
isolate, reinterpret_cast<const uint8_t*>(".repl_result"))
.ToLocalChecked();
}
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::Undefined(info.GetIsolate()).As<v8::Value>();
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::Undefined(info.GetIsolate()).As<v8::Value>();
handler->catchCallback(value);
delete handler;
}
ProtocolPromiseHandler(V8InspectorSessionImpl* session,
int executionContextId, const String16& objectGroup,
WrapMode wrapMode, bool replMode,
EvaluateCallback* callback,
v8::MaybeLocal<v8::Promise> maybeEvaluationResult)
: m_inspector(session->inspector()),
m_sessionId(session->sessionId()),
m_contextGroupId(session->contextGroupId()),
m_executionContextId(executionContextId),
m_objectGroup(objectGroup),
m_wrapMode(wrapMode),
m_replMode(replMode),
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);
v8::Local<v8::Promise> promise;
if (maybeEvaluationResult.ToLocal(&promise)) {
m_evaluationResult =
v8::Global<v8::Promise>(m_inspector->isolate(), promise);
}
}
static void cleanup(
const v8::WeakCallbackInfo<ProtocolPromiseHandler>& data) {
if (!data.GetParameter()->m_wrapper.IsEmpty()) {
data.GetParameter()->m_wrapper.Reset();
data.GetParameter()->m_evaluationResult.Reset();
data.SetSecondPassCallback(cleanup);
} else {
data.GetParameter()->sendPromiseCollected();
delete data.GetParameter();
}
}
void thenCallback(v8::Local<v8::Value> value) {
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;
// In REPL mode the result is additionally wrapped in an object.
// The evaluation result can be found at ".repl_result".
v8::Local<v8::Value> result = value;
if (m_replMode) {
v8::Local<v8::Object> object;
if (!result->ToObject(scope.context()).ToLocal(&object)) {
callback->sendFailure(response);
return;
}
v8::Local<v8::String> name =
GetDotReplResultString(m_inspector->isolate());
if (!object->Get(scope.context(), name).ToLocal(&result)) {
callback->sendFailure(response);
return;
}
}
if (m_objectGroup == "console") {
scope.injectedScript()->setLastEvaluationResult(result);
}
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;
}
v8::Isolate* isolate = session->inspector()->isolate();
v8::MaybeLocal<v8::Message> maybeMessage =
m_evaluationResult.IsEmpty()
? v8::MaybeLocal<v8::Message>()
: v8::debug::GetMessageFromPromise(m_evaluationResult.Get(isolate));
v8::Local<v8::Message> message;
// In case a MessageObject was attached to the rejected promise, we
// construct the exception details from the message object. Otherwise
// we try to capture a fresh stack trace.
if (maybeMessage.ToLocal(&message)) {
v8::Local<v8::Value> exception = result;
protocol::PtrMaybe<protocol::Runtime::ExceptionDetails> exceptionDetails;
response = scope.injectedScript()->createExceptionDetails(
message, exception, m_objectGroup, &exceptionDetails);
if (!response.IsSuccess()) {
callback->sendFailure(response);
return;
}
callback->sendSuccess(std::move(wrappedValue),
std::move(exceptionDetails));
return;
}
String16 messageString;
std::unique_ptr<V8StackTraceImpl> stack;
if (result->IsNativeError()) {
messageString =
" " +
toProtocolString(isolate,
result->ToDetailString(isolate->GetCurrentContext())
.ToLocalChecked());
v8::Local<v8::StackTrace> stackTrace =
v8::debug::GetDetailedStackTrace(isolate, result.As<v8::Object>());
if (!stackTrace.IsEmpty()) {
stack = m_inspector->debugger()->createStackTrace(stackTrace);
}
}
if (!stack) {
stack = m_inspector->debugger()->captureStackTrace(true);
}
// REPL mode implicitly handles the script like an async function.
// Do not prepend the '(in promise)' prefix for these exceptions since that
// would be confusing for the user. The stringified error is part of the
// exception and does not need to be added in REPL mode, otherwise it would
// be printed twice.
String16 exceptionDetailsText =
m_replMode ? "Uncaught" : "Uncaught (in promise)" + messageString;
std::unique_ptr<protocol::Runtime::ExceptionDetails> exceptionDetails =
protocol::Runtime::ExceptionDetails::create()
.setExceptionId(m_inspector->nextExceptionId())
.setText(exceptionDetailsText)
.setLineNumber(stack && !stack->isEmpty() ? stack->topLineNumber()
: 0)
.setColumnNumber(
stack && !stack->isEmpty() ? stack->topColumnNumber() : 0)
.build();
response = scope.injectedScript()->addExceptionToDetails(
result, exceptionDetails.get(), m_objectGroup);
if (!response.IsSuccess()) {
callback->sendFailure(response);
return;
}
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::ServerError("Promise was collected"));
}
V8InspectorImpl* m_inspector;
int m_sessionId;
int m_contextGroupId;
int m_executionContextId;
String16 m_objectGroup;
WrapMode m_wrapMode;
bool m_replMode;
EvaluateCallback* m_callback;
v8::Global<v8::External> m_wrapper;
v8::Global<v8::Promise> m_evaluationResult;
};
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 = std::make_unique<Array<PropertyDescriptor>>();
std::vector<PropertyMirror> mirrors;
PropertyAccumulator accumulator(&mirrors);
if (!ValueMirror::getProperties(context, object, ownProperties,
accessorPropertiesOnly, &accumulator)) {
return createExceptionDetails(tryCatch, groupName, 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();
std::unique_ptr<RemoteObject> remoteObject;
if (mirror.value) {
Response 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 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 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 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 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)->emplace_back(std::move(descriptor));
}
return Response::Success();
}
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 = std::make_unique<Array<InternalPropertyDescriptor>>();
*privateProperties = std::make_unique<Array<PrivatePropertyDescriptor>>();
if (!value->IsObject()) return Response::Success();
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)
->emplace_back(InternalPropertyDescriptor::create()
.setName(internalProperty.name)
.setValue(std::move(remoteObject))
.build());
}
std::vector<PrivatePropertyMirror> privatePropertyWrappers =
ValueMirror::getPrivateProperties(context, value_obj);
for (const auto& privateProperty : privatePropertyWrappers) {
std::unique_ptr<PrivatePropertyDescriptor> descriptor =
PrivatePropertyDescriptor::create()
.setName(privateProperty.name)
.build();
std::unique_ptr<RemoteObject> remoteObject;
DCHECK((privateProperty.getter || privateProperty.setter) ^
(!!privateProperty.value));
if (privateProperty.value) {
Response response = privateProperty.value->buildRemoteObject(
context, WrapMode::kNoPreview, &remoteObject);
if (!response.IsSuccess()) return response;
response = bindRemoteObjectIfNeeded(sessionId, context,
privateProperty.value->v8Value(),
groupName, remoteObject.get());
if (!response.IsSuccess()) return response;
descriptor->setValue(std::move(remoteObject));
}
if (privateProperty.getter) {
Response response = privateProperty.getter->buildRemoteObject(
context, WrapMode::kNoPreview, &remoteObject);
if (!response.IsSuccess()) return response;
response = bindRemoteObjectIfNeeded(sessionId, context,
privateProperty.getter->v8Value(),
groupName, remoteObject.get());
if (!response.IsSuccess()) return response;
descriptor->setGet(std::move(remoteObject));
}
if (privateProperty.setter) {
Response response = privateProperty.setter->buildRemoteObject(
context, WrapMode::kNoPreview, &remoteObject);
if (!response.IsSuccess()) return response;
response = bindRemoteObjectIfNeeded(sessionId, context,
privateProperty.setter->v8Value(),
groupName, remoteObject.get());
if (!response.IsSuccess()) return response;
descriptor->setSet(std::move(remoteObject));
}
(*privateProperties)->emplace_back(std::move(descriptor));
}
return Response::Success();
}
void InjectedScript::releaseObject(const String16& objectId) {
std::unique_ptr<RemoteObjectId> remoteId;
Response response = RemoteObjectId::parse(objectId, &remoteId);
if (response.IsSuccess()) unbindObject(remoteId->id());
}
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, value.As<v8::Object>(),
customPreviewConfig, maxCustomPreviewDepth,
&customPreview);
if (customPreview) (*result)->setCustomPreview(std::move(customPreview));
}
return Response::Success();
}
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;
std::vector<String16> selectedColumns;
std::unordered_set<String16> columnSet;
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()) {
String16 name = toProtocolString(isolate, column.As<v8::String>());
if (columnSet.find(name) == columnSet.end()) {
columnSet.insert(name);
selectedColumns.push_back(name);
}
}
}
}
if (!selectedColumns.empty()) {
for (const std::unique_ptr<PropertyPreview>& column :
*preview->getProperties()) {
ObjectPreview* columnPreview = column->getValuePreview(nullptr);
if (!columnPreview) continue;
// Use raw pointer here since the lifetime of each PropertyPreview is
// ensured by columnPreview. This saves an additional clone.
std::unordered_map<String16, PropertyPreview*> columnMap;
for (const std::unique_ptr<PropertyPreview>& property :
*columnPreview->getProperties()) {
if (columnSet.find(property->getName()) == columnSet.end()) continue;
columnMap[property->getName()] = property.get();
}
auto filtered = std::make_unique<Array<PropertyPreview>>();
for (const String16& column : selectedColumns) {
if (columnMap.find(column) == columnMap.end()) continue;
filtered->push_back(columnMap[column]->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, bool replMode,
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,
replMode, callback.get())) {
m_evaluateCallbacks.insert(callback.release());
}
}
void InjectedScript::discardEvaluateCallbacks() {
for (auto& callback : m_evaluateCallbacks) {
callback->sendFailure(
Response::ServerError("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::ServerError("Could not find object with given id");
*outObject = it->second.Get(m_context->isolate());
return Response::Success();
}
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() ||
remoteObjectId->isolateId() != m_context->inspector()->isolateId()) {
return Response::ServerError(
"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()) {
std::vector<uint8_t> json;
v8_crdtp::json::ConvertCBORToJSON(
v8_crdtp::SpanFrom(callArgument->getValue(nullptr)->Serialize()),
&json);
value =
"(" +
String16(reinterpret_cast<const char*>(json.data()), json.size()) +
")";
} 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::ServerError(
"Couldn't parse value object in call argument");
}
return Response::Success();
}
*result = v8::Undefined(m_context->isolate());
return Response::Success();
}
Response InjectedScript::addExceptionToDetails(
v8::Local<v8::Value> exception,
protocol::Runtime::ExceptionDetails* exceptionDetails,
const String16& objectGroup) {
if (exception.IsEmpty()) return Response::Success();
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));
return Response::Success();
}
Response InjectedScript::createExceptionDetails(
const v8::TryCatch& tryCatch, const String16& objectGroup,
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();
return createExceptionDetails(message, exception, objectGroup, result);
}
Response InjectedScript::createExceptionDetails(
v8::Local<v8::Message> message, v8::Local<v8::Value> exception,
const String16& objectGroup,
Maybe<protocol::Runtime::ExceptionDetails>* result) {
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(message->GetScriptOrigin().ScriptId()));
v8::Local<v8::StackTrace> stackTrace = message->GetStackTrace();
if (!stackTrace.IsEmpty() && stackTrace->GetFrameCount() > 0) {
std::unique_ptr<V8StackTraceImpl> v8StackTrace =
m_context->inspector()->debugger()->createStackTrace(stackTrace);
if (v8StackTrace) {
exceptionDetails->setStackTrace(v8StackTrace->buildInspectorObjectImpl(
m_context->inspector()->debugger()));
}
}
}
Response response =
addExceptionToDetails(exception, exceptionDetails.get(), objectGroup);
if (!response.IsSuccess()) return response;
*result = std::move(exceptionDetails);
return Response::Success();
}
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::ServerError("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, exceptionDetails);
if (!response.IsSuccess()) return response;
}
return Response::Success();
}
v8::Local<v8::Object> InjectedScript::commandLineAPI() {
if (m_commandLineAPI.IsEmpty()) {
v8::debug::DisableBreakScope disable_break(m_context->isolate());
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::Success();
}
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::Success();
}
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);
}
return RemoteObjectId::serialize(m_context->inspector()->isolateId(),
m_context->contextId(), 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::Success();
if (remoteObject->hasValue()) return Response::Success();
if (remoteObject->hasUnserializableValue()) return Response::Success();
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::ServerError("Cannot find context with specified id");
}
remoteObject->setObjectId(injectedScript->bindObject(value, groupName));
}
return Response::Success();
}
void InjectedScript::unbindObject(int id) {
m_idToWrappedObject.erase(id);
m_idToObjectGroupName.erase(id);
}
} // namespace v8_inspector