Changeset 291467 in webkit

Timestamp:

Mar 18, 2022 12:33:15 AM (4 months ago)

Author:

youenn@apple.com

Message:

Keep service workers alive when they are inspected even though they should be terminated
​https://bugs.webkit.org/show_bug.cgi?id=237827
<rdar://88313935>

Reviewed by Alex Christensen.

Source/WebCore:

Store in SWServerWorker whether a worker is inspected or is processing push events.
In that case, we delay termination of workers until it is no longer inspected or no longer processing push events.
Two code paths are happening:

1. A service worker was triggered with service worker clients, and all service worker clients are removed. At that point, we were previously terminating service workers after a delay. Instead, we now only terminate workers that are no longer inspected or no longer processing push events. We reschedule the timer to continue trying removing the context connection.
2. A service worker is not stopped by removal of service worker clients. In that case, we need to terminate the service workers when inspected and/or push counter gets back to regular (not inspected, no push counter). When terminating such a service worker, we try removing the context connection as well.

To make sure SWServerWorker knows whether inspectable or not, we add connection support to transmit whether inspected from WebProcess.
ServiceWorkerInspectorProxy is responsible to update the inspectable value.
Introduce internals API to set inspected state of a service worker.

Covered by new API tests.

• testing/ServiceWorkerInternals.cpp:
• testing/ServiceWorkerInternals.h:
• testing/ServiceWorkerInternals.idl:
• workers/service/context/SWContextManager.cpp:
• workers/service/context/SWContextManager.h:
• workers/service/context/ServiceWorkerInspectorProxy.cpp:
• workers/service/server/SWServer.cpp:
• workers/service/server/SWServer.h:
• workers/service/server/SWServerToContextConnection.cpp:
• workers/service/server/SWServerToContextConnection.h:
• workers/service/server/SWServerWorker.cpp:
• workers/service/server/SWServerWorker.h:

Source/WebKit:

• NetworkProcess/ServiceWorker/WebSWServerToContextConnection.messages.in:
• WebProcess/Storage/WebSWContextManagerConnection.cpp:
• WebProcess/Storage/WebSWContextManagerConnection.h:

Tools:

• TestWebKitAPI/Tests/WebKitCocoa/PushAPI.mm:

Location:

trunk

Files:

• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/testing/ServiceWorkerInternals.cpp (modified) (1 diff)
• Source/WebCore/testing/ServiceWorkerInternals.h (modified) (1 diff)
• Source/WebCore/testing/ServiceWorkerInternals.idl (modified) (1 diff)
• Source/WebCore/workers/service/context/SWContextManager.cpp (modified) (1 diff)
• Source/WebCore/workers/service/context/SWContextManager.h (modified) (2 diffs)
• Source/WebCore/workers/service/context/ServiceWorkerInspectorProxy.cpp (modified) (2 diffs)
• Source/WebCore/workers/service/server/SWServer.cpp (modified) (4 diffs)
• Source/WebCore/workers/service/server/SWServer.h (modified) (2 diffs)
• Source/WebCore/workers/service/server/SWServerToContextConnection.cpp (modified) (1 diff)
• Source/WebCore/workers/service/server/SWServerToContextConnection.h (modified) (1 diff)
• Source/WebCore/workers/service/server/SWServerWorker.cpp (modified) (1 diff)
• Source/WebCore/workers/service/server/SWServerWorker.h (modified) (3 diffs)
• Source/WebKit/ChangeLog (modified) (1 diff)
• Source/WebKit/NetworkProcess/ServiceWorker/WebSWServerToContextConnection.messages.in (modified) (1 diff)
• Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.cpp (modified) (1 diff)
• Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.h (modified) (1 diff)
• Tools/ChangeLog (modified) (1 diff)
• Tools/TestWebKitAPI/Tests/WebKitCocoa/PushAPI.mm (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2022-03-18  Youenn Fablet  <youenn@apple.com>
+
+        Keep service workers alive when they are inspected even though they should be terminated
+        https://bugs.webkit.org/show_bug.cgi?id=237827
+        <rdar://88313935>
+
+        Reviewed by Alex Christensen.
+
+        Store in SWServerWorker whether a worker is inspected or is processing push events.
+        In that case, we delay termination of workers until it is no longer inspected or no longer processing push events.
+        Two code paths are happening:
+        1. A service worker was triggered with service worker clients, and all service worker clients are removed.
+           At that point, we were previously terminating service workers after a delay.
+           Instead, we now only terminate workers that are no longer inspected or no longer processing push events.
+           We reschedule the timer to continue trying removing the context connection.
+        2. A service worker is not stopped by removal of service worker clients. In that case, we need to terminate
+           the service workers when inspected and/or push counter gets back to regular (not inspected, no push counter).
+           When terminating such a service worker, we try removing the context connection as well.
+
+        To make sure SWServerWorker knows whether inspectable or not, we add connection support to transmit whether inspected from WebProcess.
+        ServiceWorkerInspectorProxy is responsible to update the inspectable value.
+        Introduce internals API to set inspected state of a service worker.
+
+        Covered by new API tests.
+
+        * testing/ServiceWorkerInternals.cpp:
+        * testing/ServiceWorkerInternals.h:
+        * testing/ServiceWorkerInternals.idl:
+        * workers/service/context/SWContextManager.cpp:
+        * workers/service/context/SWContextManager.h:
+        * workers/service/context/ServiceWorkerInspectorProxy.cpp:
+        * workers/service/server/SWServer.cpp:
+        * workers/service/server/SWServer.h:
+        * workers/service/server/SWServerToContextConnection.cpp:
+        * workers/service/server/SWServerToContextConnection.h:
+        * workers/service/server/SWServerWorker.cpp:
+        * workers/service/server/SWServerWorker.h:
+
 2022-03-17  Matt Woodrow  <mattwoodrow@apple.com>
 

trunk/Source/WebCore/testing/ServiceWorkerInternals.cpp

@@ -200 +200 @@
 }
 
+void ServiceWorkerInternals::setAsInspected(bool isInspected)
+{
+    SWContextManager::singleton().setAsInspected(m_identifier, isInspected);
+}
+
 } // namespace WebCore
 

trunk/Source/WebCore/testing/ServiceWorkerInternals.h

@@ -74 +74 @@
 
     String serviceWorkerClientInternalIdentifier(const ServiceWorkerClient&);
+    void setAsInspected(bool);
 
 private:

trunk/Source/WebCore/testing/ServiceWorkerInternals.idl

@@ -53 +53 @@
 
     DOMString serviceWorkerClientInternalIdentifier(ServiceWorkerClient client);
+
+    undefined setAsInspected(boolean isInspected);
 };

trunk/Source/WebCore/workers/service/context/SWContextManager.cpp

@@ -209 +209 @@
 }
 
+void SWContextManager::setAsInspected(ServiceWorkerIdentifier identifier, bool isInspected)
+{
+    if (m_connection)
+        m_connection->setAsInspected(identifier, isInspected);
+}
+
 } // namespace WebCore
 

trunk/Source/WebCore/workers/service/context/SWContextManager.h

@@ -70 +70 @@
 
         virtual void didFailHeartBeatCheck(ServiceWorkerIdentifier) = 0;
+        virtual void setAsInspected(ServiceWorkerIdentifier, bool) = 0;
 
         virtual bool isThrottleable() const = 0;
@@ -111 +112 @@
     static constexpr Seconds syncWorkerTerminationTimeout { 100_ms }; // Only used by layout tests.
 
+    WEBCORE_EXPORT void setAsInspected(ServiceWorkerIdentifier, bool);
+
 private:
     SWContextManager() = default;

trunk/Source/WebCore/workers/service/context/ServiceWorkerInspectorProxy.cpp

@@ -62 +62 @@
     m_channel = &channel;
 
+    SWContextManager::singleton().setAsInspected(m_serviceWorkerThreadProxy.identifier(), true);
     m_serviceWorkerThreadProxy.thread().runLoop().postDebuggerTask([] (ScriptExecutionContext& context) {
         downcast<WorkerGlobalScope>(context).inspectorController().connectFrontend();
@@ -72 +73 @@
     m_channel = nullptr;
 
+    SWContextManager::singleton().setAsInspected(m_serviceWorkerThreadProxy.identifier(), false);
     m_serviceWorkerThreadProxy.thread().runLoop().postDebuggerTask([] (ScriptExecutionContext& context) {
         downcast<WorkerGlobalScope>(context).inspectorController().disconnectFrontend(DisconnectReason::InspectorDestroyed);

trunk/Source/WebCore/workers/service/server/SWServer.cpp

@@ -1039 +1039 @@
             Vector<SWServerWorker*> workersToTerminate;
             for (auto& worker : m_runningOrTerminatingWorkers.values()) {
-                if (worker->isRunning() && worker->origin() == clientOrigin)
+                if (worker->isRunning() && worker->origin() == clientOrigin && !worker->shouldContinue())
                     workersToTerminate.append(worker.ptr());
             }
@@ -1045 +1045 @@
                 worker->terminate();
 
-            if (!m_clientsByRegistrableDomain.contains(clientRegistrableDomain)) {
-                if (auto* connection = contextConnectionForRegistrableDomain(clientRegistrableDomain)) {
-                    removeContextConnection(*connection);
-                    connection->connectionIsNoLongerNeeded();
-                }
+            if (removeContextConnectionIfPossible(clientRegistrableDomain) == ShouldDelayRemoval::Yes) {
+                auto iterator = m_clientIdentifiersPerOrigin.find(clientOrigin);
+                ASSERT(iterator != m_clientIdentifiersPerOrigin.end());
+                iterator->value.terminateServiceWorkersTimer->startOneShot(m_isProcessTerminationDelayEnabled ? defaultTerminationDelay : defaultPushMessageDuration);
+                return;
             }
 
@@ -1073 +1073 @@
 
     m_clientToControllingRegistration.remove(registrationIterator);
+}
+
+SWServer::ShouldDelayRemoval SWServer::removeContextConnectionIfPossible(const RegistrableDomain& domain)
+{
+    if (m_clientsByRegistrableDomain.contains(domain))
+        return ShouldDelayRemoval::No;
+
+    auto* connection = contextConnectionForRegistrableDomain(domain);
+    if (!connection)
+        return ShouldDelayRemoval::No;
+
+    for (auto& worker : m_runningOrTerminatingWorkers.values()) {
+        if (worker->isRunning() && worker->registrableDomain() == domain && worker->shouldContinue())
+            return ShouldDelayRemoval::Yes;
+    }
+
+    removeContextConnection(*connection);
+    connection->connectionIsNoLongerNeeded();
+    return ShouldDelayRemoval::No;
 }
 
@@ -1282 +1301 @@
 
             auto serviceWorkerIdentifier = worker->identifier();
-            auto terminateWorkerTimer = makeUnique<Timer>([worker = WTFMove(worker)] {
-                RELEASE_LOG_ERROR(ServiceWorker, "Terminating service worker as processing push event took too much time");
-                worker->terminate();
+
+            worker->incrementPushEventCounter();
+            auto terminateWorkerTimer = makeUnique<Timer>([worker] {
+                RELEASE_LOG_ERROR(ServiceWorker, "Service worker is taking too much time to process a push event");
+                worker->decrementPushEventCounter();
             });
-            terminateWorkerTimer->startOneShot(weakThis && weakThis->m_isProcessTerminationDelayEnabled ? defaultTerminationDelay : 2_s);
-            connectionOrStatus.value()->firePushEvent(serviceWorkerIdentifier, data, [callback = WTFMove(callback), terminateWorkerTimer = WTFMove(terminateWorkerTimer)](bool succeeded) mutable {
-                if (terminateWorkerTimer->isActive())
+            terminateWorkerTimer->startOneShot(weakThis && weakThis->m_isProcessTerminationDelayEnabled ? defaultTerminationDelay : defaultPushMessageDuration);
+            connectionOrStatus.value()->firePushEvent(serviceWorkerIdentifier, data, [callback = WTFMove(callback), terminateWorkerTimer = WTFMove(terminateWorkerTimer), worker = WTFMove(worker)](bool succeeded) mutable {
+                if (terminateWorkerTimer->isActive()) {
+                    worker->decrementPushEventCounter();
                     terminateWorkerTimer->stop();
+                }
 
                 callback(succeeded);

trunk/Source/WebCore/workers/service/server/SWServer.h

@@ -219 +219 @@
 
     static constexpr Seconds defaultTerminationDelay = 10_s;
+    static constexpr Seconds defaultPushMessageDuration = 2_s;
 
     LastNavigationWasAppInitiated clientIsAppInitiatedForRegistrableDomain(const RegistrableDomain&);
@@ -231 +232 @@
 
     void forEachServiceWorker(const Function<bool(const SWServerWorker&)>&) const;
+    bool hasClientsWithOrigin(const ClientOrigin& origin) { return m_clientIdentifiersPerOrigin.contains(origin); }
+
+    enum class ShouldDelayRemoval : bool { No, Yes };
+    ShouldDelayRemoval removeContextConnectionIfPossible(const RegistrableDomain&);
 
 private:

trunk/Source/WebCore/workers/service/server/SWServerToContextConnection.cpp

@@ -138 +138 @@
 }
 
+void SWServerToContextConnection::setAsInspected(ServiceWorkerIdentifier identifier, bool isInspected)
+{
+    if (auto* worker = SWServerWorker::existingWorkerForIdentifier(identifier))
+        worker->setAsInspected(isInspected);
+}
+
 void SWServerToContextConnection::terminateWhenPossible()
 {

trunk/Source/WebCore/workers/service/server/SWServerToContextConnection.h

@@ -80 +80 @@
     WEBCORE_EXPORT void setScriptResource(ServiceWorkerIdentifier, URL&& scriptURL, ServiceWorkerContextData::ImportedScript&&);
     WEBCORE_EXPORT void didFailHeartBeatCheck(ServiceWorkerIdentifier);
+    WEBCORE_EXPORT void setAsInspected(ServiceWorkerIdentifier, bool);
     WEBCORE_EXPORT void findClientByVisibleIdentifier(ServiceWorkerIdentifier, const String& clientIdentifier, CompletionHandler<void(std::optional<WebCore::ServiceWorkerClientData>&&)>&&);
 

trunk/Source/WebCore/workers/service/server/SWServerWorker.cpp

@@ -398 +398 @@
 }
 
+void SWServerWorker::decrementPushEventCounter()
+{
+    ASSERT(m_pushEventCounter);
+    --m_pushEventCounter;
+    terminateIfPossible();
+}
+
+void SWServerWorker::setAsInspected(bool isInspected)
+{
+    m_isInspected = isInspected;
+    terminateIfPossible();
+}
+
+void SWServerWorker::terminateIfPossible()
+{
+    if (m_pushEventCounter || m_isInspected || !m_server || m_server->hasClientsWithOrigin(origin()))
+        return;
+
+    terminate();
+    m_server->removeContextConnectionIfPossible(registrableDomain());
+}
+
 } // namespace WebCore
 

trunk/Source/WebCore/workers/service/server/SWServerWorker.h

@@ -136 +136 @@
     WorkerThreadMode workerThreadMode() const;
 
+    void incrementPushEventCounter() { ++m_pushEventCounter; }
+    void decrementPushEventCounter();
+    void setAsInspected(bool);
+
+    bool shouldContinue() const { return !!m_pushEventCounter || m_isInspected; }
+
 private:
     SWServerWorker(SWServer&, SWServerRegistration&, const URL&, const ScriptBuffer&, const CertificateInfo&, const ContentSecurityPolicyResponseHeaders&, const CrossOriginEmbedderPolicy&, String&& referrerPolicy, WorkerType, ServiceWorkerIdentifier, HashMap<URL, ServiceWorkerContextData::ImportedScript>&&);
@@ -145 +151 @@
     void terminationTimerFired();
     void callTerminationCallbacks();
+    void terminateIfPossible();
 
     WeakPtr<SWServer> m_server;
@@ -167 +174 @@
     Timer m_terminationTimer;
     LastNavigationWasAppInitiated m_lastNavigationWasAppInitiated;
+    int m_pushEventCounter { 0 };
+    bool m_isInspected { false };
 };
 

trunk/Source/WebKit/ChangeLog

@@ +1 @@
+2022-03-18  Youenn Fablet  <youenn@apple.com>
+
+        Keep service workers alive when they are inspected even though they should be terminated
+        https://bugs.webkit.org/show_bug.cgi?id=237827
+        <rdar://88313935>
+
+        Reviewed by Alex Christensen.
+
+        * NetworkProcess/ServiceWorker/WebSWServerToContextConnection.messages.in:
+        * WebProcess/Storage/WebSWContextManagerConnection.cpp:
+        * WebProcess/Storage/WebSWContextManagerConnection.h:
+
 2022-03-17  Alex Christensen  <achristensen@webkit.org>
 

trunk/Source/WebKit/NetworkProcess/ServiceWorker/WebSWServerToContextConnection.messages.in

@@ -39 +39 @@
     PostMessageToServiceWorkerClient(WebCore::ScriptExecutionContextIdentifier destination, struct WebCore::MessageWithMessagePorts message, WebCore::ServiceWorkerIdentifier source, String sourceOrigin)
     DidFailHeartBeatCheck(WebCore::ServiceWorkerIdentifier identifier)
+    SetAsInspected(WebCore::ServiceWorkerIdentifier identifier, bool isInspected)
 }
 

trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.cpp

@@ -373 +373 @@
 }
 
+void WebSWContextManagerConnection::setAsInspected(WebCore::ServiceWorkerIdentifier identifier, bool isInspected)
+{
+    m_connectionToNetworkProcess->send(Messages::WebSWServerToContextConnection::SetAsInspected { identifier, isInspected }, 0);
+}
+
 } // namespace WebCore
 

trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.h

@@ -86 +86 @@
     bool isThrottleable() const final;
     void didFailHeartBeatCheck(WebCore::ServiceWorkerIdentifier) final;
+    void setAsInspected(WebCore::ServiceWorkerIdentifier, bool) final;
 
     // IPC messages.

trunk/Tools/ChangeLog

@@ +1 @@
+2022-03-18  Youenn Fablet  <youenn@apple.com>
+
+        Keep service workers alive when they are inspected even though they should be terminated
+        https://bugs.webkit.org/show_bug.cgi?id=237827
+        <rdar://88313935>
+
+        Reviewed by Alex Christensen.
+
+        * TestWebKitAPI/Tests/WebKitCocoa/PushAPI.mm:
+
 2022-03-17  Jonathan Bedard  <JonWBedard@gmail.com>
 

trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/PushAPI.mm

@@ -368 +368 @@
     clearWebsiteDataStore([configuration websiteDataStore]);
 }
+
+#if WK_HAVE_C_SPI
+
+static const char* pushEventsAndInspectedServiceWorkerScriptBytes = R"SWRESOURCE(
+let port;
+self.addEventListener("message", (event) => {
+    port = event.data.port;
+    port.postMessage(self.internals ? "Ready" : "No internals");
+});
+self.addEventListener("push", (event) => {
+    self.registration.showNotification("notification");
+    if (event.data.text() === 'first') {
+        self.internals.setAsInspected(true);
+        self.previousMessageData = 'first';
+        return;
+    }
+    if (event.data.text() === 'second') {
+        self.internals.setAsInspected(false);
+        if (self.previousMessageData !== 'first')
+            event.waitUntil(Promise.reject('expected first'));
+        return;
+    }
+    if (event.data.text() === 'third') {
+        if (self.previousMessageData !== undefined)
+            event.waitUntil(Promise.reject('expected undefined'));
+        return;
+    }
+    self.previousMessageData = event.data.text();
+    event.waitUntil(Promise.reject('expected a known message'));
+});
+)SWRESOURCE";
+
+TEST(PushAPI, pushEventsAndInspectedServiceWorker)
+{
+    TestWebKitAPI::HTTPServer server({
+        { "/", { mainBytes } },
+        { "/sw.js", { {{ "Content-Type", "application/javascript" }}, pushEventsAndInspectedServiceWorkerScriptBytes } }
+    }, TestWebKitAPI::HTTPServer::Protocol::Http);
+
+    [WKWebsiteDataStore _allowWebsiteDataRecordsForAllOrigins];
+
+    auto configuration = adoptNS([[WKWebViewConfiguration alloc] init]);
+    clearWebsiteDataStore([configuration websiteDataStore]);
+
+    auto context = adoptWK(TestWebKitAPI::Util::createContextForInjectedBundleTest("InternalsInjectedBundleTest"));
+    [configuration setProcessPool:(WKProcessPool *)context.get()];
+
+    auto provider = TestWebKitAPI::TestNotificationProvider({ [[configuration processPool] _notificationManagerForTesting], WKNotificationManagerGetSharedServiceWorkerNotificationManager() });
+    provider.setPermission(server.origin(), true);
+
+    auto messageHandler = adoptNS([[PushAPIMessageHandlerWithExpectedMessage alloc] init]);
+    [[configuration userContentController] addScriptMessageHandler:messageHandler.get() name:@"sw"];
+
+    expectedMessage = "Ready";
+    auto webView = adoptNS([[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) configuration:configuration.get()]);
+    [webView loadRequest:server.request()];
+
+    TestWebKitAPI::Util::run(&done);
+
+    [webView _close];
+    webView = nullptr;
+
+    terminateNetworkProcessWhileRegistrationIsStored(configuration.get());
+
+    // Push event for service worker without any related page.
+    pushMessageProcessed = false;
+    pushMessageSuccessful = false;
+    NSString *message = @"first";
+    [[configuration websiteDataStore] _processPushMessage:messageDictionary([message dataUsingEncoding:NSUTF8StringEncoding], [server.request() URL]) completionHandler:^(bool result) {
+        pushMessageSuccessful = result;
+        pushMessageProcessed = true;
+    }];
+    TestWebKitAPI::Util::run(&pushMessageProcessed);
+    EXPECT_TRUE(pushMessageSuccessful);
+
+    pushMessageProcessed = false;
+    pushMessageSuccessful = false;
+    message = @"second";
+    [[configuration websiteDataStore] _processPushMessage:messageDictionary([message dataUsingEncoding:NSUTF8StringEncoding], [server.request() URL]) completionHandler:^(bool result) {
+        pushMessageSuccessful = result;
+        pushMessageProcessed = true;
+    }];
+    TestWebKitAPI::Util::run(&pushMessageProcessed);
+    EXPECT_TRUE(pushMessageSuccessful);
+
+    pushMessageProcessed = false;
+    pushMessageSuccessful = false;
+    message = @"third";
+    [[configuration websiteDataStore] _processPushMessage:messageDictionary([message dataUsingEncoding:NSUTF8StringEncoding], [server.request() URL]) completionHandler:^(bool result) {
+        pushMessageSuccessful = result;
+        pushMessageProcessed = true;
+    }];
+    TestWebKitAPI::Util::run(&pushMessageProcessed);
+    EXPECT_TRUE(pushMessageSuccessful);
+}
+
+static const char* inspectedServiceWorkerWithoutPageScriptBytes = R"SWRESOURCE(
+let port;
+self.addEventListener("message", (event) => {
+    port = event.data.port;
+    port.postMessage(self.internals ? "Ready" : "No internals");
+});
+self.addEventListener("push", async (event) => {
+    self.registration.showNotification("notification");
+    if (event.data.text() === 'firstmessage-inspected' || event.data.text() === 'firstmessage-not-inspected') {
+        if (event.data.text() === 'firstmessage-inspected')
+            self.internals.setAsInspected(true);
+        if (self.previousMessageData !== undefined)
+            event.waitUntil(Promise.reject('unexpected state with inspected message'));
+        self.previousMessageData = 'inspected';
+        // Wait for client to go away before resolving the event promise;
+        let resolve;
+        event.waitUntil(new Promise(r => resolve = r));
+        while (true) {
+            const clients = await self.clients.matchAll({ includeUncontrolled : true });
+            if (!clients.length)
+                resolve();
+        }
+        return;
+    }
+    if (event.data.text() === 'not inspected') {
+        setTimeout(() => self.internals.setAsInspected(false), 10);
+        if (self.previousMessageData !== 'inspected')
+            event.waitUntil(Promise.reject('unexpected state with not inspected message'));
+        self.previousMessageData = 'not inspected';
+        return;
+    }
+    if (event.data.text() === 'last') {
+        if (self.previousMessageData !== undefined)
+            event.waitUntil(Promise.reject('unexpected state with last message'));
+    }
+});
+)SWRESOURCE";
+
+static void testInspectedServiceWorkerWithoutPage(bool enableServiceWorkerInspection)
+{
+    TestWebKitAPI::HTTPServer server({
+        { "/", { mainBytes } },
+        { "/sw.js", { {{ "Content-Type", "application/javascript" }}, inspectedServiceWorkerWithoutPageScriptBytes } }
+    }, TestWebKitAPI::HTTPServer::Protocol::Http);
+
+    [WKWebsiteDataStore _allowWebsiteDataRecordsForAllOrigins];
+
+    auto dataStoreConfiguration = adoptNS([[_WKWebsiteDataStoreConfiguration alloc] init]);
+    [dataStoreConfiguration setServiceWorkerProcessTerminationDelayEnabled:NO];
+    auto dataStore = adoptNS([[WKWebsiteDataStore alloc] _initWithConfiguration:dataStoreConfiguration.get()]);
+
+    auto configuration = adoptNS([[WKWebViewConfiguration alloc] init]);
+    configuration.get().websiteDataStore = dataStore.get();
+    clearWebsiteDataStore([configuration websiteDataStore]);
+
+    auto context = adoptWK(TestWebKitAPI::Util::createContextForInjectedBundleTest("InternalsInjectedBundleTest"));
+    [configuration setProcessPool:(WKProcessPool *)context.get()];
+
+    auto provider = TestWebKitAPI::TestNotificationProvider({ [[configuration processPool] _notificationManagerForTesting], WKNotificationManagerGetSharedServiceWorkerNotificationManager() });
+    provider.setPermission(server.origin(), true);
+
+    auto messageHandler = adoptNS([[PushAPIMessageHandlerWithExpectedMessage alloc] init]);
+    [[configuration userContentController] addScriptMessageHandler:messageHandler.get() name:@"sw"];
+
+    expectedMessage = "Ready";
+    auto webView = adoptNS([[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) configuration:configuration.get()]);
+    [webView loadRequest:server.request()];
+
+    TestWebKitAPI::Util::run(&done);
+
+    // Push event for service worker without any related page.
+    pushMessageProcessed = false;
+    pushMessageSuccessful = false;
+    NSString *message = @"firstmessage-inspected";
+    if (!enableServiceWorkerInspection)
+        message = @"firstmessage-not-inspected";
+    [[configuration websiteDataStore] _processPushMessage:messageDictionary([message dataUsingEncoding:NSUTF8StringEncoding], [server.request() URL]) completionHandler:^(bool result) {
+        pushMessageSuccessful = result;
+        pushMessageProcessed = true;
+    }];
+
+    // We delay so that the push message will happen before the unregistration of the service worker client.
+    sleep(0.5);
+
+    // Closing the web view should not terminate the service worker as service worker is inspected.
+    [webView _close];
+    webView = nullptr;
+
+    TestWebKitAPI::Util::run(&pushMessageProcessed);
+    EXPECT_TRUE(pushMessageSuccessful);
+
+    // We delay so that the timer to terminate service worker kicks in, at most up to the max push message allowed time, aka 2 seconds.
+    sleep(3);
+
+    // Send message at which point the service worker will not be inspected anymore and will be closed.
+    pushMessageProcessed = false;
+    pushMessageSuccessful = false;
+    message = @"not inspected";
+    [[configuration websiteDataStore] _processPushMessage:messageDictionary([message dataUsingEncoding:NSUTF8StringEncoding], [server.request() URL]) completionHandler:^(bool result) {
+        pushMessageSuccessful = result;
+        pushMessageProcessed = true;
+    }];
+    TestWebKitAPI::Util::run(&pushMessageProcessed);
+    EXPECT_EQ(pushMessageSuccessful, enableServiceWorkerInspection);
+
+    // We delay so that the timer to terminate service worker kicks in, at most up to the max push message allowed time, aka 2 seconds.
+    sleep(3);
+
+    pushMessageProcessed = false;
+    pushMessageSuccessful = false;
+    message = @"last";
+    [[configuration websiteDataStore] _processPushMessage:messageDictionary([message dataUsingEncoding:NSUTF8StringEncoding], [server.request() URL]) completionHandler:^(bool result) {
+        pushMessageSuccessful = result;
+        pushMessageProcessed = true;
+    }];
+
+    TestWebKitAPI::Util::run(&pushMessageProcessed);
+    EXPECT_TRUE(pushMessageSuccessful);
+}
+
+TEST(PushAPI, inspectedServiceWorkerWithoutPage)
+{
+    bool enableServiceWorkerInspection = true;
+    testInspectedServiceWorkerWithoutPage(enableServiceWorkerInspection);
+}
+
+TEST(PushAPI, uninspectedServiceWorkerWithoutPage)
+{
+    bool enableServiceWorkerInspection = false;
+    testInspectedServiceWorkerWithoutPage(enableServiceWorkerInspection);
+}
+
+#endif // WK_HAVE_C_SPI