blob: 29afa616e6dad9bc620359611156b9fdb0c160b7 [file] [log] [blame]
/*
* Copyright (C) 2011 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/v8-runtime-agent-impl.h"
#include <inttypes.h>
#include "../../third_party/inspector_protocol/crdtp/json.h"
#include "src/debug/debug-interface.h"
#include "src/inspector/injected-script.h"
#include "src/inspector/inspected-context.h"
#include "src/inspector/protocol/Protocol.h"
#include "src/inspector/remote-object-id.h"
#include "src/inspector/v8-console-message.h"
#include "src/inspector/v8-debugger-agent-impl.h"
#include "src/inspector/v8-debugger.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/tracing/trace-event.h"
#include "include/v8-inspector.h"
namespace v8_inspector {
namespace V8RuntimeAgentImplState {
static const char customObjectFormatterEnabled[] =
"customObjectFormatterEnabled";
static const char runtimeEnabled[] = "runtimeEnabled";
static const char bindings[] = "bindings";
static const char globalBindingsKey[] = "";
} // namespace V8RuntimeAgentImplState
using protocol::Runtime::RemoteObject;
namespace {
template <typename ProtocolCallback>
class EvaluateCallbackWrapper : public EvaluateCallback {
public:
static std::unique_ptr<EvaluateCallback> wrap(
std::unique_ptr<ProtocolCallback> callback) {
return std::unique_ptr<EvaluateCallback>(
new EvaluateCallbackWrapper(std::move(callback)));
}
void sendSuccess(std::unique_ptr<protocol::Runtime::RemoteObject> result,
protocol::Maybe<protocol::Runtime::ExceptionDetails>
exceptionDetails) override {
return m_callback->sendSuccess(std::move(result),
std::move(exceptionDetails));
}
void sendFailure(const protocol::DispatchResponse& response) override {
return m_callback->sendFailure(response);
}
private:
explicit EvaluateCallbackWrapper(std::unique_ptr<ProtocolCallback> callback)
: m_callback(std::move(callback)) {}
std::unique_ptr<ProtocolCallback> m_callback;
};
template <typename ProtocolCallback>
bool wrapEvaluateResultAsync(InjectedScript* injectedScript,
v8::MaybeLocal<v8::Value> maybeResultValue,
const v8::TryCatch& tryCatch,
const String16& objectGroup, WrapMode wrapMode,
ProtocolCallback* callback) {
std::unique_ptr<RemoteObject> result;
Maybe<protocol::Runtime::ExceptionDetails> exceptionDetails;
Response response = injectedScript->wrapEvaluateResult(
maybeResultValue, tryCatch, objectGroup, wrapMode, &result,
&exceptionDetails);
if (response.IsSuccess()) {
callback->sendSuccess(std::move(result), std::move(exceptionDetails));
return true;
}
callback->sendFailure(response);
return false;
}
void innerCallFunctionOn(
V8InspectorSessionImpl* session,
InjectedScript::Scope& scope, // NOLINT(runtime/references)
v8::Local<v8::Value> recv, const String16& expression,
Maybe<protocol::Array<protocol::Runtime::CallArgument>> optionalArguments,
bool silent, WrapMode wrapMode, bool userGesture, bool awaitPromise,
const String16& objectGroup,
std::unique_ptr<V8RuntimeAgentImpl::CallFunctionOnCallback> callback) {
V8InspectorImpl* inspector = session->inspector();
std::unique_ptr<v8::Local<v8::Value>[]> argv = nullptr;
int argc = 0;
if (optionalArguments.isJust()) {
protocol::Array<protocol::Runtime::CallArgument>* arguments =
optionalArguments.fromJust();
argc = static_cast<int>(arguments->size());
argv.reset(new v8::Local<v8::Value>[argc]);
for (int i = 0; i < argc; ++i) {
v8::Local<v8::Value> argumentValue;
Response response = scope.injectedScript()->resolveCallArgument(
(*arguments)[i].get(), &argumentValue);
if (!response.IsSuccess()) {
callback->sendFailure(response);
return;
}
argv[i] = argumentValue;
}
}
if (silent) scope.ignoreExceptionsAndMuteConsole();
if (userGesture) scope.pretendUserGesture();
// Temporarily enable allow evals for inspector.
scope.allowCodeGenerationFromStrings();
v8::MaybeLocal<v8::Value> maybeFunctionValue;
v8::Local<v8::Script> functionScript;
if (inspector
->compileScript(scope.context(), "(" + expression + ")", String16())
.ToLocal(&functionScript)) {
v8::MicrotasksScope microtasksScope(inspector->isolate(),
v8::MicrotasksScope::kRunMicrotasks);
maybeFunctionValue = functionScript->Run(scope.context());
}
// Re-initialize after running client's code, as it could have destroyed
// context or session.
Response response = scope.initialize();
if (!response.IsSuccess()) {
callback->sendFailure(response);
return;
}
if (scope.tryCatch().HasCaught()) {
wrapEvaluateResultAsync(scope.injectedScript(), maybeFunctionValue,
scope.tryCatch(), objectGroup, WrapMode::kNoPreview,
callback.get());
return;
}
v8::Local<v8::Value> functionValue;
if (!maybeFunctionValue.ToLocal(&functionValue) ||
!functionValue->IsFunction()) {
callback->sendFailure(Response::ServerError(
"Given expression does not evaluate to a function"));
return;
}
v8::MaybeLocal<v8::Value> maybeResultValue;
{
v8::MicrotasksScope microtasksScope(inspector->isolate(),
v8::MicrotasksScope::kRunMicrotasks);
maybeResultValue = functionValue.As<v8::Function>()->Call(
scope.context(), recv, argc, argv.get());
}
// Re-initialize after running client's code, as it could have destroyed
// context or session.
response = scope.initialize();
if (!response.IsSuccess()) {
callback->sendFailure(response);
return;
}
if (!awaitPromise || scope.tryCatch().HasCaught()) {
wrapEvaluateResultAsync(scope.injectedScript(), maybeResultValue,
scope.tryCatch(), objectGroup, wrapMode,
callback.get());
return;
}
scope.injectedScript()->addPromiseCallback(
session, maybeResultValue, objectGroup, wrapMode, false /* replMode */,
EvaluateCallbackWrapper<V8RuntimeAgentImpl::CallFunctionOnCallback>::wrap(
std::move(callback)));
}
Response ensureContext(V8InspectorImpl* inspector, int contextGroupId,
Maybe<int> executionContextId, int* contextId) {
if (executionContextId.isJust()) {
*contextId = executionContextId.fromJust();
} else {
v8::HandleScope handles(inspector->isolate());
v8::Local<v8::Context> defaultContext =
inspector->client()->ensureDefaultContextInGroup(contextGroupId);
if (defaultContext.IsEmpty())
return Response::ServerError("Cannot find default execution context");
*contextId = InspectedContext::contextId(defaultContext);
}
return Response::Success();
}
} // namespace
V8RuntimeAgentImpl::V8RuntimeAgentImpl(
V8InspectorSessionImpl* session, protocol::FrontendChannel* FrontendChannel,
protocol::DictionaryValue* state)
: m_session(session),
m_state(state),
m_frontend(FrontendChannel),
m_inspector(session->inspector()),
m_enabled(false) {}
V8RuntimeAgentImpl::~V8RuntimeAgentImpl() = default;
void V8RuntimeAgentImpl::evaluate(
const String16& expression, Maybe<String16> objectGroup,
Maybe<bool> includeCommandLineAPI, Maybe<bool> silent,
Maybe<int> executionContextId, Maybe<bool> returnByValue,
Maybe<bool> generatePreview, Maybe<bool> userGesture,
Maybe<bool> maybeAwaitPromise, Maybe<bool> throwOnSideEffect,
Maybe<double> timeout, Maybe<bool> disableBreaks, Maybe<bool> maybeReplMode,
Maybe<bool> allowUnsafeEvalBlockedByCSP,
std::unique_ptr<EvaluateCallback> callback) {
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"),
"EvaluateScript");
int contextId = 0;
Response response = ensureContext(m_inspector, m_session->contextGroupId(),
std::move(executionContextId), &contextId);
if (!response.IsSuccess()) {
callback->sendFailure(response);
return;
}
InjectedScript::ContextScope scope(m_session, contextId);
response = scope.initialize();
if (!response.IsSuccess()) {
callback->sendFailure(response);
return;
}
if (silent.fromMaybe(false)) scope.ignoreExceptionsAndMuteConsole();
if (userGesture.fromMaybe(false)) scope.pretendUserGesture();
if (includeCommandLineAPI.fromMaybe(false)) scope.installCommandLineAPI();
const bool replMode = maybeReplMode.fromMaybe(false);
if (allowUnsafeEvalBlockedByCSP.fromMaybe(true)) {
// Temporarily enable allow evals for inspector.
scope.allowCodeGenerationFromStrings();
}
v8::MaybeLocal<v8::Value> maybeResultValue;
{
V8InspectorImpl::EvaluateScope evaluateScope(scope);
if (timeout.isJust()) {
response = evaluateScope.setTimeout(timeout.fromJust() / 1000.0);
if (!response.IsSuccess()) {
callback->sendFailure(response);
return;
}
}
v8::MicrotasksScope microtasksScope(m_inspector->isolate(),
v8::MicrotasksScope::kRunMicrotasks);
v8::debug::EvaluateGlobalMode mode =
v8::debug::EvaluateGlobalMode::kDefault;
if (throwOnSideEffect.fromMaybe(false)) {
mode = v8::debug::EvaluateGlobalMode::kDisableBreaksAndThrowOnSideEffect;
} else if (disableBreaks.fromMaybe(false)) {
mode = v8::debug::EvaluateGlobalMode::kDisableBreaks;
}
const v8::Local<v8::String> source =
toV8String(m_inspector->isolate(), expression);
maybeResultValue = v8::debug::EvaluateGlobal(m_inspector->isolate(), source,
mode, replMode);
} // Run microtasks before returning result.
// Re-initialize after running client's code, as it could have destroyed
// context or session.
response = scope.initialize();
if (!response.IsSuccess()) {
callback->sendFailure(response);
return;
}
WrapMode mode = generatePreview.fromMaybe(false) ? WrapMode::kWithPreview
: WrapMode::kNoPreview;
if (returnByValue.fromMaybe(false)) mode = WrapMode::kForceValue;
// REPL mode always returns a promise that must be awaited.
const bool await = replMode || maybeAwaitPromise.fromMaybe(false);
if (!await || scope.tryCatch().HasCaught()) {
wrapEvaluateResultAsync(scope.injectedScript(), maybeResultValue,
scope.tryCatch(), objectGroup.fromMaybe(""), mode,
callback.get());
return;
}
scope.injectedScript()->addPromiseCallback(
m_session, maybeResultValue, objectGroup.fromMaybe(""), mode, replMode,
EvaluateCallbackWrapper<EvaluateCallback>::wrap(std::move(callback)));
}
void V8RuntimeAgentImpl::awaitPromise(
const String16& promiseObjectId, Maybe<bool> returnByValue,
Maybe<bool> generatePreview,
std::unique_ptr<AwaitPromiseCallback> callback) {
InjectedScript::ObjectScope scope(m_session, promiseObjectId);
Response response = scope.initialize();
if (!response.IsSuccess()) {
callback->sendFailure(response);
return;
}
if (!scope.object()->IsPromise()) {
callback->sendFailure(
Response::ServerError("Could not find promise with given id"));
return;
}
WrapMode mode = generatePreview.fromMaybe(false) ? WrapMode::kWithPreview
: WrapMode::kNoPreview;
if (returnByValue.fromMaybe(false)) mode = WrapMode::kForceValue;
scope.injectedScript()->addPromiseCallback(
m_session, scope.object(), scope.objectGroupName(), mode,
false /* replMode */,
EvaluateCallbackWrapper<AwaitPromiseCallback>::wrap(std::move(callback)));
}
void V8RuntimeAgentImpl::callFunctionOn(
const String16& expression, Maybe<String16> objectId,
Maybe<protocol::Array<protocol::Runtime::CallArgument>> optionalArguments,
Maybe<bool> silent, Maybe<bool> returnByValue, Maybe<bool> generatePreview,
Maybe<bool> userGesture, Maybe<bool> awaitPromise,
Maybe<int> executionContextId, Maybe<String16> objectGroup,
std::unique_ptr<CallFunctionOnCallback> callback) {
if (objectId.isJust() && executionContextId.isJust()) {
callback->sendFailure(Response::ServerError(
"ObjectId must not be specified together with executionContextId"));
return;
}
if (!objectId.isJust() && !executionContextId.isJust()) {
callback->sendFailure(Response::ServerError(
"Either ObjectId or executionContextId must be specified"));
return;
}
WrapMode mode = generatePreview.fromMaybe(false) ? WrapMode::kWithPreview
: WrapMode::kNoPreview;
if (returnByValue.fromMaybe(false)) mode = WrapMode::kForceValue;
if (objectId.isJust()) {
InjectedScript::ObjectScope scope(m_session, objectId.fromJust());
Response response = scope.initialize();
if (!response.IsSuccess()) {
callback->sendFailure(response);
return;
}
innerCallFunctionOn(m_session, scope, scope.object(), expression,
std::move(optionalArguments), silent.fromMaybe(false),
mode, userGesture.fromMaybe(false),
awaitPromise.fromMaybe(false),
objectGroup.isJust() ? objectGroup.fromMaybe(String16())
: scope.objectGroupName(),
std::move(callback));
} else {
int contextId = 0;
Response response =
ensureContext(m_inspector, m_session->contextGroupId(),
std::move(executionContextId.fromJust()), &contextId);
if (!response.IsSuccess()) {
callback->sendFailure(response);
return;
}
InjectedScript::ContextScope scope(m_session, contextId);
response = scope.initialize();
if (!response.IsSuccess()) {
callback->sendFailure(response);
return;
}
innerCallFunctionOn(m_session, scope, scope.context()->Global(), expression,
std::move(optionalArguments), silent.fromMaybe(false),
mode, userGesture.fromMaybe(false),
awaitPromise.fromMaybe(false),
objectGroup.fromMaybe(""), std::move(callback));
}
}
Response V8RuntimeAgentImpl::getProperties(
const String16& objectId, Maybe<bool> ownProperties,
Maybe<bool> accessorPropertiesOnly, Maybe<bool> generatePreview,
std::unique_ptr<protocol::Array<protocol::Runtime::PropertyDescriptor>>*
result,
Maybe<protocol::Array<protocol::Runtime::InternalPropertyDescriptor>>*
internalProperties,
Maybe<protocol::Array<protocol::Runtime::PrivatePropertyDescriptor>>*
privateProperties,
Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails) {
using protocol::Runtime::InternalPropertyDescriptor;
using protocol::Runtime::PrivatePropertyDescriptor;
InjectedScript::ObjectScope scope(m_session, objectId);
Response response = scope.initialize();
if (!response.IsSuccess()) return response;
scope.ignoreExceptionsAndMuteConsole();
v8::MicrotasksScope microtasks_scope(m_inspector->isolate(),
v8::MicrotasksScope::kRunMicrotasks);
if (!scope.object()->IsObject())
return Response::ServerError("Value with given id is not an object");
v8::Local<v8::Object> object = scope.object().As<v8::Object>();
response = scope.injectedScript()->getProperties(
object, scope.objectGroupName(), ownProperties.fromMaybe(false),
accessorPropertiesOnly.fromMaybe(false),
generatePreview.fromMaybe(false) ? WrapMode::kWithPreview
: WrapMode::kNoPreview,
result, exceptionDetails);
if (!response.IsSuccess()) return response;
if (exceptionDetails->isJust() || accessorPropertiesOnly.fromMaybe(false))
return Response::Success();
std::unique_ptr<protocol::Array<InternalPropertyDescriptor>>
internalPropertiesProtocolArray;
std::unique_ptr<protocol::Array<PrivatePropertyDescriptor>>
privatePropertiesProtocolArray;
response = scope.injectedScript()->getInternalAndPrivateProperties(
object, scope.objectGroupName(), &internalPropertiesProtocolArray,
&privatePropertiesProtocolArray);
if (!response.IsSuccess()) return response;
if (!internalPropertiesProtocolArray->empty())
*internalProperties = std::move(internalPropertiesProtocolArray);
if (!privatePropertiesProtocolArray->empty())
*privateProperties = std::move(privatePropertiesProtocolArray);
return Response::Success();
}
Response V8RuntimeAgentImpl::releaseObject(const String16& objectId) {
InjectedScript::ObjectScope scope(m_session, objectId);
Response response = scope.initialize();
if (!response.IsSuccess()) return response;
scope.injectedScript()->releaseObject(objectId);
return Response::Success();
}
Response V8RuntimeAgentImpl::releaseObjectGroup(const String16& objectGroup) {
m_session->releaseObjectGroup(objectGroup);
return Response::Success();
}
Response V8RuntimeAgentImpl::runIfWaitingForDebugger() {
m_inspector->client()->runIfWaitingForDebugger(m_session->contextGroupId());
return Response::Success();
}
Response V8RuntimeAgentImpl::setCustomObjectFormatterEnabled(bool enabled) {
m_state->setBoolean(V8RuntimeAgentImplState::customObjectFormatterEnabled,
enabled);
if (!m_enabled) return Response::ServerError("Runtime agent is not enabled");
m_session->setCustomObjectFormatterEnabled(enabled);
return Response::Success();
}
Response V8RuntimeAgentImpl::setMaxCallStackSizeToCapture(int size) {
if (size < 0) {
return Response::ServerError(
"maxCallStackSizeToCapture should be non-negative");
}
V8StackTraceImpl::maxCallStackSizeToCapture = size;
return Response::Success();
}
Response V8RuntimeAgentImpl::discardConsoleEntries() {
V8ConsoleMessageStorage* storage =
m_inspector->ensureConsoleMessageStorage(m_session->contextGroupId());
storage->clear();
return Response::Success();
}
Response V8RuntimeAgentImpl::compileScript(
const String16& expression, const String16& sourceURL, bool persistScript,
Maybe<int> executionContextId, Maybe<String16>* scriptId,
Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails) {
if (!m_enabled) return Response::ServerError("Runtime agent is not enabled");
int contextId = 0;
Response response = ensureContext(m_inspector, m_session->contextGroupId(),
std::move(executionContextId), &contextId);
if (!response.IsSuccess()) return response;
InjectedScript::ContextScope scope(m_session, contextId);
response = scope.initialize();
if (!response.IsSuccess()) return response;
if (!persistScript) m_inspector->debugger()->muteScriptParsedEvents();
v8::Local<v8::Script> script;
bool isOk = m_inspector->compileScript(scope.context(), expression, sourceURL)
.ToLocal(&script);
if (!persistScript) m_inspector->debugger()->unmuteScriptParsedEvents();
if (!isOk) {
if (scope.tryCatch().HasCaught()) {
response = scope.injectedScript()->createExceptionDetails(
scope.tryCatch(), String16(), exceptionDetails);
if (!response.IsSuccess()) return response;
return Response::Success();
} else {
return Response::ServerError("Script compilation failed");
}
}
if (!persistScript) return Response::Success();
String16 scriptValueId =
String16::fromInteger(script->GetUnboundScript()->GetId());
std::unique_ptr<v8::Global<v8::Script>> global(
new v8::Global<v8::Script>(m_inspector->isolate(), script));
m_compiledScripts[scriptValueId] = std::move(global);
*scriptId = scriptValueId;
return Response::Success();
}
void V8RuntimeAgentImpl::runScript(
const String16& scriptId, Maybe<int> executionContextId,
Maybe<String16> objectGroup, Maybe<bool> silent,
Maybe<bool> includeCommandLineAPI, Maybe<bool> returnByValue,
Maybe<bool> generatePreview, Maybe<bool> awaitPromise,
std::unique_ptr<RunScriptCallback> callback) {
if (!m_enabled) {
callback->sendFailure(
Response::ServerError("Runtime agent is not enabled"));
return;
}
auto it = m_compiledScripts.find(scriptId);
if (it == m_compiledScripts.end()) {
callback->sendFailure(Response::ServerError("No script with given id"));
return;
}
int contextId = 0;
Response response = ensureContext(m_inspector, m_session->contextGroupId(),
std::move(executionContextId), &contextId);
if (!response.IsSuccess()) {
callback->sendFailure(response);
return;
}
InjectedScript::ContextScope scope(m_session, contextId);
response = scope.initialize();
if (!response.IsSuccess()) {
callback->sendFailure(response);
return;
}
if (silent.fromMaybe(false)) scope.ignoreExceptionsAndMuteConsole();
std::unique_ptr<v8::Global<v8::Script>> scriptWrapper = std::move(it->second);
m_compiledScripts.erase(it);
v8::Local<v8::Script> script = scriptWrapper->Get(m_inspector->isolate());
if (script.IsEmpty()) {
callback->sendFailure(Response::ServerError("Script execution failed"));
return;
}
if (includeCommandLineAPI.fromMaybe(false)) scope.installCommandLineAPI();
v8::MaybeLocal<v8::Value> maybeResultValue;
{
v8::MicrotasksScope microtasksScope(m_inspector->isolate(),
v8::MicrotasksScope::kRunMicrotasks);
maybeResultValue = script->Run(scope.context());
}
// Re-initialize after running client's code, as it could have destroyed
// context or session.
response = scope.initialize();
if (!response.IsSuccess()) {
callback->sendFailure(response);
return;
}
WrapMode mode = generatePreview.fromMaybe(false) ? WrapMode::kWithPreview
: WrapMode::kNoPreview;
if (returnByValue.fromMaybe(false)) mode = WrapMode::kForceValue;
if (!awaitPromise.fromMaybe(false) || scope.tryCatch().HasCaught()) {
wrapEvaluateResultAsync(scope.injectedScript(), maybeResultValue,
scope.tryCatch(), objectGroup.fromMaybe(""), mode,
callback.get());
return;
}
scope.injectedScript()->addPromiseCallback(
m_session, maybeResultValue.ToLocalChecked(), objectGroup.fromMaybe(""),
mode, false /* replMode */,
EvaluateCallbackWrapper<RunScriptCallback>::wrap(std::move(callback)));
}
Response V8RuntimeAgentImpl::queryObjects(
const String16& prototypeObjectId, Maybe<String16> objectGroup,
std::unique_ptr<protocol::Runtime::RemoteObject>* objects) {
InjectedScript::ObjectScope scope(m_session, prototypeObjectId);
Response response = scope.initialize();
if (!response.IsSuccess()) return response;
if (!scope.object()->IsObject()) {
return Response::ServerError("Prototype should be instance of Object");
}
v8::Local<v8::Array> resultArray = m_inspector->debugger()->queryObjects(
scope.context(), scope.object().As<v8::Object>());
return scope.injectedScript()->wrapObject(
resultArray, objectGroup.fromMaybe(scope.objectGroupName()),
WrapMode::kNoPreview, objects);
}
Response V8RuntimeAgentImpl::globalLexicalScopeNames(
Maybe<int> executionContextId,
std::unique_ptr<protocol::Array<String16>>* outNames) {
int contextId = 0;
Response response = ensureContext(m_inspector, m_session->contextGroupId(),
std::move(executionContextId), &contextId);
if (!response.IsSuccess()) return response;
InjectedScript::ContextScope scope(m_session, contextId);
response = scope.initialize();
if (!response.IsSuccess()) return response;
v8::PersistentValueVector<v8::String> names(m_inspector->isolate());
v8::debug::GlobalLexicalScopeNames(scope.context(), &names);
*outNames = std::make_unique<protocol::Array<String16>>();
for (size_t i = 0; i < names.Size(); ++i) {
(*outNames)->emplace_back(
toProtocolString(m_inspector->isolate(), names.Get(i)));
}
return Response::Success();
}
Response V8RuntimeAgentImpl::getIsolateId(String16* outIsolateId) {
char buf[40];
std::snprintf(buf, sizeof(buf), "%" PRIx64, m_inspector->isolateId());
*outIsolateId = buf;
return Response::Success();
}
Response V8RuntimeAgentImpl::getHeapUsage(double* out_usedSize,
double* out_totalSize) {
v8::HeapStatistics stats;
m_inspector->isolate()->GetHeapStatistics(&stats);
*out_usedSize = stats.used_heap_size();
*out_totalSize = stats.total_heap_size();
return Response::Success();
}
void V8RuntimeAgentImpl::terminateExecution(
std::unique_ptr<TerminateExecutionCallback> callback) {
m_inspector->debugger()->terminateExecution(std::move(callback));
}
namespace {
protocol::DictionaryValue* getOrCreateDictionary(
protocol::DictionaryValue* dict, const String16& key) {
if (protocol::DictionaryValue* bindings = dict->getObject(key))
return bindings;
dict->setObject(key, protocol::DictionaryValue::create());
return dict->getObject(key);
}
} // namespace
Response V8RuntimeAgentImpl::addBinding(const String16& name,
Maybe<int> executionContextId,
Maybe<String16> executionContextName) {
if (m_activeBindings.count(name)) return Response::Success();
if (executionContextId.isJust()) {
if (executionContextName.isJust()) {
return Response::InvalidParams(
"executionContextName is mutually exclusive with executionContextId");
}
int contextId = executionContextId.fromJust();
InspectedContext* context =
m_inspector->getContext(m_session->contextGroupId(), contextId);
if (!context) {
return Response::InvalidParams(
"Cannot find execution context with given executionContextId");
}
addBinding(context, name);
return Response::Success();
}
// If it's a globally exposed binding, i.e. no context name specified, use
// a special value for the context name.
String16 contextKey = V8RuntimeAgentImplState::globalBindingsKey;
if (executionContextName.isJust()) {
contextKey = executionContextName.fromJust();
if (contextKey == V8RuntimeAgentImplState::globalBindingsKey) {
return Response::InvalidParams("Invalid executionContextName");
}
}
// Only persist non context-specific bindings, as contextIds don't make
// any sense when state is restored in a different process.
protocol::DictionaryValue* bindings =
getOrCreateDictionary(m_state, V8RuntimeAgentImplState::bindings);
protocol::DictionaryValue* contextBindings =
getOrCreateDictionary(bindings, contextKey);
contextBindings->setBoolean(name, true);
m_inspector->forEachContext(
m_session->contextGroupId(),
[&name, &executionContextName, this](InspectedContext* context) {
if (executionContextName.isJust() &&
executionContextName.fromJust() != context->humanReadableName())
return;
addBinding(context, name);
});
return Response::Success();
}
void V8RuntimeAgentImpl::bindingCallback(
const v8::FunctionCallbackInfo<v8::Value>& info) {
v8::Isolate* isolate = info.GetIsolate();
if (info.Length() != 1 || !info[0]->IsString()) {
info.GetIsolate()->ThrowException(toV8String(
isolate, "Invalid arguments: should be exactly one string."));
return;
}
V8InspectorImpl* inspector =
static_cast<V8InspectorImpl*>(v8::debug::GetInspector(isolate));
int contextId = InspectedContext::contextId(isolate->GetCurrentContext());
int contextGroupId = inspector->contextGroupId(contextId);
String16 name = toProtocolString(isolate, info.Data().As<v8::String>());
String16 payload = toProtocolString(isolate, info[0].As<v8::String>());
inspector->forEachSession(
contextGroupId,
[&name, &payload, &contextId](V8InspectorSessionImpl* session) {
session->runtimeAgent()->bindingCalled(name, payload, contextId);
});
}
void V8RuntimeAgentImpl::addBinding(InspectedContext* context,
const String16& name) {
v8::HandleScope handles(m_inspector->isolate());
v8::Local<v8::Context> localContext = context->context();
v8::Local<v8::Object> global = localContext->Global();
v8::Local<v8::String> v8Name = toV8String(m_inspector->isolate(), name);
v8::Local<v8::Value> functionValue;
v8::MicrotasksScope microtasks(m_inspector->isolate(),
v8::MicrotasksScope::kDoNotRunMicrotasks);
if (v8::Function::New(localContext, bindingCallback, v8Name)
.ToLocal(&functionValue)) {
v8::Maybe<bool> success = global->Set(localContext, v8Name, functionValue);
USE(success);
m_activeBindings.insert(name);
}
}
Response V8RuntimeAgentImpl::removeBinding(const String16& name) {
protocol::DictionaryValue* bindings =
m_state->getObject(V8RuntimeAgentImplState::bindings);
if (bindings) bindings->remove(name);
m_activeBindings.erase(name);
return Response::Success();
}
void V8RuntimeAgentImpl::bindingCalled(const String16& name,
const String16& payload,
int executionContextId) {
if (!m_activeBindings.count(name)) return;
m_frontend.bindingCalled(name, payload, executionContextId);
}
void V8RuntimeAgentImpl::addBindings(InspectedContext* context) {
const String16 contextName = context->humanReadableName();
if (!m_enabled) return;
protocol::DictionaryValue* bindings =
m_state->getObject(V8RuntimeAgentImplState::bindings);
if (!bindings) return;
protocol::DictionaryValue* globalBindings =
bindings->getObject(V8RuntimeAgentImplState::globalBindingsKey);
if (globalBindings) {
for (size_t i = 0; i < globalBindings->size(); ++i)
addBinding(context, globalBindings->at(i).first);
}
protocol::DictionaryValue* contextBindings =
contextName.isEmpty() ? nullptr : bindings->getObject(contextName);
if (contextBindings) {
for (size_t i = 0; i < contextBindings->size(); ++i)
addBinding(context, contextBindings->at(i).first);
}
}
void V8RuntimeAgentImpl::restore() {
if (!m_state->booleanProperty(V8RuntimeAgentImplState::runtimeEnabled, false))
return;
m_frontend.executionContextsCleared();
enable();
if (m_state->booleanProperty(
V8RuntimeAgentImplState::customObjectFormatterEnabled, false))
m_session->setCustomObjectFormatterEnabled(true);
m_inspector->forEachContext(
m_session->contextGroupId(),
[this](InspectedContext* context) { addBindings(context); });
}
Response V8RuntimeAgentImpl::enable() {
if (m_enabled) return Response::Success();
m_inspector->client()->beginEnsureAllContextsInGroup(
m_session->contextGroupId());
m_enabled = true;
m_state->setBoolean(V8RuntimeAgentImplState::runtimeEnabled, true);
m_inspector->enableStackCapturingIfNeeded();
m_session->reportAllContexts(this);
V8ConsoleMessageStorage* storage =
m_inspector->ensureConsoleMessageStorage(m_session->contextGroupId());
for (const auto& message : storage->messages()) {
if (!reportMessage(message.get(), false)) break;
}
return Response::Success();
}
Response V8RuntimeAgentImpl::disable() {
if (!m_enabled) return Response::Success();
m_enabled = false;
m_state->setBoolean(V8RuntimeAgentImplState::runtimeEnabled, false);
m_state->remove(V8RuntimeAgentImplState::bindings);
m_inspector->disableStackCapturingIfNeeded();
m_session->setCustomObjectFormatterEnabled(false);
reset();
m_inspector->client()->endEnsureAllContextsInGroup(
m_session->contextGroupId());
if (m_session->debuggerAgent() && !m_session->debuggerAgent()->enabled()) {
m_session->debuggerAgent()->setAsyncCallStackDepth(0);
}
return Response::Success();
}
void V8RuntimeAgentImpl::reset() {
m_compiledScripts.clear();
if (m_enabled) {
int sessionId = m_session->sessionId();
m_inspector->forEachContext(m_session->contextGroupId(),
[&sessionId](InspectedContext* context) {
context->setReported(sessionId, false);
});
m_frontend.executionContextsCleared();
}
}
void V8RuntimeAgentImpl::reportExecutionContextCreated(
InspectedContext* context) {
if (!m_enabled) return;
context->setReported(m_session->sessionId(), true);
std::unique_ptr<protocol::Runtime::ExecutionContextDescription> description =
protocol::Runtime::ExecutionContextDescription::create()
.setId(context->contextId())
.setName(context->humanReadableName())
.setOrigin(context->origin())
.build();
const String16& aux = context->auxData();
if (!aux.isEmpty()) {
std::vector<uint8_t> cbor;
v8_crdtp::json::ConvertJSONToCBOR(
v8_crdtp::span<uint16_t>(aux.characters16(), aux.length()), &cbor);
description->setAuxData(protocol::DictionaryValue::cast(
protocol::Value::parseBinary(cbor.data(), cbor.size())));
}
m_frontend.executionContextCreated(std::move(description));
}
void V8RuntimeAgentImpl::reportExecutionContextDestroyed(
InspectedContext* context) {
if (m_enabled && context->isReported(m_session->sessionId())) {
context->setReported(m_session->sessionId(), false);
m_frontend.executionContextDestroyed(context->contextId());
}
}
void V8RuntimeAgentImpl::inspect(
std::unique_ptr<protocol::Runtime::RemoteObject> objectToInspect,
std::unique_ptr<protocol::DictionaryValue> hints) {
if (m_enabled)
m_frontend.inspectRequested(std::move(objectToInspect), std::move(hints));
}
void V8RuntimeAgentImpl::messageAdded(V8ConsoleMessage* message) {
if (m_enabled) reportMessage(message, true);
}
bool V8RuntimeAgentImpl::reportMessage(V8ConsoleMessage* message,
bool generatePreview) {
message->reportToFrontend(&m_frontend, m_session, generatePreview);
m_frontend.flush();
return m_inspector->hasConsoleMessageStorage(m_session->contextGroupId());
}
} // namespace v8_inspector