Changeset 266534 in webkit for trunk/Source/JavaScriptCore/debugger

Timestamp:

Sep 3, 2020, 10:53:21 AM (5 years ago)

Author:

Devin Rousso

Message:

Web Inspector: allow special JavaScript breakpoints to be configured
​https://bugs.webkit.org/show_bug.cgi?id=215794

Reviewed by Brian Burg.

Source/JavaScriptCore:

• inspector/protocol/Debugger.json:

Add an options parameter to the following commands for configuring the related breakpoint:

• Debugger.setPauseOnDebuggerStatements
• Debugger.setPauseOnExceptions
• Debugger.setPauseOnAssertions
• Debugger.setPauseOnMicrotasks

• debugger/Debugger.h:

(JSC::Debugger::needsExceptionCallbacks const):
(JSC::Debugger::pauseOnAllExceptionsBreakpoint const): Added.
(JSC::Debugger::setPauseOnAllExceptionsBreakpoint): Added.
(JSC::Debugger::pauseOnUncaughtExceptionsBreakpoint const): Added.
(JSC::Debugger::setPauseOnUncaughtExceptionsBreakpoint): Added.
(JSC::Debugger::setPauseOnDebuggerStatementsBreakpoint): Added.
(JSC::Debugger::pauseOnExceptionsState const): Deleted.
(JSC::Debugger::setPauseOnDebuggerStatements): Deleted.

• debugger/Debugger.cpp:

(JSC::Debugger::TemporarilyDisableExceptionBreakpoints::TemporarilyDisableExceptionBreakpoints): Added.
(JSC::Debugger::TemporarilyDisableExceptionBreakpoints::~TemporarilyDisableExceptionBreakpoints): Added.
(JSC::Debugger::TemporarilyDisableExceptionBreakpoints::replace): Added.
(JSC::Debugger::TemporarilyDisableExceptionBreakpoints::restore): Added.
(JSC::Debugger::Debugger):
(JSC::Debugger::breakProgram):
(JSC::Debugger::exception):
(JSC::Debugger::didReachDebuggerStatement):
(JSC::Debugger::setPauseOnExceptionsState): Deleted.
Add JSC::Breakpoint member variables for the Debugger Statements and Exceptions
breakpoints. Split the Exceptions breakpoint into two JSC::Breakpoint now that
All Exceptions and Uncaught Exceptions can be independently configured (the All
Exceptions breakpoint still takes precedence).

• debugger/DebuggerCallFrame.h:
• debugger/DebuggerCallFrame.cpp:

(JSC::DebuggerCallFrame::evaluateWithScopeExtension):
If there is no CallFrame, climb the backtrace until the first valid CallFrame is reached.
This is needed when pausing in native code, such as for assertions/exceptions.

• debugger/Breakpoint.h:

Export JSC::Breakpoint::create so that other parts of WebKit can create breakpoints.

• inspector/agents/InspectorDebuggerAgent.h:
• inspector/agents/InspectorDebuggerAgent.cpp:

(Inspector::InspectorDebuggerAgent::disable):
(Inspector::InspectorDebuggerAgent::handleConsoleAssert):
(Inspector::InspectorDebuggerAgent::setPauseOnDebuggerStatements):
(Inspector::InspectorDebuggerAgent::setPauseOnExceptions):
(Inspector::InspectorDebuggerAgent::setPauseOnAssertions):
(Inspector::InspectorDebuggerAgent::setPauseOnMicrotasks):
(Inspector::InspectorDebuggerAgent::evaluateOnCallFrame):
(Inspector::InspectorDebuggerAgent::scriptExecutionBlockedByCSP):
(Inspector::InspectorDebuggerAgent::willRunMicrotask):
(Inspector::InspectorDebuggerAgent::didRunMicrotask):
(Inspector::InspectorDebuggerAgent::breakProgram):
Add JSC::Breakpoint member variables for the Assertion Failures and All Microtasks
breakpoints. Pass them to the JSC::Debugger when they are hit.

• inspector/agents/InspectorAuditAgent.cpp:

(Inspector::InspectorAuditAgent::run):

• inspector/agents/InspectorRuntimeAgent.cpp:

(Inspector::InspectorRuntimeAgent::evaluate):
(Inspector::InspectorRuntimeAgent::callFunctionOn):
(Inspector::InspectorRuntimeAgent::getPreview):
(Inspector::InspectorRuntimeAgent::getProperties):
(Inspector::InspectorRuntimeAgent::getDisplayableProperties):
(Inspector::setPauseOnExceptionsState): Deleted.
Use TemporarilyDisableExceptionBreakpoints to save, override, and restore the exceptions
breakpoints now that they've been separated into two JSC::Breakpoint instead of an enum.

Source/WebInspectorUI:

• UserInterface/Models/Breakpoint.js:

(WI.Breakpoint.prototype.reset): Added.
Provide a way to consistently clear the current configuration.

• UserInterface/Models/JavaScriptBreakpoint.js:

(WI.JavaScriptBreakpoint.supportsMicrotasks): Added.
(WI.JavaScriptBreakpoint.supportsDebuggerStatements): Added.
(WI.JavaScriptBreakpoint.fromJSON):
(WI.JavaScriptBreakpoint.prototype.toJSON):
(WI.JavaScriptBreakpoint.prototype.get editable):
(WI.JavaScriptBreakpoint.prototype._isSpecial):

• UserInterface/Models/SourceCodeLocation.js:

(WI.SourceCodeLocation.get specialBreakpointLocation): Added.
Add a helper for the special null:Infinity:Infinity breakpoint location for consistency.

• UserInterface/Controllers/DebuggerManager.js:

(WI.DebuggerManager):
(WI.DebuggerManager.prototype.async initializeTarget):
(WI.DebuggerManager.prototype.createAssertionFailuresBreakpoint): Added.
(WI.DebuggerManager.prototype.createAllMicrotasksBreakpoint): Added.
(WI.DebuggerManager.prototype.set breakpointsEnabled):
(WI.DebuggerManager.prototype.addBreakpoint):
(WI.DebuggerManager.prototype.removeBreakpoint):
(WI.DebuggerManager.prototype._setPauseOnExceptions): Added.
(WI.DebuggerManager.prototype._createSpecialBreakpoint): Added.
(WI.DebuggerManager.prototype._updateSpecialBreakpoint): Added.
(WI.DebuggerManager.prototype._breakpointDisabledStateDidChange):
(WI.DebuggerManager.prototype._breakpointEditablePropertyDidChange):
(WI.DebuggerManager.prototype._updateBreakOnExceptionsState): Deleted.
Maintain a WI.Setting for the configuration of each special WI.JavaScriptBreakpoint.
Have a common path for updating all special WI.JavaScriptBreakpoint to avoid duplicated
code.
Add methods for creating the Assertion Failures and All Microtasks WI.JavaScriptBreakpoint
since they can be removed (in addition to being disabled) and re-added.

• UserInterface/Views/BreakpointPopover.js:

(WI.BreakpointPopover.appendContextMenuItems):

• UserInterface/Views/BreakpointTreeElement.js:

(WI.BreakpointTreeElement.prototype.ondelete):
If the WI.Breakpoint is not removable, make sure to reset it in addition to disabling
it so that no configuration persists if the WI.Breakpoint is later enabled.

• UserInterface/Views/SourcesNavigationSidebarPanel.js:

(WI.SourcesNavigationSidebarPanel):
(WI.SourcesNavigationSidebarPanel.prototype._handleBreakpointTreeOutlineElementRemoved): Added.
(WI.SourcesNavigationSidebarPanel.prototype._handleBreakpointElementAddedOrRemoved): Deleted.
Eliminate the need to listen for when breakpoints are added to the WI.TreeOutline, which
was previously used to update the WI.Setting for whether special WI.JavaScriptBreakpoint
are visible.
Don't assume that a WI.Breakpoint exists for each special WI.JavaScriptBreakpoint.

• UserInterface/Base/Setting.js:

(WI.Setting):
(WI.Setting.migrateValue):
(WI.Setting.reset):
(WI.Setting.prototype.get value):
(WI.Setting.prototype.save):
(WI.Setting._localStorageKeyPrefix): Added.
(WI.Setting._localStorageKey): Deleted.
Eagerly compute the key prefix as it shouldn't change through the lifetime of Web Inspector
and is used early on too.
Add a static member isFirstLaunch which can be used by other WI.Setting to adjust their
value when Web Inspector is in a clean state (e.g. show the Assertion Failures breakpoint by
default, but only for the first launch). This is needed because WI.Setting clears the key
from localStorage if the current value matches the _defaultValue.

• UserInterface/Models/ProbeSet.js:

(WI.ProbeSet):
(WI.ProbeSet.prototype.willRemove):
(WI.ProbeSet.prototype._sampleCollected):
(WI.ProbeSet.prototype._breakpointResolvedStateDidChange): Deleted.
Drive-by: remove an unused event.

• Localizations/en.lproj/localizedStrings.js:

Source/WebKitLegacy/mac:

• WebView/WebScriptDebugger.mm:

(WebScriptDebugger::WebScriptDebugger):

LayoutTests:

• inspector/debugger/resources/breakpoint-options-utilities.js: Added.

(TestPage.registerInitializer.InspectorTest.BreakpointOptions.addTestCases):
(TestPage.registerInitializer.InspectorTest.BreakpointOptions.addTestCases.removeBreakpoint):

• inspector/debugger/break-on-exception.html:
• inspector/debugger/break-on-exception-expected.txt:
• inspector/debugger/break-on-uncaught-exception.html:
• inspector/debugger/break-on-uncaught-exception-expected.txt:
• inspector/debugger/setPauseOnAssertions.html:
• inspector/debugger/setPauseOnAssertions-expected.txt:
• inspector/debugger/setPauseOnDebuggerStatements.html:
• inspector/debugger/setPauseOnDebuggerStatements-expected.txt:
• inspector/debugger/setPauseOnMicrotasks.html:
• inspector/debugger/setPauseOnMicrotasks-expected.txt:

Add tests for global JavaScript breakpoint configuration options.

Location:

trunk/Source/JavaScriptCore/debugger

Files:

• Breakpoint.h (modified) (1 diff)
• Debugger.cpp (modified) (7 diffs)
• Debugger.h (modified) (5 diffs)
• DebuggerCallFrame.cpp (modified) (3 diffs)
• DebuggerCallFrame.h (modified) (1 diff)

trunk/Source/JavaScriptCore/debugger/Breakpoint.h

@@ -60 +60 @@
     using ActionsVector = Vector<Action>;
 
-    static Ref<Breakpoint> create(BreakpointID, const String& condition = nullString(), ActionsVector&& = { }, bool autoContinue = false, size_t ignoreCount = 0);
+    JS_EXPORT_PRIVATE static Ref<Breakpoint> create(BreakpointID, const String& condition = nullString(), ActionsVector&& = { }, bool autoContinue = false, size_t ignoreCount = 0);
 
     BreakpointID id() const { return m_id; }

trunk/Source/JavaScriptCore/debugger/Debugger.cpp

@@ -78 +78 @@
 };
 
+Debugger::TemporarilyDisableExceptionBreakpoints::TemporarilyDisableExceptionBreakpoints(Debugger& debugger)
+    : m_debugger(debugger)
+{
+}
+
+Debugger::TemporarilyDisableExceptionBreakpoints::~TemporarilyDisableExceptionBreakpoints()
+{
+    restore();
+}
+
+void Debugger::TemporarilyDisableExceptionBreakpoints::replace()
+{
+    if (m_debugger.m_pauseOnAllExceptionsBreakpoint)
+        m_pauseOnAllExceptionsBreakpoint = WTFMove(m_debugger.m_pauseOnAllExceptionsBreakpoint);
+
+    if (m_debugger.m_pauseOnUncaughtExceptionsBreakpoint)
+        m_pauseOnUncaughtExceptionsBreakpoint = WTFMove(m_debugger.m_pauseOnUncaughtExceptionsBreakpoint);
+}
+
+void Debugger::TemporarilyDisableExceptionBreakpoints::restore()
+{
+    if (m_pauseOnAllExceptionsBreakpoint)
+        m_debugger.m_pauseOnAllExceptionsBreakpoint = WTFMove(m_pauseOnAllExceptionsBreakpoint);
+
+    if (m_pauseOnUncaughtExceptionsBreakpoint)
+        m_debugger.m_pauseOnUncaughtExceptionsBreakpoint = WTFMove(m_pauseOnUncaughtExceptionsBreakpoint);
+}
+
 
 Debugger::ProfilingClient::~ProfilingClient()
@@ -85 +113 @@
 Debugger::Debugger(VM& vm)
     : m_vm(vm)
-    , m_pauseOnExceptionsState(DontPauseOnExceptions)
     , m_pauseAtNextOpportunity(false)
     , m_pastFirstExpressionInStatement(false)
@@ -689 +716 @@
 }
 
-void Debugger::setPauseOnExceptionsState(PauseOnExceptionsState pause)
-{
-    m_pauseOnExceptionsState = pause;
-}
-
 void Debugger::schedulePauseAtNextOpportunity()
 {
@@ -725 +747 @@
 }
 
-void Debugger::breakProgram()
+void Debugger::breakProgram(RefPtr<Breakpoint>&& specialBreakpoint)
 {
     if (m_isPaused)
@@ -733 +755 @@
         return;
 
-    m_pauseAtNextOpportunity = true;
+    if (specialBreakpoint) {
+        ASSERT(!m_specialBreakpoint);
+        m_specialBreakpoint = WTFMove(specialBreakpoint);
+    } else
+        m_pauseAtNextOpportunity = true;
+
     setSteppingMode(SteppingModeEnabled);
     m_currentCallFrame = m_vm.topCallFrame;
@@ -981 +1008 @@
 
     PauseReasonDeclaration reason(*this, PausedForException);
-    if (m_pauseOnExceptionsState == PauseOnAllExceptions || (m_pauseOnExceptionsState == PauseOnUncaughtExceptions && !hasCatchHandler)) {
-        m_pauseAtNextOpportunity = true;
+    if (m_pauseOnAllExceptionsBreakpoint || (m_pauseOnUncaughtExceptionsBreakpoint && !hasCatchHandler)) {
+        m_specialBreakpoint = m_pauseOnAllExceptionsBreakpoint ? m_pauseOnAllExceptionsBreakpoint.copyRef() : m_pauseOnUncaughtExceptionsBreakpoint.copyRef();
         setSteppingMode(SteppingModeEnabled);
     }
@@ -1133 +1160 @@
         return;
 
-    if (!m_pauseOnDebuggerStatements)
+    if (!m_pauseOnDebuggerStatementsBreakpoint)
         return;
 
     PauseReasonDeclaration reason(*this, PausedForDebuggerStatement);
-    m_pauseAtNextOpportunity = true;
+    m_specialBreakpoint = m_pauseOnDebuggerStatementsBreakpoint.copyRef();
     setSteppingMode(SteppingModeEnabled);
     updateCallFrame(lexicalGlobalObjectForCallFrame(m_vm, callFrame), callFrame, AttemptPause);

trunk/Source/JavaScriptCore/debugger/Debugger.h

@@ -47 +47 @@
     VM& vm() { return m_vm; }
 
-    bool needsExceptionCallbacks() const { return m_breakpointsActivated && m_pauseOnExceptionsState != DontPauseOnExceptions; }
+    bool needsExceptionCallbacks() const { return m_breakpointsActivated && (m_pauseOnAllExceptionsBreakpoint || m_pauseOnUncaughtExceptionsBreakpoint); }
     bool isInteractivelyDebugging() const { return m_breakpointsActivated; }
 
@@ -71 +71 @@
     void evaluateBreakpointActions(Breakpoint&, JSGlobalObject*);
 
-    enum PauseOnExceptionsState {
-        DontPauseOnExceptions,
-        PauseOnAllExceptions,
-        PauseOnUncaughtExceptions
-    };
-    PauseOnExceptionsState pauseOnExceptionsState() const { return m_pauseOnExceptionsState; }
-    JS_EXPORT_PRIVATE void setPauseOnExceptionsState(PauseOnExceptionsState);
-
-    void setPauseOnDebuggerStatements(bool enabled) { m_pauseOnDebuggerStatements = enabled; }
+    void setPauseOnDebuggerStatementsBreakpoint(RefPtr<Breakpoint>&& breakpoint) { m_pauseOnDebuggerStatementsBreakpoint = WTFMove(breakpoint); }
+
+    class TemporarilyDisableExceptionBreakpoints {
+    public:
+        TemporarilyDisableExceptionBreakpoints(Debugger&);
+        ~TemporarilyDisableExceptionBreakpoints();
+
+        void replace();
+        void restore();
+
+    private:
+        Debugger& m_debugger;
+        RefPtr<Breakpoint> m_pauseOnAllExceptionsBreakpoint;
+        RefPtr<Breakpoint> m_pauseOnUncaughtExceptionsBreakpoint;
+    };
+    void setPauseOnAllExceptionsBreakpoint(RefPtr<Breakpoint>&& breakpoint) { m_pauseOnAllExceptionsBreakpoint = WTFMove(breakpoint); }
+    void setPauseOnUncaughtExceptionsBreakpoint(RefPtr<Breakpoint>&& breakpoint) { m_pauseOnUncaughtExceptionsBreakpoint = WTFMove(breakpoint); }
 
     enum ReasonForPause {
@@ -99 +107 @@
     bool schedulePauseForSpecialBreakpoint(Breakpoint&);
     bool cancelPauseForSpecialBreakpoint(Breakpoint&);
-    void breakProgram();
+    void breakProgram(RefPtr<Breakpoint>&& specialBreakpoint = nullptr);
     void continueProgram();
     void stepNextExpression();
@@ -282 +290 @@
     HashMap<SourceID, BlackboxType, WTF::IntHash<SourceID>, WTF::UnsignedWithZeroKeyHashTraits<SourceID>> m_blackboxedScripts;
 
-    PauseOnExceptionsState m_pauseOnExceptionsState;
-    bool m_pauseOnDebuggerStatements : 1;
     bool m_pauseAtNextOpportunity : 1;
     bool m_pauseOnStepNext : 1;
@@ -308 +314 @@
     BreakpointID m_pausingBreakpointID;
 
+    RefPtr<Breakpoint> m_pauseOnAllExceptionsBreakpoint;
+    RefPtr<Breakpoint> m_pauseOnUncaughtExceptionsBreakpoint;
+    RefPtr<Breakpoint> m_pauseOnDebuggerStatementsBreakpoint;
+
     unsigned m_nextProbeSampleId { 1 };
     unsigned m_currentProbeBatchId { 0 };

trunk/Source/JavaScriptCore/debugger/DebuggerCallFrame.cpp

@@ -219 +219 @@
 JSValue DebuggerCallFrame::evaluateWithScopeExtension(const String& script, JSObject* scopeExtensionObject, NakedPtr<Exception>& exception)
 {
-    ASSERT(isValid());
-    CallFrame* callFrame = m_validMachineFrame;
-    if (!callFrame)
+    CallFrame* callFrame = nullptr;
+    CodeBlock* codeBlock = nullptr;
+
+    auto* debuggerCallFrame = this;
+    while (debuggerCallFrame) {
+        ASSERT(debuggerCallFrame->isValid());
+
+        callFrame = debuggerCallFrame->m_validMachineFrame;
+        if (callFrame) {
+            if (debuggerCallFrame->isTailDeleted())
+                codeBlock = debuggerCallFrame->m_shadowChickenFrame.codeBlock;
+            else
+                codeBlock = callFrame->codeBlock();
+        }
+
+        if (callFrame && codeBlock)
+            break;
+
+        debuggerCallFrame = debuggerCallFrame->m_caller.get();
+    }
+
+    if (!callFrame || !codeBlock)
         return jsUndefined();
 
@@ -227 +246 @@
     JSLockHolder lock(vm);
     auto catchScope = DECLARE_CATCH_SCOPE(vm);
-
-    CodeBlock* codeBlock = nullptr;
-    if (isTailDeleted())
-        codeBlock = m_shadowChickenFrame.codeBlock;
-    else
-        codeBlock = callFrame->codeBlock();
-    if (!codeBlock)
-        return jsUndefined();
     
     JSGlobalObject* globalObject = codeBlock->globalObject();
@@ -264 +275 @@
     }
 
-    JSValue thisValue = this->thisValue(vm);
-    JSValue result = vm.interpreter->execute(eval, globalObject, thisValue, scope()->jsScope());
+    JSValue result = vm.interpreter->execute(eval, globalObject, debuggerCallFrame->thisValue(vm), debuggerCallFrame->scope()->jsScope());
     if (UNLIKELY(catchScope.exception())) {
         exception = catchScope.exception();

trunk/Source/JavaScriptCore/debugger/DebuggerCallFrame.h

@@ -62 +62 @@
     JS_EXPORT_PRIVATE Type type() const;
     JS_EXPORT_PRIVATE JSValue thisValue(VM&) const;
+
     JSValue evaluateWithScopeExtension(const String&, JSObject* scopeExtensionObject, NakedPtr<Exception>&);