Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(591)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: src/inspector/V8Debugger.cpp

Issue 2292573002: [inspector] Initial import of v8_inspector. (Closed)
Patch Set: format the code, disable cpplint Created 4 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « src/inspector/V8Debugger.h ('k') | src/inspector/V8DebuggerAgentImpl.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/inspector/V8Debugger.cpp
diff --git a/src/inspector/V8Debugger.cpp b/src/inspector/V8Debugger.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dc7fb4859993f3fe8696c43ba5c707543ffd2d17
--- /dev/null
+++ b/src/inspector/V8Debugger.cpp
@@ -0,0 +1,917 @@
+// Copyright 2016 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/V8Debugger.h"
+
+#include "src/inspector/DebuggerScript.h"
+#include "src/inspector/ScriptBreakpoint.h"
+#include "src/inspector/StringUtil.h"
+#include "src/inspector/V8Compat.h"
+#include "src/inspector/V8DebuggerAgentImpl.h"
+#include "src/inspector/V8InspectorImpl.h"
+#include "src/inspector/V8InternalValueType.h"
+#include "src/inspector/V8StackTraceImpl.h"
+#include "src/inspector/V8ValueCopier.h"
+#include "src/inspector/protocol/Protocol.h"
+#include "src/inspector/public/V8InspectorClient.h"
+
+namespace v8_inspector {
+
+namespace {
+const char stepIntoV8MethodName[] = "stepIntoStatement";
+const char stepOutV8MethodName[] = "stepOutOfFunction";
+static const char v8AsyncTaskEventEnqueue[] = "enqueue";
+static const char v8AsyncTaskEventWillHandle[] = "willHandle";
+static const char v8AsyncTaskEventDidHandle[] = "didHandle";
+
+inline v8::Local<v8::Boolean> v8Boolean(bool value, v8::Isolate* isolate) {
+ return value ? v8::True(isolate) : v8::False(isolate);
+}
+
+} // namespace
+
+static bool inLiveEditScope = false;
+
+v8::MaybeLocal<v8::Value> V8Debugger::callDebuggerMethod(
+ const char* functionName, int argc, v8::Local<v8::Value> argv[]) {
+ v8::MicrotasksScope microtasks(m_isolate,
+ v8::MicrotasksScope::kDoNotRunMicrotasks);
+ v8::Local<v8::Object> debuggerScript = m_debuggerScript.Get(m_isolate);
+ v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
+ debuggerScript->Get(toV8StringInternalized(m_isolate, functionName)));
+ DCHECK(m_isolate->InContext());
+ return function->Call(m_isolate->GetCurrentContext(), debuggerScript, argc,
+ argv);
+}
+
+V8Debugger::V8Debugger(v8::Isolate* isolate, V8InspectorImpl* inspector)
+ : m_isolate(isolate),
+ m_inspector(inspector),
+ m_lastContextId(0),
+ m_enableCount(0),
+ m_breakpointsActivated(true),
+ m_runningNestedMessageLoop(false),
+ m_ignoreScriptParsedEventsCounter(0),
+ m_maxAsyncCallStackDepth(0) {}
+
+V8Debugger::~V8Debugger() {}
+
+void V8Debugger::enable() {
+ if (m_enableCount++) return;
+ DCHECK(!enabled());
+ v8::HandleScope scope(m_isolate);
+ v8::Debug::SetDebugEventListener(m_isolate, &V8Debugger::v8DebugEventCallback,
+ v8::External::New(m_isolate, this));
+ m_debuggerContext.Reset(m_isolate, v8::Debug::GetDebugContext(m_isolate));
+ compileDebuggerScript();
+}
+
+void V8Debugger::disable() {
+ if (--m_enableCount) return;
+ DCHECK(enabled());
+ clearBreakpoints();
+ m_debuggerScript.Reset();
+ m_debuggerContext.Reset();
+ allAsyncTasksCanceled();
+ v8::Debug::SetDebugEventListener(m_isolate, nullptr);
+}
+
+bool V8Debugger::enabled() const { return !m_debuggerScript.IsEmpty(); }
+
+// static
+int V8Debugger::contextId(v8::Local<v8::Context> context) {
+ v8::Local<v8::Value> data =
+ context->GetEmbedderData(static_cast<int>(v8::Context::kDebugIdIndex));
+ if (data.IsEmpty() || !data->IsString()) return 0;
+ String16 dataString = toProtocolString(data.As<v8::String>());
+ if (dataString.isEmpty()) return 0;
+ size_t commaPos = dataString.find(",");
+ if (commaPos == String16::kNotFound) return 0;
+ size_t commaPos2 = dataString.find(",", commaPos + 1);
+ if (commaPos2 == String16::kNotFound) return 0;
+ return dataString.substring(commaPos + 1, commaPos2 - commaPos - 1)
+ .toInteger();
+}
+
+// static
+int V8Debugger::getGroupId(v8::Local<v8::Context> context) {
+ v8::Local<v8::Value> data =
+ context->GetEmbedderData(static_cast<int>(v8::Context::kDebugIdIndex));
+ if (data.IsEmpty() || !data->IsString()) return 0;
+ String16 dataString = toProtocolString(data.As<v8::String>());
+ if (dataString.isEmpty()) return 0;
+ size_t commaPos = dataString.find(",");
+ if (commaPos == String16::kNotFound) return 0;
+ return dataString.substring(0, commaPos).toInteger();
+}
+
+void V8Debugger::getCompiledScripts(
+ int contextGroupId,
+ std::vector<std::unique_ptr<V8DebuggerScript>>& result) {
+ v8::HandleScope scope(m_isolate);
+ v8::MicrotasksScope microtasks(m_isolate,
+ v8::MicrotasksScope::kDoNotRunMicrotasks);
+ v8::Local<v8::Object> debuggerScript = m_debuggerScript.Get(m_isolate);
+ DCHECK(!debuggerScript->IsUndefined());
+ v8::Local<v8::Function> getScriptsFunction = v8::Local<v8::Function>::Cast(
+ debuggerScript->Get(toV8StringInternalized(m_isolate, "getScripts")));
+ v8::Local<v8::Value> argv[] = {v8::Integer::New(m_isolate, contextGroupId)};
+ v8::Local<v8::Value> value;
+ if (!getScriptsFunction
+ ->Call(debuggerContext(), debuggerScript,
+ V8_INSPECTOR_ARRAY_LENGTH(argv), argv)
+ .ToLocal(&value))
+ return;
+ DCHECK(value->IsArray());
+ v8::Local<v8::Array> scriptsArray = v8::Local<v8::Array>::Cast(value);
+ result.reserve(scriptsArray->Length());
+ for (unsigned i = 0; i < scriptsArray->Length(); ++i) {
+ v8::Local<v8::Object> scriptObject = v8::Local<v8::Object>::Cast(
+ scriptsArray->Get(v8::Integer::New(m_isolate, i)));
+ result.push_back(wrapUnique(
+ new V8DebuggerScript(m_isolate, scriptObject, inLiveEditScope)));
+ }
+}
+
+String16 V8Debugger::setBreakpoint(const String16& sourceID,
+ const ScriptBreakpoint& scriptBreakpoint,
+ int* actualLineNumber,
+ int* actualColumnNumber) {
+ v8::HandleScope scope(m_isolate);
+ v8::Context::Scope contextScope(debuggerContext());
+
+ v8::Local<v8::Object> info = v8::Object::New(m_isolate);
+ info->Set(toV8StringInternalized(m_isolate, "sourceID"),
+ toV8String(m_isolate, sourceID));
+ info->Set(toV8StringInternalized(m_isolate, "lineNumber"),
+ v8::Integer::New(m_isolate, scriptBreakpoint.lineNumber));
+ info->Set(toV8StringInternalized(m_isolate, "columnNumber"),
+ v8::Integer::New(m_isolate, scriptBreakpoint.columnNumber));
+ info->Set(toV8StringInternalized(m_isolate, "condition"),
+ toV8String(m_isolate, scriptBreakpoint.condition));
+
+ v8::Local<v8::Function> setBreakpointFunction =
+ v8::Local<v8::Function>::Cast(m_debuggerScript.Get(m_isolate)->Get(
+ toV8StringInternalized(m_isolate, "setBreakpoint")));
+ v8::Local<v8::Value> breakpointId =
+ v8::Debug::Call(debuggerContext(), setBreakpointFunction, info)
+ .ToLocalChecked();
+ if (!breakpointId->IsString()) return "";
+ *actualLineNumber =
+ info->Get(toV8StringInternalized(m_isolate, "lineNumber"))->Int32Value();
+ *actualColumnNumber =
+ info->Get(toV8StringInternalized(m_isolate, "columnNumber"))
+ ->Int32Value();
+ return toProtocolString(breakpointId.As<v8::String>());
+}
+
+void V8Debugger::removeBreakpoint(const String16& breakpointId) {
+ v8::HandleScope scope(m_isolate);
+ v8::Context::Scope contextScope(debuggerContext());
+
+ v8::Local<v8::Object> info = v8::Object::New(m_isolate);
+ info->Set(toV8StringInternalized(m_isolate, "breakpointId"),
+ toV8String(m_isolate, breakpointId));
+
+ v8::Local<v8::Function> removeBreakpointFunction =
+ v8::Local<v8::Function>::Cast(m_debuggerScript.Get(m_isolate)->Get(
+ toV8StringInternalized(m_isolate, "removeBreakpoint")));
+ v8::Debug::Call(debuggerContext(), removeBreakpointFunction, info)
+ .ToLocalChecked();
+}
+
+void V8Debugger::clearBreakpoints() {
+ v8::HandleScope scope(m_isolate);
+ v8::Context::Scope contextScope(debuggerContext());
+
+ v8::Local<v8::Function> clearBreakpoints =
+ v8::Local<v8::Function>::Cast(m_debuggerScript.Get(m_isolate)->Get(
+ toV8StringInternalized(m_isolate, "clearBreakpoints")));
+ v8::Debug::Call(debuggerContext(), clearBreakpoints).ToLocalChecked();
+}
+
+void V8Debugger::setBreakpointsActivated(bool activated) {
+ if (!enabled()) {
+ NOTREACHED();
+ return;
+ }
+ v8::HandleScope scope(m_isolate);
+ v8::Context::Scope contextScope(debuggerContext());
+
+ v8::Local<v8::Object> info = v8::Object::New(m_isolate);
+ info->Set(toV8StringInternalized(m_isolate, "enabled"),
+ v8::Boolean::New(m_isolate, activated));
+ v8::Local<v8::Function> setBreakpointsActivated =
+ v8::Local<v8::Function>::Cast(m_debuggerScript.Get(m_isolate)->Get(
+ toV8StringInternalized(m_isolate, "setBreakpointsActivated")));
+ v8::Debug::Call(debuggerContext(), setBreakpointsActivated, info)
+ .ToLocalChecked();
+
+ m_breakpointsActivated = activated;
+}
+
+V8Debugger::PauseOnExceptionsState V8Debugger::getPauseOnExceptionsState() {
+ DCHECK(enabled());
+ v8::HandleScope scope(m_isolate);
+ v8::Context::Scope contextScope(debuggerContext());
+
+ v8::Local<v8::Value> argv[] = {v8::Undefined(m_isolate)};
+ v8::Local<v8::Value> result =
+ callDebuggerMethod("pauseOnExceptionsState", 0, argv).ToLocalChecked();
+ return static_cast<V8Debugger::PauseOnExceptionsState>(result->Int32Value());
+}
+
+void V8Debugger::setPauseOnExceptionsState(
+ PauseOnExceptionsState pauseOnExceptionsState) {
+ DCHECK(enabled());
+ v8::HandleScope scope(m_isolate);
+ v8::Context::Scope contextScope(debuggerContext());
+
+ v8::Local<v8::Value> argv[] = {
+ v8::Int32::New(m_isolate, pauseOnExceptionsState)};
+ callDebuggerMethod("setPauseOnExceptionsState", 1, argv);
+}
+
+void V8Debugger::setPauseOnNextStatement(bool pause) {
+ if (m_runningNestedMessageLoop) return;
+ if (pause)
+ v8::Debug::DebugBreak(m_isolate);
+ else
+ v8::Debug::CancelDebugBreak(m_isolate);
+}
+
+bool V8Debugger::canBreakProgram() {
+ if (!m_breakpointsActivated) return false;
+ return m_isolate->InContext();
+}
+
+void V8Debugger::breakProgram() {
+ if (isPaused()) {
+ DCHECK(!m_runningNestedMessageLoop);
+ v8::Local<v8::Value> exception;
+ v8::Local<v8::Array> hitBreakpoints;
+ handleProgramBreak(m_pausedContext, m_executionState, exception,
+ hitBreakpoints);
+ return;
+ }
+
+ if (!canBreakProgram()) return;
+
+ v8::HandleScope scope(m_isolate);
+ v8::Local<v8::Function> breakFunction;
+ if (!V8_FUNCTION_NEW_REMOVE_PROTOTYPE(m_isolate->GetCurrentContext(),
+ &V8Debugger::breakProgramCallback,
+ v8::External::New(m_isolate, this), 0)
+ .ToLocal(&breakFunction))
+ return;
+ v8::Debug::Call(debuggerContext(), breakFunction).ToLocalChecked();
+}
+
+void V8Debugger::continueProgram() {
+ if (isPaused()) m_inspector->client()->quitMessageLoopOnPause();
+ m_pausedContext.Clear();
+ m_executionState.Clear();
+}
+
+void V8Debugger::stepIntoStatement() {
+ DCHECK(isPaused());
+ DCHECK(!m_executionState.IsEmpty());
+ v8::HandleScope handleScope(m_isolate);
+ v8::Local<v8::Value> argv[] = {m_executionState};
+ callDebuggerMethod(stepIntoV8MethodName, 1, argv);
+ continueProgram();
+}
+
+void V8Debugger::stepOverStatement() {
+ DCHECK(isPaused());
+ DCHECK(!m_executionState.IsEmpty());
+ v8::HandleScope handleScope(m_isolate);
+ v8::Local<v8::Value> argv[] = {m_executionState};
+ callDebuggerMethod("stepOverStatement", 1, argv);
+ continueProgram();
+}
+
+void V8Debugger::stepOutOfFunction() {
+ DCHECK(isPaused());
+ DCHECK(!m_executionState.IsEmpty());
+ v8::HandleScope handleScope(m_isolate);
+ v8::Local<v8::Value> argv[] = {m_executionState};
+ callDebuggerMethod(stepOutV8MethodName, 1, argv);
+ continueProgram();
+}
+
+void V8Debugger::clearStepping() {
+ DCHECK(enabled());
+ v8::HandleScope scope(m_isolate);
+ v8::Context::Scope contextScope(debuggerContext());
+
+ v8::Local<v8::Value> argv[] = {v8::Undefined(m_isolate)};
+ callDebuggerMethod("clearStepping", 0, argv);
+}
+
+bool V8Debugger::setScriptSource(
+ const String16& sourceID, v8::Local<v8::String> newSource, bool dryRun,
+ ErrorString* error,
+ Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails,
+ JavaScriptCallFrames* newCallFrames, Maybe<bool>* stackChanged) {
+ class EnableLiveEditScope {
+ public:
+ explicit EnableLiveEditScope(v8::Isolate* isolate) : m_isolate(isolate) {
+ v8::Debug::SetLiveEditEnabled(m_isolate, true);
+ inLiveEditScope = true;
+ }
+ ~EnableLiveEditScope() {
+ v8::Debug::SetLiveEditEnabled(m_isolate, false);
+ inLiveEditScope = false;
+ }
+
+ private:
+ v8::Isolate* m_isolate;
+ };
+
+ DCHECK(enabled());
+ v8::HandleScope scope(m_isolate);
+
+ std::unique_ptr<v8::Context::Scope> contextScope;
+ if (!isPaused())
+ contextScope = wrapUnique(new v8::Context::Scope(debuggerContext()));
+
+ v8::Local<v8::Value> argv[] = {toV8String(m_isolate, sourceID), newSource,
+ v8Boolean(dryRun, m_isolate)};
+
+ v8::Local<v8::Value> v8result;
+ {
+ EnableLiveEditScope enableLiveEditScope(m_isolate);
+ v8::TryCatch tryCatch(m_isolate);
+ tryCatch.SetVerbose(false);
+ v8::MaybeLocal<v8::Value> maybeResult =
+ callDebuggerMethod("liveEditScriptSource", 3, argv);
+ if (tryCatch.HasCaught()) {
+ v8::Local<v8::Message> message = tryCatch.Message();
+ if (!message.IsEmpty())
+ *error = toProtocolStringWithTypeCheck(message->Get());
+ else
+ *error = "Unknown error.";
+ return false;
+ }
+ v8result = maybeResult.ToLocalChecked();
+ }
+ DCHECK(!v8result.IsEmpty());
+ v8::Local<v8::Object> resultTuple = v8result->ToObject(m_isolate);
+ int code =
+ static_cast<int>(resultTuple->Get(0)->ToInteger(m_isolate)->Value());
+ switch (code) {
+ case 0: {
+ *stackChanged = resultTuple->Get(1)->BooleanValue();
+ // Call stack may have changed after if the edited function was on the
+ // stack.
+ if (!dryRun && isPaused()) {
+ JavaScriptCallFrames frames = currentCallFrames();
+ newCallFrames->swap(frames);
+ }
+ return true;
+ }
+ // Compile error.
+ case 1: {
+ *exceptionDetails =
+ protocol::Runtime::ExceptionDetails::create()
+ .setExceptionId(m_inspector->nextExceptionId())
+ .setText(toProtocolStringWithTypeCheck(resultTuple->Get(2)))
+ .setLineNumber(
+ resultTuple->Get(3)->ToInteger(m_isolate)->Value() - 1)
+ .setColumnNumber(
+ resultTuple->Get(4)->ToInteger(m_isolate)->Value() - 1)
+ .build();
+ return false;
+ }
+ }
+ *error = "Unknown error.";
+ return false;
+}
+
+JavaScriptCallFrames V8Debugger::currentCallFrames(int limit) {
+ if (!m_isolate->InContext()) return JavaScriptCallFrames();
+ v8::Local<v8::Value> currentCallFramesV8;
+ if (m_executionState.IsEmpty()) {
+ v8::Local<v8::Function> currentCallFramesFunction =
+ v8::Local<v8::Function>::Cast(m_debuggerScript.Get(m_isolate)->Get(
+ toV8StringInternalized(m_isolate, "currentCallFrames")));
+ currentCallFramesV8 =
+ v8::Debug::Call(debuggerContext(), currentCallFramesFunction,
+ v8::Integer::New(m_isolate, limit))
+ .ToLocalChecked();
+ } else {
+ v8::Local<v8::Value> argv[] = {m_executionState,
+ v8::Integer::New(m_isolate, limit)};
+ currentCallFramesV8 =
+ callDebuggerMethod("currentCallFrames", V8_INSPECTOR_ARRAY_LENGTH(argv),
+ argv)
+ .ToLocalChecked();
+ }
+ DCHECK(!currentCallFramesV8.IsEmpty());
+ if (!currentCallFramesV8->IsArray()) return JavaScriptCallFrames();
+ v8::Local<v8::Array> callFramesArray = currentCallFramesV8.As<v8::Array>();
+ JavaScriptCallFrames callFrames;
+ for (size_t i = 0; i < callFramesArray->Length(); ++i) {
+ v8::Local<v8::Value> callFrameValue;
+ if (!callFramesArray->Get(debuggerContext(), i).ToLocal(&callFrameValue))
+ return JavaScriptCallFrames();
+ if (!callFrameValue->IsObject()) return JavaScriptCallFrames();
+ v8::Local<v8::Object> callFrameObject = callFrameValue.As<v8::Object>();
+ callFrames.push_back(JavaScriptCallFrame::create(
+ debuggerContext(), v8::Local<v8::Object>::Cast(callFrameObject)));
+ }
+ return callFrames;
+}
+
+static V8Debugger* toV8Debugger(v8::Local<v8::Value> data) {
+ void* p = v8::Local<v8::External>::Cast(data)->Value();
+ return static_cast<V8Debugger*>(p);
+}
+
+void V8Debugger::breakProgramCallback(
+ const v8::FunctionCallbackInfo<v8::Value>& info) {
+ DCHECK_EQ(info.Length(), 2);
+ V8Debugger* thisPtr = toV8Debugger(info.Data());
+ if (!thisPtr->enabled()) return;
+ v8::Local<v8::Context> pausedContext =
+ thisPtr->m_isolate->GetCurrentContext();
+ v8::Local<v8::Value> exception;
+ v8::Local<v8::Array> hitBreakpoints;
+ thisPtr->handleProgramBreak(pausedContext,
+ v8::Local<v8::Object>::Cast(info[0]), exception,
+ hitBreakpoints);
+}
+
+void V8Debugger::handleProgramBreak(v8::Local<v8::Context> pausedContext,
+ v8::Local<v8::Object> executionState,
+ v8::Local<v8::Value> exception,
+ v8::Local<v8::Array> hitBreakpointNumbers,
+ bool isPromiseRejection) {
+ // Don't allow nested breaks.
+ if (m_runningNestedMessageLoop) return;
+
+ V8DebuggerAgentImpl* agent =
+ m_inspector->enabledDebuggerAgentForGroup(getGroupId(pausedContext));
+ if (!agent) return;
+
+ std::vector<String16> breakpointIds;
+ if (!hitBreakpointNumbers.IsEmpty()) {
+ breakpointIds.reserve(hitBreakpointNumbers->Length());
+ for (size_t i = 0; i < hitBreakpointNumbers->Length(); i++) {
+ v8::Local<v8::Value> hitBreakpointNumber = hitBreakpointNumbers->Get(i);
+ DCHECK(!hitBreakpointNumber.IsEmpty() && hitBreakpointNumber->IsInt32());
+ breakpointIds.push_back(
+ String16::fromInteger(hitBreakpointNumber->Int32Value()));
+ }
+ }
+
+ m_pausedContext = pausedContext;
+ m_executionState = executionState;
+ V8DebuggerAgentImpl::SkipPauseRequest result = agent->didPause(
+ pausedContext, exception, breakpointIds, isPromiseRejection);
+ if (result == V8DebuggerAgentImpl::RequestNoSkip) {
+ m_runningNestedMessageLoop = true;
+ int groupId = getGroupId(pausedContext);
+ DCHECK(groupId);
+ m_inspector->client()->runMessageLoopOnPause(groupId);
+ // The agent may have been removed in the nested loop.
+ agent =
+ m_inspector->enabledDebuggerAgentForGroup(getGroupId(pausedContext));
+ if (agent) agent->didContinue();
+ m_runningNestedMessageLoop = false;
+ }
+ m_pausedContext.Clear();
+ m_executionState.Clear();
+
+ if (result == V8DebuggerAgentImpl::RequestStepFrame) {
+ v8::Local<v8::Value> argv[] = {executionState};
+ callDebuggerMethod("stepFrameStatement", 1, argv);
+ } else if (result == V8DebuggerAgentImpl::RequestStepInto) {
+ v8::Local<v8::Value> argv[] = {executionState};
+ callDebuggerMethod(stepIntoV8MethodName, 1, argv);
+ } else if (result == V8DebuggerAgentImpl::RequestStepOut) {
+ v8::Local<v8::Value> argv[] = {executionState};
+ callDebuggerMethod(stepOutV8MethodName, 1, argv);
+ }
+}
+
+void V8Debugger::v8DebugEventCallback(
+ const v8::Debug::EventDetails& eventDetails) {
+ V8Debugger* thisPtr = toV8Debugger(eventDetails.GetCallbackData());
+ thisPtr->handleV8DebugEvent(eventDetails);
+}
+
+v8::Local<v8::Value> V8Debugger::callInternalGetterFunction(
+ v8::Local<v8::Object> object, const char* functionName) {
+ v8::MicrotasksScope microtasks(m_isolate,
+ v8::MicrotasksScope::kDoNotRunMicrotasks);
+ v8::Local<v8::Value> getterValue =
+ object->Get(toV8StringInternalized(m_isolate, functionName));
+ DCHECK(!getterValue.IsEmpty() && getterValue->IsFunction());
+ return v8::Local<v8::Function>::Cast(getterValue)
+ ->Call(m_isolate->GetCurrentContext(), object, 0, 0)
+ .ToLocalChecked();
+}
+
+void V8Debugger::handleV8DebugEvent(
+ const v8::Debug::EventDetails& eventDetails) {
+ if (!enabled()) return;
+ v8::DebugEvent event = eventDetails.GetEvent();
+ if (event != v8::AsyncTaskEvent && event != v8::Break &&
+ event != v8::Exception && event != v8::AfterCompile &&
+ event != v8::BeforeCompile && event != v8::CompileError)
+ return;
+
+ v8::Local<v8::Context> eventContext = eventDetails.GetEventContext();
+ DCHECK(!eventContext.IsEmpty());
+
+ if (event == v8::AsyncTaskEvent) {
+ v8::HandleScope scope(m_isolate);
+ handleV8AsyncTaskEvent(eventContext, eventDetails.GetExecutionState(),
+ eventDetails.GetEventData());
+ return;
+ }
+
+ V8DebuggerAgentImpl* agent =
+ m_inspector->enabledDebuggerAgentForGroup(getGroupId(eventContext));
+ if (agent) {
+ v8::HandleScope scope(m_isolate);
+ if (m_ignoreScriptParsedEventsCounter == 0 &&
+ (event == v8::AfterCompile || event == v8::CompileError)) {
+ v8::Context::Scope contextScope(debuggerContext());
+ v8::Local<v8::Value> argv[] = {eventDetails.GetEventData()};
+ v8::Local<v8::Value> value =
+ callDebuggerMethod("getAfterCompileScript", 1, argv).ToLocalChecked();
+ if (value->IsNull()) return;
+ DCHECK(value->IsObject());
+ v8::Local<v8::Object> scriptObject = v8::Local<v8::Object>::Cast(value);
+ agent->didParseSource(wrapUnique(new V8DebuggerScript(
+ m_isolate, scriptObject, inLiveEditScope)),
+ event == v8::AfterCompile);
+ } else if (event == v8::Exception) {
+ v8::Local<v8::Object> eventData = eventDetails.GetEventData();
+ v8::Local<v8::Value> exception =
+ callInternalGetterFunction(eventData, "exception");
+ v8::Local<v8::Value> promise =
+ callInternalGetterFunction(eventData, "promise");
+ bool isPromiseRejection = !promise.IsEmpty() && promise->IsObject();
+ handleProgramBreak(eventContext, eventDetails.GetExecutionState(),
+ exception, v8::Local<v8::Array>(), isPromiseRejection);
+ } else if (event == v8::Break) {
+ v8::Local<v8::Value> argv[] = {eventDetails.GetEventData()};
+ v8::Local<v8::Value> hitBreakpoints =
+ callDebuggerMethod("getBreakpointNumbers", 1, argv).ToLocalChecked();
+ DCHECK(hitBreakpoints->IsArray());
+ handleProgramBreak(eventContext, eventDetails.GetExecutionState(),
+ v8::Local<v8::Value>(),
+ hitBreakpoints.As<v8::Array>());
+ }
+ }
+}
+
+void V8Debugger::handleV8AsyncTaskEvent(v8::Local<v8::Context> context,
+ v8::Local<v8::Object> executionState,
+ v8::Local<v8::Object> eventData) {
+ if (!m_maxAsyncCallStackDepth) return;
+
+ String16 type = toProtocolStringWithTypeCheck(
+ callInternalGetterFunction(eventData, "type"));
+ String16 name = toProtocolStringWithTypeCheck(
+ callInternalGetterFunction(eventData, "name"));
+ int id = callInternalGetterFunction(eventData, "id")
+ ->ToInteger(m_isolate)
+ ->Value();
+ // The scopes for the ids are defined by the eventData.name namespaces. There
+ // are currently two namespaces: "Object." and "Promise.".
+ void* ptr = reinterpret_cast<void*>(id * 4 + (name[0] == 'P' ? 2 : 0) + 1);
+ if (type == v8AsyncTaskEventEnqueue)
+ asyncTaskScheduled(name, ptr, false);
+ else if (type == v8AsyncTaskEventWillHandle)
+ asyncTaskStarted(ptr);
+ else if (type == v8AsyncTaskEventDidHandle)
+ asyncTaskFinished(ptr);
+ else
+ NOTREACHED();
+}
+
+V8StackTraceImpl* V8Debugger::currentAsyncCallChain() {
+ if (!m_currentStacks.size()) return nullptr;
+ return m_currentStacks.back().get();
+}
+
+void V8Debugger::compileDebuggerScript() {
+ if (!m_debuggerScript.IsEmpty()) {
+ NOTREACHED();
+ return;
+ }
+
+ v8::HandleScope scope(m_isolate);
+ v8::Context::Scope contextScope(debuggerContext());
+
+ v8::Local<v8::String> scriptValue =
+ v8::String::NewFromUtf8(m_isolate, DebuggerScript_js,
+ v8::NewStringType::kInternalized,
+ sizeof(DebuggerScript_js))
+ .ToLocalChecked();
+ v8::Local<v8::Value> value;
+ if (!m_inspector->compileAndRunInternalScript(debuggerContext(), scriptValue)
+ .ToLocal(&value)) {
+ NOTREACHED();
+ return;
+ }
+ DCHECK(value->IsObject());
+ m_debuggerScript.Reset(m_isolate, value.As<v8::Object>());
+}
+
+v8::Local<v8::Context> V8Debugger::debuggerContext() const {
+ DCHECK(!m_debuggerContext.IsEmpty());
+ return m_debuggerContext.Get(m_isolate);
+}
+
+v8::MaybeLocal<v8::Value> V8Debugger::functionScopes(
+ v8::Local<v8::Context> context, v8::Local<v8::Function> function) {
+ if (!enabled()) {
+ NOTREACHED();
+ return v8::Local<v8::Value>::New(m_isolate, v8::Undefined(m_isolate));
+ }
+ v8::Local<v8::Value> argv[] = {function};
+ v8::Local<v8::Value> scopesValue;
+ if (!callDebuggerMethod("getFunctionScopes", 1, argv).ToLocal(&scopesValue))
+ return v8::MaybeLocal<v8::Value>();
+ v8::Local<v8::Value> copied;
+ if (!copyValueFromDebuggerContext(m_isolate, debuggerContext(), context,
+ scopesValue)
+ .ToLocal(&copied) ||
+ !copied->IsArray())
+ return v8::MaybeLocal<v8::Value>();
+ if (!markAsInternal(context, v8::Local<v8::Array>::Cast(copied),
+ V8InternalValueType::kScopeList))
+ return v8::MaybeLocal<v8::Value>();
+ if (!markArrayEntriesAsInternal(context, v8::Local<v8::Array>::Cast(copied),
+ V8InternalValueType::kScope))
+ return v8::MaybeLocal<v8::Value>();
+ return copied;
+}
+
+v8::MaybeLocal<v8::Array> V8Debugger::internalProperties(
+ v8::Local<v8::Context> context, v8::Local<v8::Value> value) {
+ v8::Local<v8::Array> properties;
+ if (!v8::Debug::GetInternalProperties(m_isolate, value).ToLocal(&properties))
+ return v8::MaybeLocal<v8::Array>();
+ if (value->IsFunction()) {
+ v8::Local<v8::Function> function = value.As<v8::Function>();
+ v8::Local<v8::Value> location = functionLocation(context, function);
+ if (location->IsObject()) {
+ createDataProperty(
+ context, properties, properties->Length(),
+ toV8StringInternalized(m_isolate, "[[FunctionLocation]]"));
+ createDataProperty(context, properties, properties->Length(), location);
+ }
+ if (function->IsGeneratorFunction()) {
+ createDataProperty(context, properties, properties->Length(),
+ toV8StringInternalized(m_isolate, "[[IsGenerator]]"));
+ createDataProperty(context, properties, properties->Length(),
+ v8::True(m_isolate));
+ }
+ }
+ if (!enabled()) return properties;
+ if (value->IsMap() || value->IsWeakMap() || value->IsSet() ||
+ value->IsWeakSet() || value->IsSetIterator() || value->IsMapIterator()) {
+ v8::Local<v8::Value> entries =
+ collectionEntries(context, v8::Local<v8::Object>::Cast(value));
+ if (entries->IsArray()) {
+ createDataProperty(context, properties, properties->Length(),
+ toV8StringInternalized(m_isolate, "[[Entries]]"));
+ createDataProperty(context, properties, properties->Length(), entries);
+ }
+ }
+ if (value->IsGeneratorObject()) {
+ v8::Local<v8::Value> location =
+ generatorObjectLocation(context, v8::Local<v8::Object>::Cast(value));
+ if (location->IsObject()) {
+ createDataProperty(
+ context, properties, properties->Length(),
+ toV8StringInternalized(m_isolate, "[[GeneratorLocation]]"));
+ createDataProperty(context, properties, properties->Length(), location);
+ }
+ }
+ if (value->IsFunction()) {
+ v8::Local<v8::Function> function = value.As<v8::Function>();
+ v8::Local<v8::Value> boundFunction = function->GetBoundFunction();
+ v8::Local<v8::Value> scopes;
+ if (boundFunction->IsUndefined() &&
+ functionScopes(context, function).ToLocal(&scopes)) {
+ createDataProperty(context, properties, properties->Length(),
+ toV8StringInternalized(m_isolate, "[[Scopes]]"));
+ createDataProperty(context, properties, properties->Length(), scopes);
+ }
+ }
+ return properties;
+}
+
+v8::Local<v8::Value> V8Debugger::collectionEntries(
+ v8::Local<v8::Context> context, v8::Local<v8::Object> object) {
+ if (!enabled()) {
+ NOTREACHED();
+ return v8::Undefined(m_isolate);
+ }
+ v8::Local<v8::Value> argv[] = {object};
+ v8::Local<v8::Value> entriesValue =
+ callDebuggerMethod("getCollectionEntries", 1, argv).ToLocalChecked();
+ v8::Local<v8::Value> copied;
+ if (!copyValueFromDebuggerContext(m_isolate, debuggerContext(), context,
+ entriesValue)
+ .ToLocal(&copied) ||
+ !copied->IsArray())
+ return v8::Undefined(m_isolate);
+ if (!markArrayEntriesAsInternal(context, v8::Local<v8::Array>::Cast(copied),
+ V8InternalValueType::kEntry))
+ return v8::Undefined(m_isolate);
+ return copied;
+}
+
+v8::Local<v8::Value> V8Debugger::generatorObjectLocation(
+ v8::Local<v8::Context> context, v8::Local<v8::Object> object) {
+ if (!enabled()) {
+ NOTREACHED();
+ return v8::Null(m_isolate);
+ }
+ v8::Local<v8::Value> argv[] = {object};
+ v8::Local<v8::Value> location =
+ callDebuggerMethod("getGeneratorObjectLocation", 1, argv)
+ .ToLocalChecked();
+ v8::Local<v8::Value> copied;
+ if (!copyValueFromDebuggerContext(m_isolate, debuggerContext(), context,
+ location)
+ .ToLocal(&copied) ||
+ !copied->IsObject())
+ return v8::Null(m_isolate);
+ if (!markAsInternal(context, v8::Local<v8::Object>::Cast(copied),
+ V8InternalValueType::kLocation))
+ return v8::Null(m_isolate);
+ return copied;
+}
+
+v8::Local<v8::Value> V8Debugger::functionLocation(
+ v8::Local<v8::Context> context, v8::Local<v8::Function> function) {
+ int scriptId = function->ScriptId();
+ if (scriptId == v8::UnboundScript::kNoScriptId) return v8::Null(m_isolate);
+ int lineNumber = function->GetScriptLineNumber();
+ int columnNumber = function->GetScriptColumnNumber();
+ if (lineNumber == v8::Function::kLineOffsetNotFound ||
+ columnNumber == v8::Function::kLineOffsetNotFound)
+ return v8::Null(m_isolate);
+ v8::Local<v8::Object> location = v8::Object::New(m_isolate);
+ if (!location->SetPrototype(context, v8::Null(m_isolate)).FromMaybe(false))
+ return v8::Null(m_isolate);
+ if (!createDataProperty(
+ context, location, toV8StringInternalized(m_isolate, "scriptId"),
+ toV8String(m_isolate, String16::fromInteger(scriptId)))
+ .FromMaybe(false))
+ return v8::Null(m_isolate);
+ if (!createDataProperty(context, location,
+ toV8StringInternalized(m_isolate, "lineNumber"),
+ v8::Integer::New(m_isolate, lineNumber))
+ .FromMaybe(false))
+ return v8::Null(m_isolate);
+ if (!createDataProperty(context, location,
+ toV8StringInternalized(m_isolate, "columnNumber"),
+ v8::Integer::New(m_isolate, columnNumber))
+ .FromMaybe(false))
+ return v8::Null(m_isolate);
+ if (!markAsInternal(context, location, V8InternalValueType::kLocation))
+ return v8::Null(m_isolate);
+ return location;
+}
+
+bool V8Debugger::isPaused() { return !m_pausedContext.IsEmpty(); }
+
+std::unique_ptr<V8StackTraceImpl> V8Debugger::createStackTrace(
+ v8::Local<v8::StackTrace> stackTrace) {
+ int contextGroupId =
+ m_isolate->InContext() ? getGroupId(m_isolate->GetCurrentContext()) : 0;
+ return V8StackTraceImpl::create(this, contextGroupId, stackTrace,
+ V8StackTraceImpl::maxCallStackSizeToCapture);
+}
+
+int V8Debugger::markContext(const V8ContextInfo& info) {
+ DCHECK(info.context->GetIsolate() == m_isolate);
+ int contextId = ++m_lastContextId;
+ String16 debugData = String16::fromInteger(info.contextGroupId) + "," +
+ String16::fromInteger(contextId) + "," +
+ toString16(info.auxData);
+ v8::Context::Scope contextScope(info.context);
+ info.context->SetEmbedderData(static_cast<int>(v8::Context::kDebugIdIndex),
+ toV8String(m_isolate, debugData));
+ return contextId;
+}
+
+void V8Debugger::setAsyncCallStackDepth(V8DebuggerAgentImpl* agent, int depth) {
+ if (depth <= 0)
+ m_maxAsyncCallStackDepthMap.erase(agent);
+ else
+ m_maxAsyncCallStackDepthMap[agent] = depth;
+
+ int maxAsyncCallStackDepth = 0;
+ for (const auto& pair : m_maxAsyncCallStackDepthMap) {
+ if (pair.second > maxAsyncCallStackDepth)
+ maxAsyncCallStackDepth = pair.second;
+ }
+
+ if (m_maxAsyncCallStackDepth == maxAsyncCallStackDepth) return;
+ m_maxAsyncCallStackDepth = maxAsyncCallStackDepth;
+ if (!maxAsyncCallStackDepth) allAsyncTasksCanceled();
+}
+
+void V8Debugger::asyncTaskScheduled(const StringView& taskName, void* task,
+ bool recurring) {
+ if (!m_maxAsyncCallStackDepth) return;
+ asyncTaskScheduled(toString16(taskName), task, recurring);
+}
+
+void V8Debugger::asyncTaskScheduled(const String16& taskName, void* task,
+ bool recurring) {
+ if (!m_maxAsyncCallStackDepth) return;
+ v8::HandleScope scope(m_isolate);
+ int contextGroupId =
+ m_isolate->InContext() ? getGroupId(m_isolate->GetCurrentContext()) : 0;
+ std::unique_ptr<V8StackTraceImpl> chain = V8StackTraceImpl::capture(
+ this, contextGroupId, V8StackTraceImpl::maxCallStackSizeToCapture,
+ taskName);
+ if (chain) {
+ m_asyncTaskStacks[task] = std::move(chain);
+ if (recurring) m_recurringTasks.insert(task);
+ }
+}
+
+void V8Debugger::asyncTaskCanceled(void* task) {
+ if (!m_maxAsyncCallStackDepth) return;
+ m_asyncTaskStacks.erase(task);
+ m_recurringTasks.erase(task);
+}
+
+void V8Debugger::asyncTaskStarted(void* task) {
+ if (!m_maxAsyncCallStackDepth) return;
+ m_currentTasks.push_back(task);
+ AsyncTaskToStackTrace::iterator stackIt = m_asyncTaskStacks.find(task);
+ // Needs to support following order of events:
+ // - asyncTaskScheduled
+ // <-- attached here -->
+ // - asyncTaskStarted
+ // - asyncTaskCanceled <-- canceled before finished
+ // <-- async stack requested here -->
+ // - asyncTaskFinished
+ std::unique_ptr<V8StackTraceImpl> stack;
+ if (stackIt != m_asyncTaskStacks.end() && stackIt->second)
+ stack = stackIt->second->cloneImpl();
+ m_currentStacks.push_back(std::move(stack));
+}
+
+void V8Debugger::asyncTaskFinished(void* task) {
+ if (!m_maxAsyncCallStackDepth) return;
+ // We could start instrumenting half way and the stack is empty.
+ if (!m_currentStacks.size()) return;
+
+ DCHECK(m_currentTasks.back() == task);
+ m_currentTasks.pop_back();
+
+ m_currentStacks.pop_back();
+ if (m_recurringTasks.find(task) == m_recurringTasks.end())
+ m_asyncTaskStacks.erase(task);
+}
+
+void V8Debugger::allAsyncTasksCanceled() {
+ m_asyncTaskStacks.clear();
+ m_recurringTasks.clear();
+ m_currentStacks.clear();
+ m_currentTasks.clear();
+}
+
+void V8Debugger::muteScriptParsedEvents() {
+ ++m_ignoreScriptParsedEventsCounter;
+}
+
+void V8Debugger::unmuteScriptParsedEvents() {
+ --m_ignoreScriptParsedEventsCounter;
+ DCHECK_GE(m_ignoreScriptParsedEventsCounter, 0);
+}
+
+std::unique_ptr<V8StackTraceImpl> V8Debugger::captureStackTrace(
+ bool fullStack) {
+ if (!m_isolate->InContext()) return nullptr;
+
+ v8::HandleScope handles(m_isolate);
+ int contextGroupId = getGroupId(m_isolate->GetCurrentContext());
+ if (!contextGroupId) return nullptr;
+
+ size_t stackSize =
+ fullStack ? V8StackTraceImpl::maxCallStackSizeToCapture : 1;
+ if (m_inspector->enabledRuntimeAgentForGroup(contextGroupId))
+ stackSize = V8StackTraceImpl::maxCallStackSizeToCapture;
+
+ return V8StackTraceImpl::capture(this, contextGroupId, stackSize);
+}
+
+} // namespace v8_inspector
« no previous file with comments | « src/inspector/V8Debugger.h ('k') | src/inspector/V8DebuggerAgentImpl.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698