Google Git
Sign in
cobalt / cobalt / ef837fa448402e2ada2fb3821210cc20d850164b / . / src / v8 / src / inspector / v8-debugger-agent-impl.cc
blob: 2e47e4e778fa9a58d6fa2eb16c3f2ae8ceaf96da [file] [log] [blame]
// Copyright 2015 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/inspector/v8-debugger-agent-impl.h"
#include <algorithm>
#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/script-breakpoint.h"
#include "src/inspector/search-util.h"
#include "src/inspector/string-util.h"
#include "src/inspector/v8-debugger-script.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-regex.h"
#include "src/inspector/v8-runtime-agent-impl.h"
#include "src/inspector/v8-stack-trace-impl.h"
#include "src/inspector/v8-value-utils.h"
#include "include/v8-inspector.h"
namespace v8_inspector {
using protocol::Array;
using protocol::Maybe;
using protocol::Debugger::BreakpointId;
using protocol::Debugger::CallFrame;
using protocol::Runtime::ExceptionDetails;
using protocol::Runtime::ScriptId;
using protocol::Runtime::RemoteObject;
using protocol::Debugger::Scope;
namespace DebuggerAgentState {
static const char javaScriptBreakpoints[] = "javaScriptBreakopints";
static const char pauseOnExceptionsState[] = "pauseOnExceptionsState";
static const char asyncCallStackDepth[] = "asyncCallStackDepth";
static const char blackboxPattern[] = "blackboxPattern";
static const char debuggerEnabled[] = "debuggerEnabled";
static const char skipAllPauses[] = "skipAllPauses";
// Breakpoint properties.
static const char url[] = "url";
static const char isRegex[] = "isRegex";
static const char lineNumber[] = "lineNumber";
static const char columnNumber[] = "columnNumber";
static const char condition[] = "condition";
static const char hint[] = "hint";
} // namespace DebuggerAgentState
static const char kBacktraceObjectGroup[] = "backtrace";
static const char kDebuggerNotEnabled[] = "Debugger agent is not enabled";
static const char kDebuggerNotPaused[] =
"Can only perform operation while paused.";
static const size_t kBreakpointHintMaxLength = 128;
static const intptr_t kBreakpointHintMaxSearchOffset = 80 * 10;
namespace {
void TranslateLocation(protocol::Debugger::Location* location,
WasmTranslation* wasmTranslation) {
String16 scriptId = location->getScriptId();
int lineNumber = location->getLineNumber();
int columnNumber = location->getColumnNumber(-1);
if (wasmTranslation->TranslateWasmScriptLocationToProtocolLocation(
&scriptId, &lineNumber, &columnNumber)) {
location->setScriptId(std::move(scriptId));
location->setLineNumber(lineNumber);
location->setColumnNumber(columnNumber);
}
}
String16 breakpointIdSuffix(V8DebuggerAgentImpl::BreakpointSource source) {
switch (source) {
case V8DebuggerAgentImpl::UserBreakpointSource:
break;
case V8DebuggerAgentImpl::DebugCommandBreakpointSource:
return ":debug";
case V8DebuggerAgentImpl::MonitorCommandBreakpointSource:
return ":monitor";
}
return String16();
}
String16 generateBreakpointId(const ScriptBreakpoint& breakpoint,
V8DebuggerAgentImpl::BreakpointSource source) {
String16Builder builder;
builder.append(breakpoint.script_id);
builder.append(':');
builder.appendNumber(breakpoint.line_number);
builder.append(':');
builder.appendNumber(breakpoint.column_number);
builder.append(breakpointIdSuffix(source));
return builder.toString();
}
bool positionComparator(const std::pair<int, int>& a,
const std::pair<int, int>& b) {
if (a.first != b.first) return a.first < b.first;
return a.second < b.second;
}
std::unique_ptr<protocol::Debugger::Location> buildProtocolLocation(
const String16& scriptId, int lineNumber, int columnNumber) {
return protocol::Debugger::Location::create()
.setScriptId(scriptId)
.setLineNumber(lineNumber)
.setColumnNumber(columnNumber)
.build();
}
String16 breakpointHint(const V8DebuggerScript& script,
const ScriptBreakpoint& breakpoint) {
int offset = script.offset(breakpoint.line_number, breakpoint.column_number);
if (offset == V8DebuggerScript::kNoOffset) return String16();
const String16& source = script.source();
String16 hint =
source.substring(offset, kBreakpointHintMaxLength).stripWhiteSpace();
for (size_t i = 0; i < hint.length(); ++i) {
if (hint[i] == '\r' || hint[i] == '\n' || hint[i] == ';') {
return hint.substring(0, i);
}
}
return hint;
}
void adjustBreakpointLocation(const V8DebuggerScript& script,
const String16& hint,
ScriptBreakpoint* breakpoint) {
if (hint.isEmpty()) return;
intptr_t sourceOffset =
script.offset(breakpoint->line_number, breakpoint->column_number);
if (sourceOffset == V8DebuggerScript::kNoOffset) return;
intptr_t searchRegionOffset = std::max(
sourceOffset - kBreakpointHintMaxSearchOffset, static_cast<intptr_t>(0));
size_t offset = sourceOffset - searchRegionOffset;
String16 searchArea = script.source().substring(
searchRegionOffset, offset + kBreakpointHintMaxSearchOffset);
size_t nextMatch = searchArea.find(hint, offset);
size_t prevMatch = searchArea.reverseFind(hint, offset);
if (nextMatch == String16::kNotFound && prevMatch == String16::kNotFound) {
return;
}
size_t bestMatch;
if (nextMatch == String16::kNotFound) {
bestMatch = prevMatch;
} else if (prevMatch == String16::kNotFound) {
bestMatch = nextMatch;
} else {
bestMatch = nextMatch - offset < offset - prevMatch ? nextMatch : prevMatch;
}
bestMatch += searchRegionOffset;
v8::debug::Location hintPosition =
script.location(static_cast<int>(bestMatch));
if (hintPosition.IsEmpty()) return;
breakpoint->line_number = hintPosition.GetLineNumber();
breakpoint->column_number = hintPosition.GetColumnNumber();
}
String16 breakLocationType(v8::debug::BreakLocationType type) {
switch (type) {
case v8::debug::kCallBreakLocation:
return protocol::Debugger::BreakLocation::TypeEnum::Call;
case v8::debug::kReturnBreakLocation:
return protocol::Debugger::BreakLocation::TypeEnum::Return;
case v8::debug::kDebuggerStatementBreakLocation:
return protocol::Debugger::BreakLocation::TypeEnum::DebuggerStatement;
case v8::debug::kCommonBreakLocation:
return String16();
}
return String16();
}
} // namespace
String16 scopeType(v8::debug::ScopeIterator::ScopeType type) {
switch (type) {
case v8::debug::ScopeIterator::ScopeTypeGlobal:
return Scope::TypeEnum::Global;
case v8::debug::ScopeIterator::ScopeTypeLocal:
return Scope::TypeEnum::Local;
case v8::debug::ScopeIterator::ScopeTypeWith:
return Scope::TypeEnum::With;
case v8::debug::ScopeIterator::ScopeTypeClosure:
return Scope::TypeEnum::Closure;
case v8::debug::ScopeIterator::ScopeTypeCatch:
return Scope::TypeEnum::Catch;
case v8::debug::ScopeIterator::ScopeTypeBlock:
return Scope::TypeEnum::Block;
case v8::debug::ScopeIterator::ScopeTypeScript:
return Scope::TypeEnum::Script;
case v8::debug::ScopeIterator::ScopeTypeEval:
return Scope::TypeEnum::Eval;
case v8::debug::ScopeIterator::ScopeTypeModule:
return Scope::TypeEnum::Module;
}
UNREACHABLE();
return String16();
}
namespace {
Response buildScopes(v8::debug::ScopeIterator* iterator,
InjectedScript* injectedScript,
std::unique_ptr<Array<Scope>>* scopes) {
*scopes = Array<Scope>::create();
if (!injectedScript) return Response::OK();
for (; !iterator->Done(); iterator->Advance()) {
std::unique_ptr<RemoteObject> object;
Response result = injectedScript->wrapObject(
iterator->GetObject(), kBacktraceObjectGroup, false, false, &object);
if (!result.isSuccess()) return result;
auto scope = Scope::create()
.setType(scopeType(iterator->GetType()))
.setObject(std::move(object))
.build();
v8::Local<v8::Function> closure = iterator->GetFunction();
if (!closure.IsEmpty()) {
String16 name = toProtocolStringWithTypeCheck(closure->GetDebugName());
if (!name.isEmpty()) scope->setName(name);
String16 scriptId = String16::fromInteger(closure->ScriptId());
v8::debug::Location start = iterator->GetStartLocation();
scope->setStartLocation(protocol::Debugger::Location::create()
.setScriptId(scriptId)
.setLineNumber(start.GetLineNumber())
.setColumnNumber(start.GetColumnNumber())
.build());
v8::debug::Location end = iterator->GetEndLocation();
scope->setEndLocation(protocol::Debugger::Location::create()
.setScriptId(scriptId)
.setLineNumber(end.GetLineNumber())
.setColumnNumber(end.GetColumnNumber())
.build());
}
(*scopes)->addItem(std::move(scope));
}
return Response::OK();
}
bool liveEditExceptionToDetails(
V8InspectorImpl* inspector, v8::Local<v8::Context> context,
v8::Local<v8::Value> exceptionValue,
Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails) {
if (!exceptionValue->IsObject()) return false;
v8::Isolate* isolate = context->GetIsolate();
v8::Local<v8::Object> exception = exceptionValue.As<v8::Object>();
v8::Local<v8::Value> detailsValue;
if (!exception->Get(context, toV8String(isolate, "details"))
.ToLocal(&detailsValue) ||
!detailsValue->IsObject()) {
return false;
}
v8::Local<v8::Object> details = detailsValue.As<v8::Object>();
v8::Local<v8::Value> message;
if (!details->Get(context, toV8String(isolate, "syntaxErrorMessage"))
.ToLocal(&message) ||
!message->IsString()) {
return false;
}
v8::Local<v8::Value> positionValue;
if (!details->Get(context, toV8String(isolate, "position"))
.ToLocal(&positionValue) ||
!positionValue->IsObject()) {
return false;
}
v8::Local<v8::Value> startPositionValue;
if (!positionValue.As<v8::Object>()
->Get(context, toV8String(isolate, "start"))
.ToLocal(&startPositionValue) ||
!startPositionValue->IsObject()) {
return false;
}
v8::Local<v8::Object> startPosition = startPositionValue.As<v8::Object>();
v8::Local<v8::Value> lineValue;
if (!startPosition->Get(context, toV8String(isolate, "line"))
.ToLocal(&lineValue) ||
!lineValue->IsInt32()) {
return false;
}
v8::Local<v8::Value> columnValue;
if (!startPosition->Get(context, toV8String(isolate, "column"))
.ToLocal(&columnValue) ||
!columnValue->IsInt32()) {
return false;
}
*exceptionDetails =
protocol::Runtime::ExceptionDetails::create()
.setExceptionId(inspector->nextExceptionId())
.setText(toProtocolString(message.As<v8::String>()))
.setLineNumber(lineValue->Int32Value(context).FromJust() - 1)
.setColumnNumber(columnValue->Int32Value(context).FromJust() - 1)
.build();
return true;
}
} // namespace
V8DebuggerAgentImpl::V8DebuggerAgentImpl(
V8InspectorSessionImpl* session, protocol::FrontendChannel* frontendChannel,
protocol::DictionaryValue* state)
: m_inspector(session->inspector()),
m_debugger(m_inspector->debugger()),
m_session(session),
m_enabled(false),
m_state(state),
m_frontend(frontendChannel),
m_isolate(m_inspector->isolate()) {}
V8DebuggerAgentImpl::~V8DebuggerAgentImpl() {}
void V8DebuggerAgentImpl::enableImpl() {
m_enabled = true;
m_state->setBoolean(DebuggerAgentState::debuggerEnabled, true);
m_debugger->enable();
std::vector<std::unique_ptr<V8DebuggerScript>> compiledScripts;
m_debugger->getCompiledScripts(m_session->contextGroupId(), compiledScripts);
for (size_t i = 0; i < compiledScripts.size(); i++)
didParseSource(std::move(compiledScripts[i]), true);
m_breakpointsActive = true;
m_debugger->setBreakpointsActive(true);
if (isPaused()) {
didPause(0, v8::Local<v8::Value>(), std::vector<v8::debug::BreakpointId>(),
false, false, false, false);
}
}
Response V8DebuggerAgentImpl::enable() {
if (enabled()) return Response::OK();
if (!m_inspector->client()->canExecuteScripts(m_session->contextGroupId()))
return Response::Error("Script execution is prohibited");
enableImpl();
return Response::OK();
}
Response V8DebuggerAgentImpl::disable() {
if (!enabled()) return Response::OK();
m_state->setObject(DebuggerAgentState::javaScriptBreakpoints,
protocol::DictionaryValue::create());
m_state->setInteger(DebuggerAgentState::pauseOnExceptionsState,
v8::debug::NoBreakOnException);
m_state->setInteger(DebuggerAgentState::asyncCallStackDepth, 0);
if (isPaused()) m_debugger->continueProgram(m_session->contextGroupId());
if (m_breakpointsActive) {
m_debugger->setBreakpointsActive(false);
m_breakpointsActive = false;
}
m_debugger->disable();
m_blackboxedPositions.clear();
m_blackboxPattern.reset();
resetBlackboxedStateCache();
m_scripts.clear();
for (const auto& it : m_breakpointIdToDebuggerBreakpointIds) {
for (const auto& id : it.second) {
v8::debug::RemoveBreakpoint(m_isolate, id);
}
}
m_breakpointIdToDebuggerBreakpointIds.clear();
m_debugger->setAsyncCallStackDepth(this, 0);
clearBreakDetails();
m_skipAllPauses = false;
m_state->setBoolean(DebuggerAgentState::skipAllPauses, false);
m_state->remove(DebuggerAgentState::blackboxPattern);
m_enabled = false;
m_state->setBoolean(DebuggerAgentState::debuggerEnabled, false);
return Response::OK();
}
void V8DebuggerAgentImpl::restore() {
DCHECK(!m_enabled);
if (!m_state->booleanProperty(DebuggerAgentState::debuggerEnabled, false))
return;
if (!m_inspector->client()->canExecuteScripts(m_session->contextGroupId()))
return;
enableImpl();
int pauseState = v8::debug::NoBreakOnException;
m_state->getInteger(DebuggerAgentState::pauseOnExceptionsState, &pauseState);
setPauseOnExceptionsImpl(pauseState);
m_skipAllPauses =
m_state->booleanProperty(DebuggerAgentState::skipAllPauses, false);
int asyncCallStackDepth = 0;
m_state->getInteger(DebuggerAgentState::asyncCallStackDepth,
&asyncCallStackDepth);
m_debugger->setAsyncCallStackDepth(this, asyncCallStackDepth);
String16 blackboxPattern;
if (m_state->getString(DebuggerAgentState::blackboxPattern,
&blackboxPattern)) {
setBlackboxPattern(blackboxPattern);
}
}
Response V8DebuggerAgentImpl::setBreakpointsActive(bool active) {
if (!enabled()) return Response::Error(kDebuggerNotEnabled);
if (m_breakpointsActive == active) return Response::OK();
m_breakpointsActive = active;
m_debugger->setBreakpointsActive(active);
if (!active && !m_breakReason.empty()) {
clearBreakDetails();
m_debugger->setPauseOnNextStatement(false, m_session->contextGroupId());
}
return Response::OK();
}
Response V8DebuggerAgentImpl::setSkipAllPauses(bool skip) {
m_state->setBoolean(DebuggerAgentState::skipAllPauses, skip);
m_skipAllPauses = skip;
return Response::OK();
}
static std::unique_ptr<protocol::DictionaryValue>
buildObjectForBreakpointCookie(const String16& url, int lineNumber,
int columnNumber, const String16& condition,
bool isRegex, const String16& hint) {
std::unique_ptr<protocol::DictionaryValue> breakpointObject =
protocol::DictionaryValue::create();
breakpointObject->setString(DebuggerAgentState::url, url);
breakpointObject->setInteger(DebuggerAgentState::lineNumber, lineNumber);
breakpointObject->setInteger(DebuggerAgentState::columnNumber, columnNumber);
breakpointObject->setString(DebuggerAgentState::condition, condition);
breakpointObject->setBoolean(DebuggerAgentState::isRegex, isRegex);
if (!hint.isEmpty()) {
breakpointObject->setString(DebuggerAgentState::hint, hint);
}
return breakpointObject;
}
static bool matches(V8InspectorImpl* inspector, const String16& url,
const String16& pattern, bool isRegex) {
if (isRegex) {
V8Regex regex(inspector, pattern, true);
return regex.match(url) != -1;
}
return url == pattern;
}
Response V8DebuggerAgentImpl::setBreakpointByUrl(
int lineNumber, Maybe<String16> optionalURL,
Maybe<String16> optionalURLRegex, Maybe<int> optionalColumnNumber,
Maybe<String16> optionalCondition, String16* outBreakpointId,
std::unique_ptr<protocol::Array<protocol::Debugger::Location>>* locations) {
*locations = Array<protocol::Debugger::Location>::create();
if (optionalURL.isJust() == optionalURLRegex.isJust())
return Response::Error("Either url or urlRegex must be specified.");
String16 url = optionalURL.isJust() ? optionalURL.fromJust()
: optionalURLRegex.fromJust();
int columnNumber = 0;
if (optionalColumnNumber.isJust()) {
columnNumber = optionalColumnNumber.fromJust();
if (columnNumber < 0) return Response::Error("Incorrect column number");
}
String16 condition = optionalCondition.fromMaybe("");
bool isRegex = optionalURLRegex.isJust();
String16 breakpointId = (isRegex ? "/" + url + "/" : url) + ":" +
String16::fromInteger(lineNumber) + ":" +
String16::fromInteger(columnNumber);
protocol::DictionaryValue* breakpointsCookie =
m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
if (!breakpointsCookie) {
std::unique_ptr<protocol::DictionaryValue> newValue =
protocol::DictionaryValue::create();
breakpointsCookie = newValue.get();
m_state->setObject(DebuggerAgentState::javaScriptBreakpoints,
std::move(newValue));
}
if (breakpointsCookie->get(breakpointId))
return Response::Error("Breakpoint at specified location already exists.");
String16 hint;
ScriptBreakpoint breakpoint(String16(), lineNumber, columnNumber, condition);
for (const auto& script : m_scripts) {
if (!matches(m_inspector, script.second->sourceURL(), url, isRegex))
continue;
breakpoint.script_id = script.first;
std::unique_ptr<protocol::Debugger::Location> location =
resolveBreakpoint(breakpointId, breakpoint, UserBreakpointSource, hint);
if (!isRegex) hint = breakpointHint(*script.second, breakpoint);
if (location) (*locations)->addItem(std::move(location));
}
breakpointsCookie->setObject(
breakpointId,
buildObjectForBreakpointCookie(url, lineNumber, columnNumber, condition,
isRegex, hint));
*outBreakpointId = breakpointId;
return Response::OK();
}
Response V8DebuggerAgentImpl::setBreakpoint(
std::unique_ptr<protocol::Debugger::Location> location,
Maybe<String16> optionalCondition, String16* outBreakpointId,
std::unique_ptr<protocol::Debugger::Location>* actualLocation) {
ScriptBreakpoint breakpoint(
location->getScriptId(), location->getLineNumber(),
location->getColumnNumber(0), optionalCondition.fromMaybe(String16()));
String16 breakpointId =
generateBreakpointId(breakpoint, UserBreakpointSource);
if (m_breakpointIdToDebuggerBreakpointIds.find(breakpointId) !=
m_breakpointIdToDebuggerBreakpointIds.end()) {
return Response::Error("Breakpoint at specified location already exists.");
}
*actualLocation = resolveBreakpoint(
breakpointId, breakpoint, UserBreakpointSource, /* hint */ String16());
if (!*actualLocation) return Response::Error("Could not resolve breakpoint");
*outBreakpointId = breakpointId;
return Response::OK();
}
Response V8DebuggerAgentImpl::removeBreakpoint(const String16& breakpointId) {
if (!enabled()) return Response::Error(kDebuggerNotEnabled);
protocol::DictionaryValue* breakpointsCookie =
m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
if (breakpointsCookie) breakpointsCookie->remove(breakpointId);
removeBreakpointImpl(breakpointId);
return Response::OK();
}
void V8DebuggerAgentImpl::removeBreakpointImpl(const String16& breakpointId) {
DCHECK(enabled());
BreakpointIdToDebuggerBreakpointIdsMap::iterator
debuggerBreakpointIdsIterator =
m_breakpointIdToDebuggerBreakpointIds.find(breakpointId);
if (debuggerBreakpointIdsIterator ==
m_breakpointIdToDebuggerBreakpointIds.end()) {
return;
}
for (const auto& id : debuggerBreakpointIdsIterator->second) {
v8::debug::RemoveBreakpoint(m_isolate, id);
m_serverBreakpoints.erase(id);
}
m_breakpointIdToDebuggerBreakpointIds.erase(breakpointId);
}
Response V8DebuggerAgentImpl::getPossibleBreakpoints(
std::unique_ptr<protocol::Debugger::Location> start,
Maybe<protocol::Debugger::Location> end, Maybe<bool> restrictToFunction,
std::unique_ptr<protocol::Array<protocol::Debugger::BreakLocation>>*
locations) {
String16 scriptId = start->getScriptId();
if (start->getLineNumber() < 0 || start->getColumnNumber(0) < 0)
return Response::Error(
"start.lineNumber and start.columnNumber should be >= 0");
v8::debug::Location v8Start(start->getLineNumber(),
start->getColumnNumber(0));
v8::debug::Location v8End;
if (end.isJust()) {
if (end.fromJust()->getScriptId() != scriptId)
return Response::Error("Locations should contain the same scriptId");
int line = end.fromJust()->getLineNumber();
int column = end.fromJust()->getColumnNumber(0);
if (line < 0 || column < 0)
return Response::Error(
"end.lineNumber and end.columnNumber should be >= 0");
v8End = v8::debug::Location(line, column);
}
auto it = m_scripts.find(scriptId);
if (it == m_scripts.end()) return Response::Error("Script not found");
std::vector<v8::debug::BreakLocation> v8Locations;
{
v8::HandleScope handleScope(m_isolate);
v8::Local<v8::Context> debuggerContext =
v8::debug::GetDebugContext(m_isolate);
v8::Context::Scope contextScope(debuggerContext);
v8::MicrotasksScope microtasks(m_isolate,
v8::MicrotasksScope::kDoNotRunMicrotasks);
v8::TryCatch tryCatch(m_isolate);
it->second->getPossibleBreakpoints(
v8Start, v8End, restrictToFunction.fromMaybe(false), &v8Locations);
}
*locations = protocol::Array<protocol::Debugger::BreakLocation>::create();
for (size_t i = 0; i < v8Locations.size(); ++i) {
std::unique_ptr<protocol::Debugger::BreakLocation> breakLocation =
protocol::Debugger::BreakLocation::create()
.setScriptId(scriptId)
.setLineNumber(v8Locations[i].GetLineNumber())
.setColumnNumber(v8Locations[i].GetColumnNumber())
.build();
if (v8Locations[i].type() != v8::debug::kCommonBreakLocation) {
breakLocation->setType(breakLocationType(v8Locations[i].type()));
}
(*locations)->addItem(std::move(breakLocation));
}
return Response::OK();
}
Response V8DebuggerAgentImpl::continueToLocation(
std::unique_ptr<protocol::Debugger::Location> location,
Maybe<String16> targetCallFrames) {
if (!enabled()) return Response::Error(kDebuggerNotEnabled);
if (!isPaused()) return Response::Error(kDebuggerNotPaused);
ScriptsMap::iterator it = m_scripts.find(location->getScriptId());
if (it == m_scripts.end()) {
return Response::Error("Cannot continue to specified location");
}
V8DebuggerScript* script = it->second.get();
int contextId = script->executionContextId();
InspectedContext* inspected = m_inspector->getContext(contextId);
if (!inspected)
return Response::Error("Cannot continue to specified location");
v8::Context::Scope contextScope(inspected->context());
return m_debugger->continueToLocation(
m_session->contextGroupId(), script, std::move(location),
targetCallFrames.fromMaybe(
protocol::Debugger::ContinueToLocation::TargetCallFramesEnum::Any));
}
bool V8DebuggerAgentImpl::isFunctionBlackboxed(const String16& scriptId,
const v8::debug::Location& start,
const v8::debug::Location& end) {
ScriptsMap::iterator it = m_scripts.find(scriptId);
if (it == m_scripts.end()) {
// Unknown scripts are blackboxed.
return true;
}
if (m_blackboxPattern) {
const String16& scriptSourceURL = it->second->sourceURL();
if (!scriptSourceURL.isEmpty() &&
m_blackboxPattern->match(scriptSourceURL) != -1)
return true;
}
auto itBlackboxedPositions = m_blackboxedPositions.find(scriptId);
if (itBlackboxedPositions == m_blackboxedPositions.end()) return false;
const std::vector<std::pair<int, int>>& ranges =
itBlackboxedPositions->second;
auto itStartRange = std::lower_bound(
ranges.begin(), ranges.end(),
std::make_pair(start.GetLineNumber(), start.GetColumnNumber()),
positionComparator);
auto itEndRange = std::lower_bound(
itStartRange, ranges.end(),
std::make_pair(end.GetLineNumber(), end.GetColumnNumber()),
positionComparator);
// Ranges array contains positions in script where blackbox state is changed.
// [(0,0) ... ranges[0]) isn't blackboxed, [ranges[0] ... ranges[1]) is
// blackboxed...
return itStartRange == itEndRange &&
std::distance(ranges.begin(), itStartRange) % 2;
}
bool V8DebuggerAgentImpl::acceptsPause(bool isOOMBreak) const {
return enabled() && (isOOMBreak || !m_skipAllPauses);
}
std::unique_ptr<protocol::Debugger::Location>
V8DebuggerAgentImpl::resolveBreakpoint(const String16& breakpointId,
const ScriptBreakpoint& breakpoint,
BreakpointSource source,
const String16& hint) {
v8::HandleScope handles(m_isolate);
DCHECK(enabled());
// FIXME: remove these checks once crbug.com/520702 is resolved.
CHECK(!breakpointId.isEmpty());
CHECK(!breakpoint.script_id.isEmpty());
ScriptsMap::iterator scriptIterator = m_scripts.find(breakpoint.script_id);
if (scriptIterator == m_scripts.end()) return nullptr;
V8DebuggerScript* script = scriptIterator->second.get();
if (breakpoint.line_number < script->startLine() ||
script->endLine() < breakpoint.line_number)
return nullptr;
// Translate from protocol location to v8 location for the debugger.
ScriptBreakpoint translatedBreakpoint = breakpoint;
adjustBreakpointLocation(*script, hint, &translatedBreakpoint);
m_debugger->wasmTranslation()->TranslateProtocolLocationToWasmScriptLocation(
&translatedBreakpoint.script_id, &translatedBreakpoint.line_number,
&translatedBreakpoint.column_number);
v8::debug::BreakpointId debuggerBreakpointId;
v8::debug::Location location(translatedBreakpoint.line_number,
translatedBreakpoint.column_number);
int contextId = script->executionContextId();
InspectedContext* inspected = m_inspector->getContext(contextId);
if (!inspected) return nullptr;
{
v8::Context::Scope contextScope(inspected->context());
if (!script->setBreakpoint(translatedBreakpoint.condition, &location,
&debuggerBreakpointId)) {
return nullptr;
}
}
int actualLineNumber = location.GetLineNumber();
int actualColumnNumber = location.GetColumnNumber();
// Translate back from v8 location to protocol location for the return value.
m_debugger->wasmTranslation()->TranslateWasmScriptLocationToProtocolLocation(
&translatedBreakpoint.script_id, &actualLineNumber, &actualColumnNumber);
m_serverBreakpoints[debuggerBreakpointId] =
std::make_pair(breakpointId, source);
CHECK(!breakpointId.isEmpty());
m_breakpointIdToDebuggerBreakpointIds[breakpointId].push_back(
debuggerBreakpointId);
return buildProtocolLocation(translatedBreakpoint.script_id, actualLineNumber,
actualColumnNumber);
}
Response V8DebuggerAgentImpl::searchInContent(
const String16& scriptId, const String16& query,
Maybe<bool> optionalCaseSensitive, Maybe<bool> optionalIsRegex,
std::unique_ptr<Array<protocol::Debugger::SearchMatch>>* results) {
v8::HandleScope handles(m_isolate);
ScriptsMap::iterator it = m_scripts.find(scriptId);
if (it == m_scripts.end())
return Response::Error("No script for id: " + scriptId);
std::vector<std::unique_ptr<protocol::Debugger::SearchMatch>> matches =
searchInTextByLinesImpl(m_session, it->second->source(), query,
optionalCaseSensitive.fromMaybe(false),
optionalIsRegex.fromMaybe(false));
*results = protocol::Array<protocol::Debugger::SearchMatch>::create();
for (size_t i = 0; i < matches.size(); ++i)
(*results)->addItem(std::move(matches[i]));
return Response::OK();
}
Response V8DebuggerAgentImpl::setScriptSource(
const String16& scriptId, const String16& newContent, Maybe<bool> dryRun,
Maybe<protocol::Array<protocol::Debugger::CallFrame>>* newCallFrames,
Maybe<bool>* stackChanged,
Maybe<protocol::Runtime::StackTrace>* asyncStackTrace,
Maybe<protocol::Runtime::ExceptionDetails>* optOutCompileError) {
if (!enabled()) return Response::Error(kDebuggerNotEnabled);
ScriptsMap::iterator it = m_scripts.find(scriptId);
if (it == m_scripts.end()) {
return Response::Error("No script with given id found");
}
if (it->second->isModule()) {
// TODO(kozyatinskiy): LiveEdit should support ES6 module
return Response::Error("Editing module's script is not supported.");
}
int contextId = it->second->executionContextId();
InspectedContext* inspected = m_inspector->getContext(contextId);
if (!inspected) {
return Response::InternalError();
}
v8::HandleScope handleScope(m_isolate);
v8::Local<v8::Context> context = inspected->context();
v8::Context::Scope contextScope(context);
v8::TryCatch tryCatch(m_isolate);
bool stackChangedValue = false;
it->second->setSource(newContent, dryRun.fromMaybe(false),
&stackChangedValue);
if (tryCatch.HasCaught()) {
if (liveEditExceptionToDetails(m_inspector, context, tryCatch.Exception(),
optOutCompileError)) {
return Response::OK();
}
v8::Local<v8::Message> message = tryCatch.Message();
if (!message.IsEmpty())
return Response::Error(toProtocolStringWithTypeCheck(message->Get()));
else
return Response::InternalError();
} else {
*stackChanged = stackChangedValue;
}
std::unique_ptr<Array<CallFrame>> callFrames;
Response response = currentCallFrames(&callFrames);
if (!response.isSuccess()) return response;
*newCallFrames = std::move(callFrames);
*asyncStackTrace = currentAsyncStackTrace();
return Response::OK();
}
Response V8DebuggerAgentImpl::restartFrame(
const String16& callFrameId,
std::unique_ptr<Array<CallFrame>>* newCallFrames,
Maybe<protocol::Runtime::StackTrace>* asyncStackTrace) {
if (!isPaused()) return Response::Error(kDebuggerNotPaused);
InjectedScript::CallFrameScope scope(m_session, callFrameId);
Response response = scope.initialize();
if (!response.isSuccess()) return response;
int frameOrdinal = static_cast<int>(scope.frameOrdinal());
auto it = v8::debug::StackTraceIterator::Create(m_isolate, frameOrdinal);
if (it->Done()) {
return Response::Error("Could not find call frame with given id");
}
if (!it->Restart()) {
return Response::InternalError();
}
response = currentCallFrames(newCallFrames);
if (!response.isSuccess()) return response;
*asyncStackTrace = currentAsyncStackTrace();
return Response::OK();
}
Response V8DebuggerAgentImpl::getScriptSource(const String16& scriptId,
String16* scriptSource) {
if (!enabled()) return Response::Error(kDebuggerNotEnabled);
ScriptsMap::iterator it = m_scripts.find(scriptId);
if (it == m_scripts.end())
return Response::Error("No script for id: " + scriptId);
*scriptSource = it->second->source();
return Response::OK();
}
void V8DebuggerAgentImpl::pushBreakDetails(
const String16& breakReason,
std::unique_ptr<protocol::DictionaryValue> breakAuxData) {
m_breakReason.push_back(std::make_pair(breakReason, std::move(breakAuxData)));
}
void V8DebuggerAgentImpl::popBreakDetails() {
if (m_breakReason.empty()) return;
m_breakReason.pop_back();
}
void V8DebuggerAgentImpl::clearBreakDetails() {
std::vector<BreakReason> emptyBreakReason;
m_breakReason.swap(emptyBreakReason);
}
void V8DebuggerAgentImpl::schedulePauseOnNextStatement(
const String16& breakReason,
std::unique_ptr<protocol::DictionaryValue> data) {
if (isPaused() || !acceptsPause(false) || !m_breakpointsActive) return;
if (m_breakReason.empty()) {
m_debugger->setPauseOnNextStatement(true, m_session->contextGroupId());
}
pushBreakDetails(breakReason, std::move(data));
}
void V8DebuggerAgentImpl::cancelPauseOnNextStatement() {
if (isPaused() || !acceptsPause(false) || !m_breakpointsActive) return;
if (m_breakReason.size() == 1) {
m_debugger->setPauseOnNextStatement(false, m_session->contextGroupId());
}
popBreakDetails();
}
Response V8DebuggerAgentImpl::pause() {
if (!enabled()) return Response::Error(kDebuggerNotEnabled);
if (isPaused()) return Response::OK();
if (m_breakReason.empty()) {
m_debugger->setPauseOnNextStatement(true, m_session->contextGroupId());
}
pushBreakDetails(protocol::Debugger::Paused::ReasonEnum::Other, nullptr);
return Response::OK();
}
Response V8DebuggerAgentImpl::resume() {
if (!isPaused()) return Response::Error(kDebuggerNotPaused);
m_session->releaseObjectGroup(kBacktraceObjectGroup);
m_debugger->continueProgram(m_session->contextGroupId());
return Response::OK();
}
Response V8DebuggerAgentImpl::stepOver() {
if (!isPaused()) return Response::Error(kDebuggerNotPaused);
m_session->releaseObjectGroup(kBacktraceObjectGroup);
m_debugger->stepOverStatement(m_session->contextGroupId());
return Response::OK();
}
Response V8DebuggerAgentImpl::stepInto() {
if (!isPaused()) return Response::Error(kDebuggerNotPaused);
m_session->releaseObjectGroup(kBacktraceObjectGroup);
m_debugger->stepIntoStatement(m_session->contextGroupId());
return Response::OK();
}
Response V8DebuggerAgentImpl::stepOut() {
if (!isPaused()) return Response::Error(kDebuggerNotPaused);
m_session->releaseObjectGroup(kBacktraceObjectGroup);
m_debugger->stepOutOfFunction(m_session->contextGroupId());
return Response::OK();
}
void V8DebuggerAgentImpl::scheduleStepIntoAsync(
std::unique_ptr<ScheduleStepIntoAsyncCallback> callback) {
if (!isPaused()) {
callback->sendFailure(Response::Error(kDebuggerNotPaused));
return;
}
m_debugger->scheduleStepIntoAsync(std::move(callback),
m_session->contextGroupId());
}
Response V8DebuggerAgentImpl::setPauseOnExceptions(
const String16& stringPauseState) {
if (!enabled()) return Response::Error(kDebuggerNotEnabled);
v8::debug::ExceptionBreakState pauseState;
if (stringPauseState == "none") {
pauseState = v8::debug::NoBreakOnException;
} else if (stringPauseState == "all") {
pauseState = v8::debug::BreakOnAnyException;
} else if (stringPauseState == "uncaught") {
pauseState = v8::debug::BreakOnUncaughtException;
} else {
return Response::Error("Unknown pause on exceptions mode: " +
stringPauseState);
}
setPauseOnExceptionsImpl(pauseState);
return Response::OK();
}
void V8DebuggerAgentImpl::setPauseOnExceptionsImpl(int pauseState) {
// TODO(dgozman): this changes the global state and forces all context groups
// to pause. We should make this flag be per-context-group.
m_debugger->setPauseOnExceptionsState(
static_cast<v8::debug::ExceptionBreakState>(pauseState));
m_state->setInteger(DebuggerAgentState::pauseOnExceptionsState, pauseState);
}
Response V8DebuggerAgentImpl::evaluateOnCallFrame(
const String16& callFrameId, const String16& expression,
Maybe<String16> objectGroup, Maybe<bool> includeCommandLineAPI,
Maybe<bool> silent, Maybe<bool> returnByValue, Maybe<bool> generatePreview,
Maybe<bool> throwOnSideEffect, std::unique_ptr<RemoteObject>* result,
Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails) {
if (!isPaused()) return Response::Error(kDebuggerNotPaused);
InjectedScript::CallFrameScope scope(m_session, callFrameId);
Response response = scope.initialize();
if (!response.isSuccess()) return response;
if (includeCommandLineAPI.fromMaybe(false)) scope.installCommandLineAPI();
if (silent.fromMaybe(false)) scope.ignoreExceptionsAndMuteConsole();
int frameOrdinal = static_cast<int>(scope.frameOrdinal());
auto it = v8::debug::StackTraceIterator::Create(m_isolate, frameOrdinal);
if (it->Done()) {
return Response::Error("Could not find call frame with given id");
}
v8::MaybeLocal<v8::Value> maybeResultValue = it->Evaluate(
toV8String(m_isolate, expression), throwOnSideEffect.fromMaybe(false));
// Re-initialize after running client's code, as it could have destroyed
// context or session.
response = scope.initialize();
if (!response.isSuccess()) return response;
return scope.injectedScript()->wrapEvaluateResult(
maybeResultValue, scope.tryCatch(), objectGroup.fromMaybe(""),
returnByValue.fromMaybe(false), generatePreview.fromMaybe(false), result,
exceptionDetails);
}
Response V8DebuggerAgentImpl::setVariableValue(
int scopeNumber, const String16& variableName,
std::unique_ptr<protocol::Runtime::CallArgument> newValueArgument,
const String16& callFrameId) {
if (!enabled()) return Response::Error(kDebuggerNotEnabled);
if (!isPaused()) return Response::Error(kDebuggerNotPaused);
InjectedScript::CallFrameScope scope(m_session, callFrameId);
Response response = scope.initialize();
if (!response.isSuccess()) return response;
v8::Local<v8::Value> newValue;
response = scope.injectedScript()->resolveCallArgument(newValueArgument.get(),
&newValue);
if (!response.isSuccess()) return response;
int frameOrdinal = static_cast<int>(scope.frameOrdinal());
auto it = v8::debug::StackTraceIterator::Create(m_isolate, frameOrdinal);
if (it->Done()) {
return Response::Error("Could not find call frame with given id");
}
auto scopeIterator = it->GetScopeIterator();
while (!scopeIterator->Done() && scopeNumber > 0) {
--scopeNumber;
scopeIterator->Advance();
}
if (scopeNumber != 0) {
return Response::Error("Could not find scope with given number");
}
if (!scopeIterator->SetVariableValue(toV8String(m_isolate, variableName),
newValue) ||
scope.tryCatch().HasCaught()) {
return Response::InternalError();
}
return Response::OK();
}
Response V8DebuggerAgentImpl::setAsyncCallStackDepth(int depth) {
if (!enabled()) return Response::Error(kDebuggerNotEnabled);
m_state->setInteger(DebuggerAgentState::asyncCallStackDepth, depth);
m_debugger->setAsyncCallStackDepth(this, depth);
return Response::OK();
}
Response V8DebuggerAgentImpl::setBlackboxPatterns(
std::unique_ptr<protocol::Array<String16>> patterns) {
if (!patterns->length()) {
m_blackboxPattern = nullptr;
resetBlackboxedStateCache();
m_state->remove(DebuggerAgentState::blackboxPattern);
return Response::OK();
}
String16Builder patternBuilder;
patternBuilder.append('(');
for (size_t i = 0; i < patterns->length() - 1; ++i) {
patternBuilder.append(patterns->get(i));
patternBuilder.append("|");
}
patternBuilder.append(patterns->get(patterns->length() - 1));
patternBuilder.append(')');
String16 pattern = patternBuilder.toString();
Response response = setBlackboxPattern(pattern);
if (!response.isSuccess()) return response;
resetBlackboxedStateCache();
m_state->setString(DebuggerAgentState::blackboxPattern, pattern);
return Response::OK();
}
Response V8DebuggerAgentImpl::setBlackboxPattern(const String16& pattern) {
std::unique_ptr<V8Regex> regex(new V8Regex(
m_inspector, pattern, true /** caseSensitive */, false /** multiline */));
if (!regex->isValid())
return Response::Error("Pattern parser error: " + regex->errorMessage());
m_blackboxPattern = std::move(regex);
return Response::OK();
}
void V8DebuggerAgentImpl::resetBlackboxedStateCache() {
for (const auto& it : m_scripts) {
it.second->resetBlackboxedStateCache();
}
}
Response V8DebuggerAgentImpl::setBlackboxedRanges(
const String16& scriptId,
std::unique_ptr<protocol::Array<protocol::Debugger::ScriptPosition>>
inPositions) {
auto it = m_scripts.find(scriptId);
if (it == m_scripts.end())
return Response::Error("No script with passed id.");
if (!inPositions->length()) {
m_blackboxedPositions.erase(scriptId);
it->second->resetBlackboxedStateCache();
return Response::OK();
}
std::vector<std::pair<int, int>> positions;
positions.reserve(inPositions->length());
for (size_t i = 0; i < inPositions->length(); ++i) {
protocol::Debugger::ScriptPosition* position = inPositions->get(i);
if (position->getLineNumber() < 0)
return Response::Error("Position missing 'line' or 'line' < 0.");
if (position->getColumnNumber() < 0)
return Response::Error("Position missing 'column' or 'column' < 0.");
positions.push_back(
std::make_pair(position->getLineNumber(), position->getColumnNumber()));
}
for (size_t i = 1; i < positions.size(); ++i) {
if (positions[i - 1].first < positions[i].first) continue;
if (positions[i - 1].first == positions[i].first &&
positions[i - 1].second < positions[i].second)
continue;
return Response::Error(
"Input positions array is not sorted or contains duplicate values.");
}
m_blackboxedPositions[scriptId] = positions;
it->second->resetBlackboxedStateCache();
return Response::OK();
}
Response V8DebuggerAgentImpl::currentCallFrames(
std::unique_ptr<Array<CallFrame>>* result) {
if (!isPaused()) {
*result = Array<CallFrame>::create();
return Response::OK();
}
v8::HandleScope handles(m_isolate);
*result = Array<CallFrame>::create();
auto iterator = v8::debug::StackTraceIterator::Create(m_isolate);
int frameOrdinal = 0;
for (; !iterator->Done(); iterator->Advance(), frameOrdinal++) {
int contextId = iterator->GetContextId();
InjectedScript* injectedScript = nullptr;
if (contextId) m_session->findInjectedScript(contextId, injectedScript);
String16 callFrameId =
RemoteCallFrameId::serialize(contextId, frameOrdinal);
v8::debug::Location loc = iterator->GetSourceLocation();
std::unique_ptr<Array<Scope>> scopes;
auto scopeIterator = iterator->GetScopeIterator();
Response res = buildScopes(scopeIterator.get(), injectedScript, &scopes);
if (!res.isSuccess()) return res;
std::unique_ptr<RemoteObject> receiver;
if (injectedScript) {
res = injectedScript->wrapObject(iterator->GetReceiver(),
kBacktraceObjectGroup, false, false,
&receiver);
if (!res.isSuccess()) return res;
} else {
receiver = RemoteObject::create()
.setType(RemoteObject::TypeEnum::Undefined)
.build();
}
v8::Local<v8::debug::Script> script = iterator->GetScript();
DCHECK(!script.IsEmpty());
std::unique_ptr<protocol::Debugger::Location> location =
protocol::Debugger::Location::create()
.setScriptId(String16::fromInteger(script->Id()))
.setLineNumber(loc.GetLineNumber())
.setColumnNumber(loc.GetColumnNumber())
.build();
TranslateLocation(location.get(), m_debugger->wasmTranslation());
String16 scriptId = String16::fromInteger(script->Id());
ScriptsMap::iterator scriptIterator =
m_scripts.find(location->getScriptId());
String16 url;
if (scriptIterator != m_scripts.end()) {
url = scriptIterator->second->sourceURL();
}
auto frame =
CallFrame::create()
.setCallFrameId(callFrameId)
.setFunctionName(toProtocolString(iterator->GetFunctionName()))
.setLocation(std::move(location))
.setUrl(url)
.setScopeChain(std::move(scopes))
.setThis(std::move(receiver))
.build();
v8::Local<v8::Function> func = iterator->GetFunction();
if (!func.IsEmpty()) {
frame->setFunctionLocation(
protocol::Debugger::Location::create()
.setScriptId(String16::fromInteger(func->ScriptId()))
.setLineNumber(func->GetScriptLineNumber())
.setColumnNumber(func->GetScriptColumnNumber())
.build());
}
v8::Local<v8::Value> returnValue = iterator->GetReturnValue();
if (!returnValue.IsEmpty() && injectedScript) {
std::unique_ptr<RemoteObject> value;
res = injectedScript->wrapObject(returnValue, kBacktraceObjectGroup,
false, false, &value);
if (!res.isSuccess()) return res;
frame->setReturnValue(std::move(value));
}
(*result)->addItem(std::move(frame));
}
return Response::OK();
}
std::unique_ptr<protocol::Runtime::StackTrace>
V8DebuggerAgentImpl::currentAsyncStackTrace() {
std::shared_ptr<AsyncStackTrace> asyncParent =
m_debugger->currentAsyncParent();
if (!asyncParent) return nullptr;
return asyncParent->buildInspectorObject(
m_debugger->currentAsyncCreation().get(),
m_debugger->maxAsyncCallChainDepth() - 1);
}
bool V8DebuggerAgentImpl::isPaused() const {
return m_debugger->isPausedInContextGroup(m_session->contextGroupId());
}
void V8DebuggerAgentImpl::didParseSource(
std::unique_ptr<V8DebuggerScript> script, bool success) {
v8::HandleScope handles(m_isolate);
String16 scriptSource = script->source();
if (!success) script->setSourceURL(findSourceURL(scriptSource, false));
if (!success)
script->setSourceMappingURL(findSourceMapURL(scriptSource, false));
int contextId = script->executionContextId();
int contextGroupId = m_inspector->contextGroupId(contextId);
InspectedContext* inspected =
m_inspector->getContext(contextGroupId, contextId);
std::unique_ptr<protocol::DictionaryValue> executionContextAuxData;
if (inspected) {
// Script reused between different groups/sessions can have a stale
// execution context id.
executionContextAuxData = protocol::DictionaryValue::cast(
protocol::StringUtil::parseJSON(inspected->auxData()));
}
bool isLiveEdit = script->isLiveEdit();
bool hasSourceURL = script->hasSourceURL();
bool isModule = script->isModule();
String16 scriptId = script->scriptId();
String16 scriptURL = script->sourceURL();
m_scripts[scriptId] = std::move(script);
ScriptsMap::iterator scriptIterator = m_scripts.find(scriptId);
DCHECK(scriptIterator != m_scripts.end());
V8DebuggerScript* scriptRef = scriptIterator->second.get();
// V8 could create functions for parsed scripts before reporting and asks
// inspector about blackboxed state, we should reset state each time when we
// make any change that change isFunctionBlackboxed output - adding parsed
// script is changing.
scriptRef->resetBlackboxedStateCache();
Maybe<String16> sourceMapURLParam = scriptRef->sourceMappingURL();
Maybe<protocol::DictionaryValue> executionContextAuxDataParam(
std::move(executionContextAuxData));
const bool* isLiveEditParam = isLiveEdit ? &isLiveEdit : nullptr;
const bool* hasSourceURLParam = hasSourceURL ? &hasSourceURL : nullptr;
const bool* isModuleParam = isModule ? &isModule : nullptr;
std::unique_ptr<V8StackTraceImpl> stack =
V8StackTraceImpl::capture(m_inspector->debugger(), contextGroupId, 1);
std::unique_ptr<protocol::Runtime::StackTrace> stackTrace =
stack && !stack->isEmpty() ? stack->buildInspectorObjectImpl() : nullptr;
if (success) {
m_frontend.scriptParsed(
scriptId, scriptURL, scriptRef->startLine(), scriptRef->startColumn(),
scriptRef->endLine(), scriptRef->endColumn(), contextId,
scriptRef->hash(), std::move(executionContextAuxDataParam),
isLiveEditParam, std::move(sourceMapURLParam), hasSourceURLParam,
isModuleParam, static_cast<int>(scriptRef->source().length()),
std::move(stackTrace));
} else {
m_frontend.scriptFailedToParse(
scriptId, scriptURL, scriptRef->startLine(), scriptRef->startColumn(),
scriptRef->endLine(), scriptRef->endColumn(), contextId,
scriptRef->hash(), std::move(executionContextAuxDataParam),
std::move(sourceMapURLParam), hasSourceURLParam, isModuleParam,
static_cast<int>(scriptRef->source().length()), std::move(stackTrace));
}
if (scriptURL.isEmpty() || !success) return;
protocol::DictionaryValue* breakpointsCookie =
m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
if (!breakpointsCookie) return;
for (size_t i = 0; i < breakpointsCookie->size(); ++i) {
auto cookie = breakpointsCookie->at(i);
protocol::DictionaryValue* breakpointObject =
protocol::DictionaryValue::cast(cookie.second);
bool isRegex;
breakpointObject->getBoolean(DebuggerAgentState::isRegex, &isRegex);
String16 url;
breakpointObject->getString(DebuggerAgentState::url, &url);
if (!matches(m_inspector, scriptURL, url, isRegex)) continue;
ScriptBreakpoint breakpoint;
breakpoint.script_id = scriptId;
breakpointObject->getInteger(DebuggerAgentState::lineNumber,
&breakpoint.line_number);
breakpointObject->getInteger(DebuggerAgentState::columnNumber,
&breakpoint.column_number);
breakpointObject->getString(DebuggerAgentState::condition,
&breakpoint.condition);
String16 hint;
bool hasHint = breakpointObject->getString(DebuggerAgentState::hint, &hint);
std::unique_ptr<protocol::Debugger::Location> location =
resolveBreakpoint(cookie.first, breakpoint, UserBreakpointSource, hint);
if (!hasHint) {
hint = breakpointHint(*scriptRef, breakpoint);
if (!hint.isEmpty())
breakpointObject->setString(DebuggerAgentState::hint, hint);
}
if (location)
m_frontend.breakpointResolved(cookie.first, std::move(location));
}
}
void V8DebuggerAgentImpl::didPause(
int contextId, v8::Local<v8::Value> exception,
const std::vector<v8::debug::BreakpointId>& hitBreakpoints,
bool isPromiseRejection, bool isUncaught, bool isOOMBreak, bool isAssert) {
v8::HandleScope handles(m_isolate);
std::vector<BreakReason> hitReasons;
if (isOOMBreak) {
hitReasons.push_back(
std::make_pair(protocol::Debugger::Paused::ReasonEnum::OOM, nullptr));
} else if (isAssert) {
hitReasons.push_back(std::make_pair(
protocol::Debugger::Paused::ReasonEnum::Assert, nullptr));
} else if (!exception.IsEmpty()) {
InjectedScript* injectedScript = nullptr;
m_session->findInjectedScript(contextId, injectedScript);
if (injectedScript) {
String16 breakReason =
isPromiseRejection
? protocol::Debugger::Paused::ReasonEnum::PromiseRejection
: protocol::Debugger::Paused::ReasonEnum::Exception;
std::unique_ptr<protocol::Runtime::RemoteObject> obj;
injectedScript->wrapObject(exception, kBacktraceObjectGroup, false, false,
&obj);
std::unique_ptr<protocol::DictionaryValue> breakAuxData;
if (obj) {
breakAuxData = obj->toValue();
breakAuxData->setBoolean("uncaught", isUncaught);
} else {
breakAuxData = nullptr;
}
hitReasons.push_back(
std::make_pair(breakReason, std::move(breakAuxData)));
}
}
std::unique_ptr<Array<String16>> hitBreakpointIds = Array<String16>::create();
bool hasDebugCommandBreakpointReason = false;
for (const auto& id : hitBreakpoints) {
DebugServerBreakpointToBreakpointIdAndSourceMap::iterator
breakpointIterator = m_serverBreakpoints.find(id);
if (breakpointIterator != m_serverBreakpoints.end()) {
const String16& localId = breakpointIterator->second.first;
hitBreakpointIds->addItem(localId);
BreakpointSource source = breakpointIterator->second.second;
if (!hasDebugCommandBreakpointReason &&
source == DebugCommandBreakpointSource) {
hasDebugCommandBreakpointReason = true;
hitReasons.push_back(std::make_pair(
protocol::Debugger::Paused::ReasonEnum::DebugCommand, nullptr));
}
}
}
for (size_t i = 0; i < m_breakReason.size(); ++i) {
hitReasons.push_back(std::move(m_breakReason[i]));
}
clearBreakDetails();
String16 breakReason = protocol::Debugger::Paused::ReasonEnum::Other;
std::unique_ptr<protocol::DictionaryValue> breakAuxData;
if (hitReasons.size() == 1) {
breakReason = hitReasons[0].first;
breakAuxData = std::move(hitReasons[0].second);
} else if (hitReasons.size() > 1) {
breakReason = protocol::Debugger::Paused::ReasonEnum::Ambiguous;
std::unique_ptr<protocol::ListValue> reasons =
protocol::ListValue::create();
for (size_t i = 0; i < hitReasons.size(); ++i) {
std::unique_ptr<protocol::DictionaryValue> reason =
protocol::DictionaryValue::create();
reason->setString("reason", hitReasons[i].first);
if (hitReasons[i].second)
reason->setObject("auxData", std::move(hitReasons[i].second));
reasons->pushValue(std::move(reason));
}
breakAuxData = protocol::DictionaryValue::create();
breakAuxData->setArray("reasons", std::move(reasons));
}
std::unique_ptr<Array<CallFrame>> protocolCallFrames;
Response response = currentCallFrames(&protocolCallFrames);
if (!response.isSuccess()) protocolCallFrames = Array<CallFrame>::create();
m_frontend.paused(std::move(protocolCallFrames), breakReason,
std::move(breakAuxData), std::move(hitBreakpointIds),
currentAsyncStackTrace());
}
void V8DebuggerAgentImpl::didContinue() {
clearBreakDetails();
m_frontend.resumed();
}
void V8DebuggerAgentImpl::breakProgram(
const String16& breakReason,
std::unique_ptr<protocol::DictionaryValue> data) {
if (!enabled() || m_skipAllPauses || !m_debugger->canBreakProgram()) return;
std::vector<BreakReason> currentScheduledReason;
currentScheduledReason.swap(m_breakReason);
pushBreakDetails(breakReason, std::move(data));
int contextGroupId = m_session->contextGroupId();
int sessionId = m_session->sessionId();
V8InspectorImpl* inspector = m_inspector;
m_debugger->breakProgram(contextGroupId);
// Check that session and |this| are still around.
if (!inspector->sessionById(contextGroupId, sessionId)) return;
if (!enabled()) return;
popBreakDetails();
m_breakReason.swap(currentScheduledReason);
if (!m_breakReason.empty()) {
m_debugger->setPauseOnNextStatement(true, m_session->contextGroupId());
}
}
void V8DebuggerAgentImpl::setBreakpointAt(const String16& scriptId,
int lineNumber, int columnNumber,
BreakpointSource source,
const String16& condition) {
ScriptBreakpoint breakpoint(scriptId, lineNumber, columnNumber, condition);
String16 breakpointId = generateBreakpointId(breakpoint, source);
resolveBreakpoint(breakpointId, breakpoint, source, /* hint */ String16());
}
void V8DebuggerAgentImpl::removeBreakpointAt(const String16& scriptId,
int lineNumber, int columnNumber,
BreakpointSource source) {
removeBreakpointImpl(generateBreakpointId(
ScriptBreakpoint(scriptId, lineNumber, columnNumber, String16()),
source));
}
void V8DebuggerAgentImpl::reset() {
if (!enabled()) return;
m_blackboxedPositions.clear();
resetBlackboxedStateCache();
m_scripts.clear();
m_breakpointIdToDebuggerBreakpointIds.clear();
}
} // namespace v8_inspector