Web Inspector: Automatically connect Web Inspector to ServiceWorker

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

Author: the-chenergy

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",

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

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;

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

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();

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)

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&);
 

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);

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&&);

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)))

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())

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;