Remove excessive headers from JavaScriptCore
[WebKit-https.git] / Source / JavaScriptCore / inspector / agents / InspectorDebuggerAgent.h
1 /*
2  * Copyright (C) 2010, 2013, 2015-2016 Apple Inc. All rights reserved.
3  * Copyright (C) 2010, 2011 Google Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1.  Redistributions of source code must retain the above copyright
10  *     notice, this list of conditions and the following disclaimer.
11  * 2.  Redistributions in binary form must reproduce the above copyright
12  *     notice, this list of conditions and the following disclaimer in the
13  *     documentation and/or other materials provided with the distribution.
14  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
15  *     its contributors may be used to endorse or promote products derived
16  *     from this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #pragma once
31
32 #include "InspectorBackendDispatchers.h"
33 #include "InspectorFrontendDispatchers.h"
34 #include "bindings/ScriptValue.h"
35 #include "debugger/Debugger.h"
36 #include "inspector/InspectorAgentBase.h"
37 #include "inspector/ScriptBreakpoint.h"
38 #include "inspector/ScriptDebugListener.h"
39 #include <wtf/Forward.h>
40 #include <wtf/HashMap.h>
41 #include <wtf/Noncopyable.h>
42 #include <wtf/Vector.h>
43
44 namespace Inspector {
45
46 class AsyncStackTrace;
47 class InjectedScript;
48 class InjectedScriptManager;
49 class InspectorArray;
50 class InspectorObject;
51 class ScriptDebugServer;
52 typedef String ErrorString;
53
54 class JS_EXPORT_PRIVATE InspectorDebuggerAgent : public InspectorAgentBase, public ScriptDebugListener, public DebuggerBackendDispatcherHandler {
55     WTF_MAKE_NONCOPYABLE(InspectorDebuggerAgent);
56     WTF_MAKE_FAST_ALLOCATED;
57 public:
58     static const char* backtraceObjectGroup;
59
60     virtual ~InspectorDebuggerAgent();
61
62     void didCreateFrontendAndBackend(FrontendRouter*, BackendDispatcher*) final;
63     void willDestroyFrontendAndBackend(DisconnectReason) final;
64
65     void enable(ErrorString&) final;
66     void disable(ErrorString&) final;
67     void setAsyncStackTraceDepth(ErrorString&, int depth) final;
68     void setBreakpointsActive(ErrorString&, bool active) final;
69     void setBreakpointByUrl(ErrorString&, int lineNumber, const String* const optionalURL, const String* const optionalURLRegex, const int* const optionalColumnNumber, const Inspector::InspectorObject* options, Inspector::Protocol::Debugger::BreakpointId*, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Debugger::Location>>& locations) final;
70     void setBreakpoint(ErrorString&, const Inspector::InspectorObject& location, const Inspector::InspectorObject* options, Inspector::Protocol::Debugger::BreakpointId*, RefPtr<Inspector::Protocol::Debugger::Location>& actualLocation) final;
71     void removeBreakpoint(ErrorString&, const String& breakpointIdentifier) final;
72     void continueUntilNextRunLoop(ErrorString&) final;
73     void continueToLocation(ErrorString&, const InspectorObject& location) final;
74     void searchInContent(ErrorString&, const String& scriptID, const String& query, const bool* const optionalCaseSensitive, const bool* const optionalIsRegex, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::GenericTypes::SearchMatch>>&) final;
75     void getScriptSource(ErrorString&, const String& scriptID, String* scriptSource) final;
76     void getFunctionDetails(ErrorString&, const String& functionId, RefPtr<Inspector::Protocol::Debugger::FunctionDetails>&) final;
77     void pause(ErrorString&) final;
78     void resume(ErrorString&) final;
79     void stepOver(ErrorString&) final;
80     void stepInto(ErrorString&) final;
81     void stepOut(ErrorString&) final;
82     void setPauseOnExceptions(ErrorString&, const String& pauseState) final;
83     void setPauseOnAssertions(ErrorString&, bool enabled) final;
84     void evaluateOnCallFrame(ErrorString&, const String& callFrameId, const String& expression, const String* const objectGroup, const bool* const includeCommandLineAPI, const bool* const doNotPauseOnExceptionsAndMuteConsole, const bool* const returnByValue, const bool* const generatePreview, const bool* const saveResult, RefPtr<Inspector::Protocol::Runtime::RemoteObject>& result, Inspector::Protocol::OptOutput<bool>* wasThrown, Inspector::Protocol::OptOutput<int>* savedResultIndex) final;
85     void setOverlayMessage(ErrorString&, const String* const) override;
86
87     bool isPaused() const;
88     bool breakpointsActive() const;
89
90     void setSuppressAllPauses(bool);
91
92     void handleConsoleAssert(const String& message);
93
94     void didScheduleAsyncCall(JSC::ExecState*, int asyncCallType, int callbackIdentifier, bool singleShot);
95     void didCancelAsyncCall(int asyncCallType, int callbackIdentifier);
96     void willDispatchAsyncCall(int asyncCallType, int callbackIdentifier);
97     void didDispatchAsyncCall();
98
99     void schedulePauseOnNextStatement(DebuggerFrontendDispatcher::Reason breakReason, RefPtr<InspectorObject>&& data);
100     void cancelPauseOnNextStatement();
101     bool pauseOnNextStatementEnabled() const { return m_javaScriptPauseScheduled; }
102
103     void breakProgram(DebuggerFrontendDispatcher::Reason breakReason, RefPtr<InspectorObject>&& data);
104     void scriptExecutionBlockedByCSP(const String& directiveText);
105
106     class Listener {
107     public:
108         virtual ~Listener() { }
109         virtual void debuggerWasEnabled() = 0;
110         virtual void debuggerWasDisabled() = 0;
111     };
112     void setListener(Listener* listener) { m_listener = listener; }
113
114 protected:
115     InspectorDebuggerAgent(AgentContext&);
116
117     InjectedScriptManager& injectedScriptManager() const { return m_injectedScriptManager; }
118     virtual InjectedScript injectedScriptForEval(ErrorString&, const int* executionContextId) = 0;
119
120     ScriptDebugServer& scriptDebugServer() { return m_scriptDebugServer; }
121
122     virtual void muteConsole() = 0;
123     virtual void unmuteConsole() = 0;
124
125     virtual void enable();
126     virtual void disable(bool skipRecompile);
127     void didPause(JSC::ExecState&, JSC::JSValue callFrames, JSC::JSValue exceptionOrCaughtValue) final;
128     void didContinue() final;
129
130     virtual String sourceMapURLForScript(const Script&);
131
132     void didClearGlobalObject();
133
134 private:
135     Ref<Inspector::Protocol::Array<Inspector::Protocol::Debugger::CallFrame>> currentCallFrames(const InjectedScript&);
136
137     void didParseSource(JSC::SourceID, const Script&) final;
138     void failedToParseSource(const String& url, const String& data, int firstLine, int errorLine, const String& errorMessage) final;
139
140     void breakpointActionSound(int breakpointActionIdentifier) final;
141     void breakpointActionProbe(JSC::ExecState&, const ScriptBreakpointAction&, unsigned batchId, unsigned sampleId, JSC::JSValue sample) final;
142
143     void resolveBreakpoint(const Script&, JSC::Breakpoint&);
144     void setBreakpoint(JSC::Breakpoint&, bool& existing);    
145     void didSetBreakpoint(const JSC::Breakpoint&, const String&, const ScriptBreakpoint&);
146
147     bool assertPaused(ErrorString&);
148     void clearDebuggerBreakpointState();
149     void clearInspectorBreakpointState();
150     void clearBreakDetails();
151     void clearExceptionValue();
152     void clearAsyncStackTraceData();
153
154     enum class ShouldDispatchResumed { No, WhenIdle, WhenContinued };
155     void registerIdleHandler();
156     void willStepAndMayBecomeIdle();
157     void didBecomeIdle();
158
159     RefPtr<InspectorObject> buildBreakpointPauseReason(JSC::BreakpointID);
160     RefPtr<InspectorObject> buildExceptionPauseReason(JSC::JSValue exception, const InjectedScript&);
161
162     bool breakpointActionsFromProtocol(ErrorString&, RefPtr<InspectorArray>& actions, BreakpointActions* result);
163
164     typedef std::pair<int, int> AsyncCallIdentifier;
165
166     typedef HashMap<JSC::SourceID, Script> ScriptsMap;
167     typedef HashMap<String, Vector<JSC::BreakpointID>> BreakpointIdentifierToDebugServerBreakpointIDsMap;
168     typedef HashMap<String, RefPtr<InspectorObject>> BreakpointIdentifierToBreakpointMap;
169     typedef HashMap<JSC::BreakpointID, String> DebugServerBreakpointIDToBreakpointIdentifier;
170
171     InjectedScriptManager& m_injectedScriptManager;
172     std::unique_ptr<DebuggerFrontendDispatcher> m_frontendDispatcher;
173     RefPtr<DebuggerBackendDispatcher> m_backendDispatcher;
174     ScriptDebugServer& m_scriptDebugServer;
175     Listener* m_listener { nullptr };
176     JSC::ExecState* m_pausedScriptState { nullptr };
177     Deprecated::ScriptValue m_currentCallStack;
178     ScriptsMap m_scripts;
179     BreakpointIdentifierToDebugServerBreakpointIDsMap m_breakpointIdentifierToDebugServerBreakpointIDs;
180     BreakpointIdentifierToBreakpointMap m_javaScriptBreakpoints;
181     DebugServerBreakpointIDToBreakpointIdentifier m_debuggerBreakpointIdentifierToInspectorBreakpointIdentifier;
182     JSC::BreakpointID m_continueToLocationBreakpointID;
183     DebuggerFrontendDispatcher::Reason m_breakReason;
184     RefPtr<InspectorObject> m_breakAuxData;
185     ShouldDispatchResumed m_conditionToDispatchResumed { ShouldDispatchResumed::No };
186     bool m_enablePauseWhenIdle { false };
187     HashMap<AsyncCallIdentifier, RefPtr<AsyncStackTrace>> m_pendingAsyncCalls;
188     std::optional<AsyncCallIdentifier> m_currentAsyncCallIdentifier { std::nullopt };
189     bool m_enabled { false };
190     bool m_javaScriptPauseScheduled { false };
191     bool m_hasExceptionValue { false };
192     bool m_didPauseStopwatch { false };
193     bool m_pauseOnAssertionFailures { false };
194     bool m_registeredIdleCallback { false };
195     int m_asyncStackTraceDepth { 0 };
196 };
197
198 } // namespace Inspector