Web Inspector: Canvas: show WebGPU shader pipelines
[WebKit-https.git] / Source / WebCore / inspector / agents / InspectorCanvasAgent.h
1 /*
2  * Copyright (C) 2017 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #pragma once
27
28 #include "CallTracerTypes.h"
29 #include "CanvasBase.h"
30 #include "InspectorCanvas.h"
31 #include "InspectorWebAgentBase.h"
32 #include "Timer.h"
33 #include <JavaScriptCore/InspectorBackendDispatchers.h>
34 #include <JavaScriptCore/InspectorFrontendDispatchers.h>
35 #include <initializer_list>
36 #include <wtf/Forward.h>
37
38 namespace Inspector {
39 class InjectedScriptManager;
40 }
41
42 namespace WebCore {
43
44 class CanvasRenderingContext;
45 class InspectorShaderProgram;
46 #if ENABLE(WEBGL)
47 class WebGLProgram;
48 class WebGLRenderingContextBase;
49 #endif
50 #if ENABLE(WEBGPU)
51 class GPUCanvasContext;
52 class WebGPUDevice;
53 class WebGPUPipeline;
54 class WebGPUSwapChain;
55 #endif
56
57 typedef String ErrorString;
58
59 class InspectorCanvasAgent final : public InspectorAgentBase, public Inspector::CanvasBackendDispatcherHandler, public CanvasObserver {
60     WTF_MAKE_NONCOPYABLE(InspectorCanvasAgent);
61     WTF_MAKE_FAST_ALLOCATED;
62 public:
63     InspectorCanvasAgent(PageAgentContext&);
64     virtual ~InspectorCanvasAgent();
65
66     // InspectorAgentBase
67     void didCreateFrontendAndBackend(Inspector::FrontendRouter*, Inspector::BackendDispatcher*);
68     void willDestroyFrontendAndBackend(Inspector::DisconnectReason);
69     void discardAgent();
70
71     // CanvasBackendDispatcherHandler
72     void enable(ErrorString&);
73     void disable(ErrorString&);
74     void requestNode(ErrorString&, const String& canvasId, int* nodeId);
75     void requestContent(ErrorString&, const String& canvasId, String* content);
76     void requestClientNodes(ErrorString&, const String& canvasId, RefPtr<JSON::ArrayOf<int>>&);
77     void resolveContext(ErrorString&, const String& canvasId, const String* objectGroup, RefPtr<Inspector::Protocol::Runtime::RemoteObject>&);
78     void setRecordingAutoCaptureFrameCount(ErrorString&, int count);
79     void startRecording(ErrorString&, const String& canvasId, const int* frameCount, const int* memoryLimit);
80     void stopRecording(ErrorString&, const String& canvasId);
81     void requestShaderSource(ErrorString&, const String& programId, const String& shaderType, String* source);
82     void updateShader(ErrorString&, const String& programId, const String& shaderType, const String& source);
83     void setShaderProgramDisabled(ErrorString&, const String& programId, bool disabled);
84     void setShaderProgramHighlighted(ErrorString&, const String& programId, bool highlighted);
85
86     // CanvasObserver
87     void canvasChanged(CanvasBase&, const FloatRect&);
88     void canvasResized(CanvasBase&) { }
89     void canvasDestroyed(CanvasBase&);
90
91     // InspectorInstrumentation
92     void frameNavigated(Frame&);
93     void didChangeCSSCanvasClientNodes(CanvasBase&);
94     void didCreateCanvasRenderingContext(CanvasRenderingContext&);
95     void didChangeCanvasMemory(CanvasRenderingContext&);
96     void recordCanvasAction(CanvasRenderingContext&, const String&, std::initializer_list<RecordCanvasActionVariant>&& = { });
97     void didFinishRecordingCanvasFrame(CanvasRenderingContext&, bool forceDispatch = false);
98     void consoleStartRecordingCanvas(CanvasRenderingContext&, JSC::ExecState&, JSC::JSObject* options);
99 #if ENABLE(WEBGL)
100     void didEnableExtension(WebGLRenderingContextBase&, const String&);
101     void didCreateWebGLProgram(WebGLRenderingContextBase&, WebGLProgram&);
102     void willDestroyWebGLProgram(WebGLProgram&);
103     bool isWebGLProgramDisabled(WebGLProgram&);
104     bool isWebGLProgramHighlighted(WebGLProgram&);
105 #endif
106 #if ENABLE(WEBGPU)
107     void didCreateWebGPUDevice(WebGPUDevice&);
108     void willDestroyWebGPUDevice(WebGPUDevice&);
109     void willConfigureSwapChain(GPUCanvasContext&, WebGPUSwapChain&);
110     void didCreateWebGPUPipeline(WebGPUDevice&, WebGPUPipeline&);
111     void willDestroyWebGPUPipeline(WebGPUPipeline&);
112 #endif
113
114 private:
115     struct RecordingOptions {
116         Optional<long> frameCount;
117         Optional<long> memoryLimit;
118         Optional<String> name;
119     };
120     void startRecording(InspectorCanvas&, Inspector::Protocol::Recording::Initiator, RecordingOptions&& = { });
121
122     void canvasDestroyedTimerFired();
123     void programDestroyedTimerFired();
124     void reset();
125
126     InspectorCanvas& bindCanvas(CanvasRenderingContext&, bool captureBacktrace);
127 #if ENABLE(WEBGPU)
128     InspectorCanvas& bindCanvas(WebGPUDevice&, bool captureBacktrace);
129 #endif
130     void unbindCanvas(InspectorCanvas&);
131     RefPtr<InspectorCanvas> assertInspectorCanvas(ErrorString&, const String& canvasId);
132     RefPtr<InspectorCanvas> findInspectorCanvas(CanvasRenderingContext&);
133 #if ENABLE(WEBGPU)
134     RefPtr<InspectorCanvas> findInspectorCanvas(WebGPUDevice&);
135 #endif
136
137     void unbindProgram(InspectorShaderProgram&);
138     RefPtr<InspectorShaderProgram> assertInspectorProgram(ErrorString&, const String& programId);
139 #if ENABLE(WEBGL)
140     RefPtr<InspectorShaderProgram> findInspectorProgram(WebGLProgram&);
141 #endif
142 #if ENABLE(WEBGPU)
143     RefPtr<InspectorShaderProgram> findInspectorProgram(WebGPUPipeline&);
144 #endif
145
146     std::unique_ptr<Inspector::CanvasFrontendDispatcher> m_frontendDispatcher;
147     RefPtr<Inspector::CanvasBackendDispatcher> m_backendDispatcher;
148
149     Inspector::InjectedScriptManager& m_injectedScriptManager;
150     Page& m_inspectedPage;
151
152     HashMap<String, RefPtr<InspectorCanvas>> m_identifierToInspectorCanvas;
153     Vector<String> m_removedCanvasIdentifiers;
154     Timer m_canvasDestroyedTimer;
155
156     HashMap<String, RefPtr<InspectorShaderProgram>> m_identifierToInspectorProgram;
157     Vector<String> m_removedProgramIdentifiers;
158     Timer m_programDestroyedTimer;
159
160     Optional<size_t> m_recordingAutoCaptureFrameCount;
161 };
162
163 } // namespace WebCore