Web Inspector: Automatically connect Web Inspector to ServiceWorker

the-chenergy · the-chenergy · commit a85f48918e35 · 2025-02-26T14:30:50.000-08:00
https://bugs.webkit.org/show_bug.cgi?id=264576 rdar://114997939 Reviewed by BJ Burg. (This work was done in collaboration with Razvan and was based on his draft at WebKit@377f3e1.) This commit enables automatically inspecting and pausing the ServiceWorkerDebuggable. The idea is similar to the same functionalities with the JSContext/JSGlobalObjectDebuggable. The general flow is: 1. When the debuggable is first created, we optionally mark it as inspectable. 2. As soon as the debuggable is marked inspectable, its main thread (the thread that it was created on) gets blocked. 3. When the auto-launched Web Inspector frontend finishes initializing, it notifies the backend. - It's important for the debuggable to wait for this signal because a genuine auto-inspection must appear attached to the debuggable before it begins execution, respecting any breakpoints set early on in its script (where auto-pausing is basically a breakpoint before line 1). 4. The backend unpauses the blocked debuggable. If auto-pausing was requested, tell the debugger agent to pause. The service worker begins executing script unless its worker thread was specified to start in the WorkerThreadStartMode::WaitForInspector. During that waiting period, the worker thread can perform tasks sent into its debugging run loop, until it's signaled to stop waiting and continue to execute the script like normal. This commit makes use of that interface to make the service worker pause (when justified, i.e. developerExtrasEnabled) before running the above flow resembling auto-inspecting a JSContext. * Source/WebCore/workers/service/context/ServiceWorkerThread.cpp: (WebCore::threadStartModeFromSettings): (WebCore::ServiceWorkerThread::ServiceWorkerThread): - When there is potentially a remote inspector that would like to auto-inspect, make it so that the thread waits on start before executing its script. * Source/WebCore/workers/service/context/ServiceWorkerThreadProxy.h: * Source/WebCore/workers/service/context/ServiceWorkerThreadProxy.cpp: (WebCore::ServiceWorkerThreadProxy::ServiceWorkerThreadProxy): (WebCore::ServiceWorkerThreadProxy::threadStartedRunningDebuggerTasks): - Setting inspectability is step #1 in the above flow. - In step #2, calling `debuggable->setInspectable(true)` might block already, but we don't want that until the worker thread is setup and have the run loop be in debug mode, so we do that in a callback instead. - In step #4, when connection to the inspector completes or fails, the setInspectable call only returns then, so we unblock the worker thread to resume code execution. * Source/WebCore/inspector/agents/worker/WorkerDebuggerAgent.h: * Source/WebCore/inspector/WorkerInspectorController.h: * Source/WebCore/inspector/WorkerInspectorController.cpp: (WebCore::WorkerInspectorController::frontendInitialized): (WebCore::WorkerInspectorController::connectFrontend): (WebCore::WorkerInspectorController::disconnectFrontend): (WebCore::WorkerInspectorController::createLazyAgents): (WebCore::WorkerInspectorController::ensureDebuggerAgent): * Source/WebCore/workers/service/context/ServiceWorkerDebuggable.cpp: (WebCore::ServiceWorkerDebuggable::connect): * Source/WebCore/workers/service/context/ServiceWorkerInspectorProxy.h: * Source/WebCore/workers/service/context/ServiceWorkerInspectorProxy.cpp: (WebCore::ServiceWorkerInspectorProxy::connectToWorker): - Mimic the logic for auto-inspecting a JSContext/JSGlobalObjectDebuggable. * Source/JavaScriptCore/inspector/protocol/Inspector.json: - Step #3 in the above flow, notify the backend when frontend completes setting up. * Source/WebCore/workers/service/context/ServiceWorkerDebuggable.h: - Allow service workers to be auto-inspected. (This is checked at https://github.com/rcaliman-apple/WebKit/blob/eng/Web-Inspector-Automatically-connect-Web-Inspector-to-ServiceWorker/Source/JavaScriptCore/inspector/remote/RemoteInspectionTarget.cpp#L95) * Source/WTF/wtf/PlatformEnableCocoa.h: - Add feature flag just in case. Canonical link: https://commits.webkit.org/291167@main
diff --git a/Source/JavaScriptCore/inspector/protocol/Inspector.json b/Source/JavaScriptCore/inspector/protocol/Inspector.json
@@ -1,7 +1,7 @@
 {
     "domain": "Inspector",
-    "debuggableTypes": ["itml", "javascript", "page", "web-page"],
-    "targetTypes": ["itml", "javascript", "page"],
+    "debuggableTypes": ["itml", "javascript", "page", "service-worker", "web-page"],
+    "targetTypes": ["itml", "javascript", "page", "service-worker"],
     "commands": [
         {
             "name": "enable",
diff --git a/Source/WTF/wtf/PlatformEnableCocoa.h b/Source/WTF/wtf/PlatformEnableCocoa.h
@@ -788,6 +788,10 @@
 #define ENABLE_REMOTE_INSPECTOR 1
 #endif
 
+#if !defined(ENABLE_REMOTE_INSPECTOR_SERVICE_WORKER_AUTO_INSPECTION)
+#define ENABLE_REMOTE_INSPECTOR_SERVICE_WORKER_AUTO_INSPECTION 1
+#endif
+
 #if !defined(ENABLE_REMOTE_LAYER_TREE_ON_MAC_BY_DEFAULT) && PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 140000
 #define ENABLE_REMOTE_LAYER_TREE_ON_MAC_BY_DEFAULT 1
 #endif
diff --git a/Source/WebCore/inspector/WorkerInspectorController.cpp b/Source/WebCore/inspector/WorkerInspectorController.cpp
@@ -50,6 +50,7 @@
 #include "WorkerTimelineAgent.h"
 #include "WorkerToPageFrontendChannel.h"
 #include "WorkerWorkerAgent.h"
+#include <JavaScriptCore/InspectorAgent.h>
 #include <JavaScriptCore/InspectorAgentBase.h>
 #include <JavaScriptCore/InspectorBackendDispatcher.h>
 #include <JavaScriptCore/InspectorFrontendChannel.h>
@@ -101,11 +102,31 @@ void WorkerInspectorController::workerTerminating()
     m_debugger = nullptr;
 }
 
-void WorkerInspectorController::connectFrontend()
+void WorkerInspectorController::frontendInitialized()
+{
+#if ENABLE(REMOTE_INSPECTOR) && ENABLE(REMOTE_INSPECTOR_SERVICE_WORKER_AUTO_INSPECTION)
+    if (m_pauseAfterInitialization) {
+        m_pauseAfterInitialization = false;
+
+        ensureDebuggerAgent().enable();
+        ensureDebuggerAgent().pause();
+    }
+
+    if (m_isAutomaticInspection && m_frontendInitializedCallback)
+        m_frontendInitializedCallback();
+    m_frontendInitializedCallback = { };
+#endif
+}
+
+void WorkerInspectorController::connectFrontend(bool isAutomaticInspection, bool immediatelyPause, Function<void()>&& frontendInitializedCallback)
 {
     ASSERT(!m_frontendRouter->hasFrontends());
     ASSERT(!m_forwardingChannel);
 
+    m_isAutomaticInspection = isAutomaticInspection;
+    m_pauseAfterInitialization = immediatelyPause;
+    m_frontendInitializedCallback = WTFMove(frontendInitializedCallback);
+
     createLazyAgents();
 
     callOnMainThread([] {
@@ -124,6 +145,10 @@ void WorkerInspectorController::connectFrontend()
 
 void WorkerInspectorController::disconnectFrontend(Inspector::DisconnectReason reason)
 {
+    m_isAutomaticInspection = false;
+    m_pauseAfterInitialization = false;
+    m_frontendInitializedCallback = { };
+
     if (!m_frontendRouter->hasFrontends())
         return;
 
@@ -203,17 +228,16 @@ void WorkerInspectorController::createLazyAgents()
     m_agents.append(makeUnique<WorkerRuntimeAgent>(workerContext));
 
     if (is<ServiceWorkerGlobalScope>(m_globalScope)) {
+        m_agents.append(makeUnique<InspectorAgent>(workerContext));
         m_agents.append(makeUnique<ServiceWorkerAgent>(workerContext));
         m_agents.append(makeUnique<WorkerNetworkAgent>(workerContext));
     }
 
     m_agents.append(makeUnique<WebHeapAgent>(workerContext));
 
-    auto debuggerAgent = makeUnique<WorkerDebuggerAgent>(workerContext);
-    auto debuggerAgentPtr = debuggerAgent.get();
-    m_agents.append(WTFMove(debuggerAgent));
+    ensureDebuggerAgent();
+    m_agents.append(makeUnique<WorkerDOMDebuggerAgent>(workerContext, m_debuggerAgent.get()));
 
-    m_agents.append(makeUnique<WorkerDOMDebuggerAgent>(workerContext, debuggerAgentPtr));
     m_agents.append(makeUnique<WorkerAuditAgent>(workerContext));
     m_agents.append(makeUnique<WorkerCanvasAgent>(workerContext));
     m_agents.append(makeUnique<WorkerTimelineAgent>(workerContext));
@@ -227,6 +251,17 @@ void WorkerInspectorController::createLazyAgents()
         commandLineAPIHost->init(m_instrumentingAgents.copyRef());
 }
 
+WorkerDebuggerAgent& WorkerInspectorController::ensureDebuggerAgent()
+{
+    if (!m_debuggerAgent) {
+        auto workerContext = workerAgentContext();
+        auto debuggerAgent = makeUnique<WorkerDebuggerAgent>(workerContext);
+        m_debuggerAgent = debuggerAgent.get();
+        m_agents.append(WTFMove(debuggerAgent));
+    }
+    return *m_debuggerAgent;
+}
+
 InspectorFunctionCallHandler WorkerInspectorController::functionCallHandler() const
 {
     return WebCore::functionCallHandlerFromAnyThread;
diff --git a/Source/WebCore/inspector/WorkerInspectorController.h b/Source/WebCore/inspector/WorkerInspectorController.h
@@ -25,6 +25,7 @@
 
 #pragma once
 
+#include "WorkerDebuggerAgent.h"
 #include "WorkerOrWorkletGlobalScope.h"
 #include <JavaScriptCore/InspectorAgentRegistry.h>
 #include <JavaScriptCore/InspectorEnvironment.h>
@@ -54,7 +55,7 @@ class WorkerInspectorController final : public Inspector::InspectorEnvironment {
 
     void workerTerminating();
 
-    void connectFrontend();
+    void connectFrontend(bool isAutomaticInspection = false, bool immediatelyPause = false, Function<void()>&& frontendInitializedCallback = { });
     void disconnectFrontend(Inspector::DisconnectReason);
 
     void dispatchMessageFromFrontend(const String&);
@@ -64,7 +65,7 @@ class WorkerInspectorController final : public Inspector::InspectorEnvironment {
     bool canAccessInspectedScriptState(JSC::JSGlobalObject*) const override { return true; }
     Inspector::InspectorFunctionCallHandler functionCallHandler() const override;
     Inspector::InspectorEvaluateHandler evaluateHandler() const override;
-    void frontendInitialized() override { }
+    void frontendInitialized() final;
     WTF::Stopwatch& executionStopwatch() const override;
     JSC::Debugger* debugger() override;
     JSC::VM& vm() override;
@@ -74,6 +75,7 @@ class WorkerInspectorController final : public Inspector::InspectorEnvironment {
 
     WorkerAgentContext workerAgentContext();
     void createLazyAgents();
+    WorkerDebuggerAgent& ensureDebuggerAgent();
 
     void updateServiceWorkerPageFrontendCount();
 
@@ -84,9 +86,13 @@ class WorkerInspectorController final : public Inspector::InspectorEnvironment {
     Ref<WTF::Stopwatch> m_executionStopwatch;
     std::unique_ptr<WorkerDebugger> m_debugger;
     Inspector::AgentRegistry m_agents;
+    CheckedPtr<WorkerDebuggerAgent> m_debuggerAgent;
     WeakRef<WorkerOrWorkletGlobalScope> m_globalScope;
     std::unique_ptr<Inspector::FrontendChannel> m_forwardingChannel;
     bool m_didCreateLazyAgents { false };
+    bool m_isAutomaticInspection { false };
+    bool m_pauseAfterInitialization { false };
+    Function<void()> m_frontendInitializedCallback;
 };
 
 } // namespace WebCore
diff --git a/Source/WebCore/inspector/agents/worker/WorkerDebuggerAgent.h b/Source/WebCore/inspector/agents/worker/WorkerDebuggerAgent.h
@@ -26,15 +26,17 @@
 #pragma once
 
 #include "WebDebuggerAgent.h"
+#include <wtf/CheckedRef.h>
 #include <wtf/TZoneMalloc.h>
 
 namespace WebCore {
 
 class WorkerOrWorkletGlobalScope;
 
-class WorkerDebuggerAgent final : public WebDebuggerAgent {
+class WorkerDebuggerAgent final : public WebDebuggerAgent, public WTF::CanMakeThreadSafeCheckedPtr<WorkerDebuggerAgent> {
     WTF_MAKE_NONCOPYABLE(WorkerDebuggerAgent);
     WTF_MAKE_TZONE_ALLOCATED(WorkerDebuggerAgent);
+    WTF_OVERRIDE_DELETE_FOR_CHECKED_PTR(WorkerDebuggerAgent);
 public:
     WorkerDebuggerAgent(WorkerAgentContext&);
     ~WorkerDebuggerAgent();
diff --git a/Source/WebCore/workers/service/context/ServiceWorkerDebuggable.cpp b/Source/WebCore/workers/service/context/ServiceWorkerDebuggable.cpp
@@ -30,6 +30,8 @@
 
 #include "ServiceWorkerInspectorProxy.h"
 #include "ServiceWorkerThreadProxy.h"
+#include "WorkerRunLoop.h"
+#include <JavaScriptCore/RemoteInspector.h>
 #include <wtf/TZoneMallocInlines.h>
 
 namespace WebCore {
@@ -49,10 +51,17 @@ ServiceWorkerDebuggable::ServiceWorkerDebuggable(ServiceWorkerThreadProxy& servi
 {
 }
 
-void ServiceWorkerDebuggable::connect(FrontendChannel& channel, bool, bool)
+void ServiceWorkerDebuggable::connect(FrontendChannel& channel, bool isAutomaticInspection, bool immediatelyPause)
 {
-    if (RefPtr serviceWorkerThreadProxy = m_serviceWorkerThreadProxy.get())
+    if (RefPtr serviceWorkerThreadProxy = m_serviceWorkerThreadProxy.get()) {
+#if ENABLE(REMOTE_INSPECTOR_SERVICE_WORKER_AUTO_INSPECTION)
+        serviceWorkerThreadProxy->inspectorProxy().connectToWorker(channel, *this, isAutomaticInspection, immediatelyPause);
+#else
+        UNUSED_PARAM(isAutomaticInspection);
+        UNUSED_PARAM(immediatelyPause);
         serviceWorkerThreadProxy->inspectorProxy().connectToWorker(channel);
+#endif
+    }
 }
 
 void ServiceWorkerDebuggable::disconnect(FrontendChannel& channel)
diff --git a/Source/WebCore/workers/service/context/ServiceWorkerDebuggable.h b/Source/WebCore/workers/service/context/ServiceWorkerDebuggable.h
@@ -53,6 +53,8 @@ class ServiceWorkerDebuggable final : public Inspector::RemoteInspectionTarget {
     void disconnect(Inspector::FrontendChannel&) final;
     void dispatchMessageFromRemote(String&& message) final;
 
+    bool automaticInspectionAllowed() const final { return true; }
+
 private:
     ServiceWorkerDebuggable(ServiceWorkerThreadProxy&, const ServiceWorkerContextData&);
 
diff --git a/Source/WebCore/workers/service/context/ServiceWorkerInspectorProxy.cpp b/Source/WebCore/workers/service/context/ServiceWorkerInspectorProxy.cpp
@@ -28,13 +28,15 @@
 
 #include "SWContextManager.h"
 #include "ScriptExecutionContext.h"
+#include "ServiceWorkerDebuggable.h"
 #include "ServiceWorkerGlobalScope.h"
 #include "ServiceWorkerThreadProxy.h"
 #include "WorkerInspectorController.h"
 #include "WorkerRunLoop.h"
 #include <JavaScriptCore/InspectorAgentBase.h>
 #include <JavaScriptCore/InspectorFrontendChannel.h>
 #include <wtf/TZoneMallocInlines.h>
+#include <wtf/ThreadSafeWeakPtr.h>
 
 namespace WebCore {
 
@@ -70,6 +72,28 @@ void ServiceWorkerInspectorProxy::connectToWorker(FrontendChannel& channel)
     });
 }
 
+#if ENABLE(REMOTE_INSPECTOR_SERVICE_WORKER_AUTO_INSPECTION)
+
+void ServiceWorkerInspectorProxy::connectToWorker(FrontendChannel& channel, ServiceWorkerDebuggable& debuggable, bool isAutomaticConnection, bool immediatelyPause)
+{
+    m_channel = &channel;
+
+    RefPtr serviceWorkerThreadProxy = m_serviceWorkerThreadProxy.get();
+    SWContextManager::singleton().setAsInspected(serviceWorkerThreadProxy->identifier(), true);
+
+    ThreadSafeWeakPtr weakDebuggable = ThreadSafeWeakPtr { debuggable };
+    serviceWorkerThreadProxy->thread().runLoop().postDebuggerTask(
+        [weakDebuggable, isAutomaticConnection, immediatelyPause](ScriptExecutionContext& context) {
+            Function<void()> handleFrontendInitialized = [weakDebuggable] {
+                if (RefPtr debuggable = weakDebuggable.get())
+                    debuggable->unpauseForInitializedInspector();
+            };
+            downcast<WorkerGlobalScope>(context).inspectorController().connectFrontend(isAutomaticConnection, immediatelyPause, WTFMove(handleFrontendInitialized));
+        });
+}
+
+#endif
+
 void ServiceWorkerInspectorProxy::disconnectFromWorker(FrontendChannel& channel)
 {
     ASSERT_UNUSED(channel, &channel == m_channel);
diff --git a/Source/WebCore/workers/service/context/ServiceWorkerInspectorProxy.h b/Source/WebCore/workers/service/context/ServiceWorkerInspectorProxy.h
@@ -25,6 +25,7 @@
 
 #pragma once
 
+#include "ServiceWorkerDebuggable.h"
 #include <wtf/Forward.h>
 #include <wtf/Noncopyable.h>
 #include <wtf/TZoneMalloc.h>
@@ -51,6 +52,9 @@ class ServiceWorkerInspectorProxy {
     void serviceWorkerTerminated();
 
     WEBCORE_EXPORT void connectToWorker(Inspector::FrontendChannel&);
+#if ENABLE(REMOTE_INSPECTOR_SERVICE_WORKER_AUTO_INSPECTION)
+    WEBCORE_EXPORT void connectToWorker(Inspector::FrontendChannel&, ServiceWorkerDebuggable&, bool isAutomaticConnection = false, bool immediatelyPause = false);
+#endif
     WEBCORE_EXPORT void disconnectFromWorker(Inspector::FrontendChannel&);
     WEBCORE_EXPORT void sendMessageToWorker(String&&);
     void sendMessageFromWorkerToFrontend(String&&);
diff --git a/Source/WebCore/workers/service/context/ServiceWorkerThread.cpp b/Source/WebCore/workers/service/context/ServiceWorkerThread.cpp
@@ -117,8 +117,19 @@ static WorkerParameters generateWorkerParameters(const ServiceWorkerContextData&
     };
 }
 
+static WorkerThreadStartMode threadStartModeFromSettings()
+{
+#if ENABLE(REMOTE_INSPECTOR) && ENABLE(REMOTE_INSPECTOR_SERVICE_WORKER_AUTO_INSPECTION)
+    // FIXME: Find a reasonable heuristic for when the service worker definitely won't be
+    // automatically inspected, in which case there's no need to force this start mode.
+    return WorkerThreadStartMode::WaitForInspector;
+#else
+    return WorkerThreadStartMode::Normal;
+#endif
+}
+
 ServiceWorkerThread::ServiceWorkerThread(ServiceWorkerContextData&& contextData, ServiceWorkerData&& workerData, String&& userAgent, WorkerThreadMode workerThreadMode, const Settings::Values& settingsValues, WorkerLoaderProxy& loaderProxy, WorkerDebuggerProxy& debuggerProxy, WorkerBadgeProxy& badgeProxy, IDBClient::IDBConnectionProxy* idbConnectionProxy, SocketProvider* socketProvider, std::unique_ptr<NotificationClient>&& notificationClient, PAL::SessionID sessionID, std::optional<uint64_t> noiseInjectionHashSalt, OptionSet<AdvancedPrivacyProtections> advancedPrivacyProtections)
-    : WorkerThread(generateWorkerParameters(contextData, WTFMove(userAgent), workerThreadMode, settingsValues, sessionID, advancedPrivacyProtections, noiseInjectionHashSalt), contextData.script, loaderProxy, debuggerProxy, DummyServiceWorkerThreadProxy::shared(), badgeProxy, WorkerThreadStartMode::Normal, contextData.registration.key.topOrigin().securityOrigin().get(), idbConnectionProxy, socketProvider, JSC::RuntimeFlags::createAllEnabled())
+    : WorkerThread(generateWorkerParameters(contextData, WTFMove(userAgent), workerThreadMode, settingsValues, sessionID, advancedPrivacyProtections, noiseInjectionHashSalt), contextData.script, loaderProxy, debuggerProxy, DummyServiceWorkerThreadProxy::shared(), badgeProxy, threadStartModeFromSettings(), contextData.registration.key.topOrigin().securityOrigin().get(), idbConnectionProxy, socketProvider, JSC::RuntimeFlags::createAllEnabled())
     , m_serviceWorkerIdentifier(contextData.serviceWorkerIdentifier)
     , m_jobDataIdentifier(contextData.jobDataIdentifier)
     , m_contextData(crossThreadCopy(WTFMove(contextData)))
diff --git a/Source/WebCore/workers/service/context/ServiceWorkerThreadProxy.cpp b/Source/WebCore/workers/service/context/ServiceWorkerThreadProxy.cpp
@@ -85,9 +85,19 @@ ServiceWorkerThreadProxy::ServiceWorkerThreadProxy(Ref<Page>&& page, ServiceWork
     allServiceWorkerThreadProxies().add(*this);
 
 #if ENABLE(REMOTE_INSPECTOR)
-    m_remoteDebuggable->setInspectable(m_page->inspectable());
     m_remoteDebuggable->init();
-#endif
+
+#if ENABLE(REMOTE_INSPECTOR_SERVICE_WORKER_AUTO_INSPECTION)
+    thread().runLoop().postDebuggerTask([this, protectedThis = Ref { *this }](ScriptExecutionContext&) {
+        callOnMainThread([this, protectedThis] {
+            threadStartedRunningDebuggerTasks();
+        });
+    });
+#else
+    m_remoteDebuggable->setInspectable(m_page->inspectable());
+#endif // not ENABLE(REMOTE_INSPECTOR_SERVICE_WORKER_AUTO_INSPECTION)
+
+#endif // not ENABLE(REMOTE_INSPECTOR)
 }
 
 ServiceWorkerThreadProxy::~ServiceWorkerThreadProxy()
@@ -101,6 +111,21 @@ ServiceWorkerThreadProxy::~ServiceWorkerThreadProxy()
     m_serviceWorkerThread->clearProxies();
 }
 
+#if ENABLE(REMOTE_INSPECTOR) && ENABLE(REMOTE_INSPECTOR_SERVICE_WORKER_AUTO_INSPECTION)
+
+void ServiceWorkerThreadProxy::threadStartedRunningDebuggerTasks()
+{
+    m_remoteDebuggable->setInspectable(m_page->inspectable());
+
+    // In case the worker is paused running debugger tasks, ensure we break out of
+    // the pause since this will be the last debugger task we send to the worker.
+    thread().runLoop().postDebuggerTask([this, protectedThis = Ref { *this }](ScriptExecutionContext&) {
+        thread().stopRunningDebuggerTasks();
+    });
+}
+
+#endif
+
 void ServiceWorkerThreadProxy::setLastNavigationWasAppInitiated(bool wasAppInitiated)
 {
     if (m_document->loader())
diff --git a/Source/WebCore/workers/service/context/ServiceWorkerThreadProxy.h b/Source/WebCore/workers/service/context/ServiceWorkerThreadProxy.h
@@ -100,6 +100,10 @@ class ServiceWorkerThreadProxy final : public ThreadSafeRefCountedAndCanMakeThre
 
     WEBCORE_EXPORT void setInspectable(bool);
 
+#if ENABLE(REMOTE_INSPECTOR) && ENABLE(REMOTE_INSPECTOR_SERVICE_WORKER_AUTO_INSPECTION)
+    ServiceWorkerDebuggable& remoteDebuggable() { return m_remoteDebuggable; }
+#endif
+
     uint32_t checkedPtrCount() const { return CanMakeThreadSafeCheckedPtr<ServiceWorkerThreadProxy>::checkedPtrCount(); }
     uint32_t checkedPtrCountWithoutThreadCheck() const { return CanMakeThreadSafeCheckedPtr<ServiceWorkerThreadProxy>::checkedPtrCountWithoutThreadCheck(); }
     void incrementCheckedPtrCount() const { CanMakeThreadSafeCheckedPtr<ServiceWorkerThreadProxy>::incrementCheckedPtrCount(); }
@@ -111,6 +115,10 @@ class ServiceWorkerThreadProxy final : public ThreadSafeRefCountedAndCanMakeThre
     WEBCORE_EXPORT static void networkStateChanged(bool isOnLine);
     bool postTaskForModeToWorkerOrWorkletGlobalScope(ScriptExecutionContext::Task&&, const String& mode);
 
+#if ENABLE(REMOTE_INSPECTOR) && ENABLE(REMOTE_INSPECTOR_SERVICE_WORKER_AUTO_INSPECTION)
+    void threadStartedRunningDebuggerTasks();
+#endif
+
     // WorkerLoaderProxy
     void postTaskToLoader(ScriptExecutionContext::Task&&) final;
     ScriptExecutionContextIdentifier loaderContextIdentifier() const final;

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"domain": "Inspector",`
`3`		`- "debuggableTypes": ["itml", "javascript", "page", "web-page"],`
`4`		`- "targetTypes": ["itml", "javascript", "page"],`
	`3`	`+ "debuggableTypes": ["itml", "javascript", "page", "service-worker", "web-page"],`
	`4`	`+ "targetTypes": ["itml", "javascript", "page", "service-worker"],`
`5`	`5`	`"commands": [`
`6`	`6`	`{`
`7`	`7`	`"name": "enable",`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,8 @@`
`30`	`30`
`31`	`31`	`#include "ServiceWorkerInspectorProxy.h"`
`32`	`32`	`#include "ServiceWorkerThreadProxy.h"`
	`33`	`+#include "WorkerRunLoop.h"`
	`34`	`+#include <JavaScriptCore/RemoteInspector.h>`
`33`	`35`	`#include <wtf/TZoneMallocInlines.h>`
`34`	`36`
`35`	`37`	`namespace WebCore {`
`@@ -49,10 +51,17 @@ ServiceWorkerDebuggable::ServiceWorkerDebuggable(ServiceWorkerThreadProxy& servi`
`49`	`51`	`{`
`50`	`52`	`}`
`51`	`53`
`52`		`-void ServiceWorkerDebuggable::connect(FrontendChannel& channel, bool, bool)`
	`54`	`+void ServiceWorkerDebuggable::connect(FrontendChannel& channel, bool isAutomaticInspection, bool immediatelyPause)`
`53`	`55`	`{`
`54`		`- if (RefPtr serviceWorkerThreadProxy = m_serviceWorkerThreadProxy.get())`
	`56`	`+ if (RefPtr serviceWorkerThreadProxy = m_serviceWorkerThreadProxy.get()) {`
	`57`	`+#if ENABLE(REMOTE_INSPECTOR_SERVICE_WORKER_AUTO_INSPECTION)`
	`58`	`+ serviceWorkerThreadProxy->inspectorProxy().connectToWorker(channel, *this, isAutomaticInspection, immediatelyPause);`
	`59`	`+#else`
	`60`	`+ UNUSED_PARAM(isAutomaticInspection);`
	`61`	`+ UNUSED_PARAM(immediatelyPause);`
`55`	`62`	`serviceWorkerThreadProxy->inspectorProxy().connectToWorker(channel);`
	`63`	`+#endif`
	`64`	`+ }`
`56`	`65`	`}`
`57`	`66`
`58`	`67`	`void ServiceWorkerDebuggable::disconnect(FrontendChannel& channel)`